roxyapi 2.0.3

#![allow(clippy::large_enum_variant)]
#![allow(clippy::format_in_format_args)]
#![allow(clippy::let_unit_value)]
#![allow(unreachable_patterns)]
#![allow(clippy::too_many_arguments)]
use serde::{Deserialize, Serialize};
mod tri_state_serde {
    use serde::{Deserialize, Deserializer};
    pub fn deserialize<'de, D, T>(de: D) -> Result<Option<T>, D::Error>
    where
        D: Deserializer<'de>,
        T: Deserialize<'de>,
    {
        T::deserialize(de).map(Some)
    }
}
/// Response body of `detectYogas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct YogaDetectResponse {
    /// Echo of the resolved birth data used for detection. Timezone is the numeric offset that the chart engine consumed (IANA names are resolved upstream).
    #[serde(rename = "birthDetails")]
    pub birth_details: YogaDetectResponseBirthDetails,
    /// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
    pub frame: YogaDetectResponseFrame,
    /// Count of yogas where present === true in this chart. Range 0-48, though real charts sit in the low single digits: the Nabhasa families are mutually constrained by the precedence norms, and most shape yogas are rare.
    pub total: f64,
    /// Array of 48 detected yogas, always the full set so a caller can render absent verdicts too. Every entry carries a `present` boolean and a `quality` (Positive, Negative, or Both = auspicious, inauspicious, or context-dependent); filter on present === true for active yogas. Evidence text names the rule that triggered or failed, or the precedence norm that outranked it.
    pub yogas: Vec<YogaDetectResponseYogasItem>,
}
/// One entry of `yogas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct YogaDetectResponseYogasItem {
    /// Brief classical formation rule. Identifies the planetary placement, lordship, dignity, aspect pattern, sign modality, or whole-chart bhava distribution required for the yoga to form.
    pub description: String,
    /// Human-readable rationale naming the specific rule that triggered or failed the detection, including planetary positions, dignity, kendradhipati status, lordship, malefic drishti, sign modality, or whole-chart bhava distribution. For a Nabhasa yoga that matched its own rule but was outranked, this names the precedence norm that silenced it, for example that an Akriti yoga outranks Asraya or that any other Nabhasa family suppresses Sankhya. English in every language, like the per-graha stateSource on POST /daily, because it is provenance to be checked against a text rather than display copy.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub evidence: Option<String>,
    /// Classical grouping, ALWAYS present on a detection verdict: one of the four Nabhasa families (asraya, dala, akriti, sankhya) or classical for the twelve single-combination yogas such as Gajakesari and the Pancha Mahapurusha. Group the verdict list on this key to render a Nabhasa result the way the tradition arranges it. Never translated, so grouping works identically under any lang.
    pub family: YogaDetectResponseYogasItemFamily,
    /// Glossary id (lowercase, kebab-case) matching an entry in the 301-entry planetary-yoga catalog. Use with GET /yoga/{id} to retrieve the full glossary text.
    pub id: String,
    /// Classical Sanskrit name of the yoga as referenced in BPHS (Brihat Parashara Hora Shastra), Phaladeepika, and B.V. Raman *Three Hundred Important Combinations*.
    pub name: String,
    /// True if every classical condition for the yoga is satisfied by the given chart. False means one of TWO different things: the rule failed, or the rule held and a stronger family outranked it. Read `suppressedBy` to tell those apart, which is exact and locale-independent; `evidence` says the same thing in English prose.
    pub present: bool,
    /// Overall nature. Auspicious yogas (Pancha Mahapurusha, Gajakesari) bestow benefits; inauspicious yogas (Kemadruma) indicate challenges; Both denotes context-dependent effects.
    pub quality: YogaDetectResponseYogasItemQuality,
    /// Classical phala (life-effect) description of the yoga when present, sourced from the parashari and phaladeepika tradition.
    pub result: String,
    /// Set ONLY when this yoga matched its own classical rule and was then silenced by a higher-ranking family, so `present` is false for a reason a practitioner reads very differently from a failed rule. Names the family that took precedence, under the four classical norms: Akriti outranks Asraya, and Akriti, Asraya and Dala each outrank Sankhya. Absent means the rule genuinely did not hold.
    #[serde(rename = "suppressedBy", skip_serializing_if = "Option::is_none")]
    pub suppressed_by: Option<YogaDetectResponseYogasItemSuppressedBy>,
}
string_enum! {
    /// Set ONLY when this yoga matched its own classical rule and was then silenced by a higher-ranking family, so `present` is false for a reason a practitioner reads very differently from a failed rule. Names the family that took precedence, under the four classical norms: Akriti outranks Asraya, and Akriti, Asraya and Dala each outrank Sankhya. Absent means the rule genuinely did not hold.
    YogaDetectResponseYogasItemSuppressedBy {
        Classical = "classical",
        Asraya = "asraya",
        Dala = "dala",
        Akriti = "akriti",
        Sankhya = "sankhya",
    }
}
string_enum! {
    /// Overall nature. Auspicious yogas (Pancha Mahapurusha, Gajakesari) bestow benefits; inauspicious yogas (Kemadruma) indicate challenges; Both denotes context-dependent effects.
    YogaDetectResponseYogasItemQuality {
        Positive = "Positive",
        Negative = "Negative",
        Both = "Both",
    }
}
string_enum! {
    /// Classical grouping, ALWAYS present on a detection verdict: one of the four Nabhasa families (asraya, dala, akriti, sankhya) or classical for the twelve single-combination yogas such as Gajakesari and the Pancha Mahapurusha. Group the verdict list on this key to render a Nabhasa result the way the tradition arranges it. Never translated, so grouping works identically under any lang.
    YogaDetectResponseYogasItemFamily {
        Classical = "classical",
        Asraya = "asraya",
        Dala = "dala",
        Akriti = "akriti",
        Sankhya = "sankhya",
    }
}
/// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct YogaDetectResponseFrame {
    /// Sidereal frame this chart was cast in, echoing the ayanamsa request field. "lahiri" when the field was omitted.
    pub ayanamsa: String,
    /// Degrees actually subtracted from every tropical longitude to produce this chart, read at the birth instant. Subtract it back to recover the tropical positions, or compare it against your reference software to confirm you are in the same frame before chasing a placement difference.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
}
/// Echo of the resolved birth data used for detection. Timezone is the numeric offset that the chart engine consumed (IANA names are resolved upstream).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct YogaDetectResponseBirthDetails {
    /// Birth date the kundli was cast for, YYYY-MM-DD, echoed back from the request.
    pub date: String,
    /// Birth latitude in decimal degrees, echoed back from the request. Feeds the local sidereal time behind the Lagna.
    pub latitude: f64,
    /// Birth longitude in decimal degrees, echoed back from the request. East is positive, west is negative.
    pub longitude: f64,
    /// Birth time the kundli was cast for, 24-hour HH:MM:SS, echoed back from the request. Lagna moves roughly one rashi every two hours, so this is what pins the bhava-dependent yogas.
    pub time: String,
    /// Numeric UTC offset in decimal hours that the chart engine actually consumed. An IANA name sent on the request is resolved to its DST-correct offset upstream, so this is always a number.
    pub timezone: f64,
}
/// Request body of `detectYogas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct YogaDetectRequest {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<YogaDetectRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<YogaDetectRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum YogaDetectRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    YogaDetectRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Response body of `getYoga`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct YogaDetail {
    /// Brief classical formation rule. Identifies the planetary placement, lordship, dignity, aspect pattern, sign modality, or whole-chart bhava distribution required for the yoga to form.
    pub description: String,
    /// Nabhasa family this yoga belongs to, present only on the 32 Nabhasa distribution yogas: asraya (3, sign modality), dala (2, benefic or malefic kendra tenancy), akriti (20, bhava shape) and sankhya (7, count of occupied rasis). Absent on every other glossary row, which is most of the catalog, since those are single-combination yogas outside the Nabhasa scheme. Group or filter the catalog on this key; it is never translated.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub family: Option<YogaDetailFamily>,
    /// Glossary id (lowercase, kebab-case) matching an entry in the 301-entry planetary-yoga catalog. Use with GET /yoga/{id} to retrieve the full glossary text.
    pub id: String,
    /// Classical Sanskrit name of the yoga as referenced in BPHS (Brihat Parashara Hora Shastra), Phaladeepika, and B.V. Raman *Three Hundred Important Combinations*.
    pub name: String,
    /// Overall nature. Auspicious yogas (Pancha Mahapurusha, Gajakesari) bestow benefits; inauspicious yogas (Kemadruma) indicate challenges; Both denotes context-dependent effects.
    pub quality: YogaDetailQuality,
    /// Classical phala (life-effect) description of the yoga when present, sourced from the parashari and phaladeepika tradition.
    pub result: String,
}
string_enum! {
    /// Overall nature. Auspicious yogas (Pancha Mahapurusha, Gajakesari) bestow benefits; inauspicious yogas (Kemadruma) indicate challenges; Both denotes context-dependent effects.
    YogaDetailQuality {
        Positive = "Positive",
        Negative = "Negative",
        Both = "Both",
    }
}
string_enum! {
    /// Nabhasa family this yoga belongs to, present only on the 32 Nabhasa distribution yogas: asraya (3, sign modality), dala (2, benefic or malefic kendra tenancy), akriti (20, bhava shape) and sankhya (7, count of occupied rasis). Absent on every other glossary row, which is most of the catalog, since those are single-combination yogas outside the Nabhasa scheme. Group or filter the catalog on this key; it is never translated.
    YogaDetailFamily {
        Classical = "classical",
        Asraya = "asraya",
        Dala = "dala",
        Akriti = "akriti",
        Sankhya = "sankhya",
    }
}
/// Complete upagraha positions for a birth chart
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct UpagrahaResponse {
    /// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
    pub frame: UpagrahaResponseFrame,
    /// Sun-longitude-based upagrahas (Dhuma group). Pure arithmetic from the Sun sidereal position. Dhuma = Sun + 133d20m, then each derived from the previous.
    #[serde(rename = "sunBased")]
    pub sun_based: Vec<UpagrahaResponseSunBasedItem>,
    /// Time-based upagrahas derived from the 8-part division of day or night. Gulika and Mandi are from Saturn segment, others from Sun, Mars, Mercury, Jupiter segments. Positions depend on birth time, location, and weekday.
    #[serde(rename = "timeBased")]
    pub time_based: Vec<UpagrahaResponseTimeBasedItem>,
}
/// Position details for a single upagraha (sub-planet)
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct UpagrahaResponseTimeBasedItem {
    /// Degree position within the occupied rashi (0 to 30).
    #[serde(rename = "degreeInSign")]
    pub degree_in_sign: f64,
    /// Sidereal longitude in degrees (0 to 360). Used for house placement and aspect analysis.
    pub longitude: f64,
    /// Nakshatra (lunar mansion) the upagraha occupies. One of 27 Vedic nakshatras.
    pub nakshatra: String,
    /// Nakshatra number (1 to 27). Ashwini = 1, Bharani = 2, through Revati = 27.
    #[serde(rename = "nakshatraIndex")]
    pub nakshatra_index: f64,
    /// Pada (quarter) within the nakshatra (1 to 4). Each pada spans 3 degrees 20 minutes.
    #[serde(rename = "nakshatraPada")]
    pub nakshatra_pada: f64,
    /// Upagraha name. Time-based: Gulika, Mandi, Kala, Mrityu, Ardhaprahara, Yamaghantaka. Sun-based: Dhuma, Vyatipata, Parivesha, Indra Chapa, Upaketu.
    pub name: String,
    /// Zodiac sign (rashi) the upagraha occupies. One of 12 Vedic rashis from Aries to Pisces.
    pub rashi: String,
}
/// Position details for a single upagraha (sub-planet)
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct UpagrahaResponseSunBasedItem {
    /// Degree position within the occupied rashi (0 to 30).
    #[serde(rename = "degreeInSign")]
    pub degree_in_sign: f64,
    /// Sidereal longitude in degrees (0 to 360). Used for house placement and aspect analysis.
    pub longitude: f64,
    /// Nakshatra (lunar mansion) the upagraha occupies. One of 27 Vedic nakshatras.
    pub nakshatra: String,
    /// Nakshatra number (1 to 27). Ashwini = 1, Bharani = 2, through Revati = 27.
    #[serde(rename = "nakshatraIndex")]
    pub nakshatra_index: f64,
    /// Pada (quarter) within the nakshatra (1 to 4). Each pada spans 3 degrees 20 minutes.
    #[serde(rename = "nakshatraPada")]
    pub nakshatra_pada: f64,
    /// Upagraha name. Time-based: Gulika, Mandi, Kala, Mrityu, Ardhaprahara, Yamaghantaka. Sun-based: Dhuma, Vyatipata, Parivesha, Indra Chapa, Upaketu.
    pub name: String,
    /// Zodiac sign (rashi) the upagraha occupies. One of 12 Vedic rashis from Aries to Pisces.
    pub rashi: String,
}
/// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct UpagrahaResponseFrame {
    /// Sidereal frame this chart was cast in, echoing the ayanamsa request field. "lahiri" when the field was omitted.
    pub ayanamsa: String,
    /// Degrees actually subtracted from every tropical longitude to produce this chart, read at the birth instant. Subtract it back to recover the tropical positions, or compare it against your reference software to confirm you are in the same frame before chasing a placement difference.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
}
/// Request body of `getUpagrahaPositions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct UpagrahaRequest {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<UpagrahaRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<UpagrahaRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum UpagrahaRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    UpagrahaRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Response body of `calculateTransits`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct TransitsResponse {
    /// Transit aspect summary counts (only included when natalChart is provided). Quick overview of the current transit weather.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub summary: Option<TransitsResponseSummary>,
    /// Timezone offset from UTC in hours used for this calculation.
    pub timezone: f64,
    /// Transit-to-natal aspects (only included when natalChart is provided in the request). Shows which transiting planets are aspecting natal planets.
    #[serde(rename = "transitAspects", skip_serializing_if = "Option::is_none")]
    pub transit_aspects: Option<Vec<TransitsResponseTransitAspectsItem>>,
    /// Date of the transit calculation (YYYY-MM-DD).
    #[serde(rename = "transitDate")]
    pub transit_date: String,
    /// Current positions of all 14 celestial bodies (10 classical planets, lunar nodes, Chiron, Black Moon Lilith) in the tropical zodiac. Use for daily transit tracking, horoscope generation, and aspect monitoring.
    #[serde(rename = "transitPlanets")]
    pub transit_planets: Vec<TransitsResponseTransitPlanetsItem>,
    /// Time of the transit calculation (HH:MM:SS, 24-hour).
    #[serde(rename = "transitTime")]
    pub transit_time: String,
}
/// One entry of `transitPlanets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct TransitsResponseTransitPlanetsItem {
    /// Degree within the current zodiac sign (0-29.999). Indicates how far into the sign the planet has progressed.
    pub degree: f64,
    /// Whether the planet is currently in apparent retrograde motion. Retrograde transits are considered more introspective and revisionary.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Apparent geocentric ecliptic latitude of date, in degrees. Near zero for most planets except Moon and Pluto.
    pub latitude: f64,
    /// Apparent geocentric tropical longitude on the true ecliptic of date, in degrees (0-360): light time and aberration applied, nutation included, the convention desktop chart software and the NASA JPL Horizons observer tables print, so it compares directly with either. Primary coordinate for sign and aspect calculation.
    pub longitude: f64,
    /// Planet name (Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto, North Node, South Node, Chiron, Black Moon Lilith). Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees. The lunar nodes follow the request nodeType, which defaults to the true (osculating) node; pass "mean" for the smoothed node. The two differ by up to about 1.8 degrees and no other body is affected. Black Moon Lilith is always the mean lunar apogee, whatever nodeType says. POST /lilith returns the mean and the true (osculating) apogee side by side, each labelled by its variant.
    pub name: String,
    /// Planet name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tropical zodiac sign the planet currently occupies. Changes when longitude crosses a 30-degree boundary. Always English, whatever the lang parameter says. Use signLocalized for anything a reader sees.
    pub sign: String,
    /// Zodiac sign name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
    /// Daily motion in degrees per day. Negative values indicate retrograde motion.
    pub speed: f64,
}
/// One entry of `transitAspects`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct TransitsResponseTransitAspectsItem {
    /// Exact angle of this aspect type in degrees.
    pub angle: f64,
    /// Rich interpretation of the transit aspect including narrative summary, timing, impact assessment, practical guidance, and keywords.
    pub interpretation: TransitsResponseTransitAspectsItemInterpretation,
    /// Whether the transiting planet is moving toward exactitude (applying) or away from it (separating). Applying aspects grow stronger.
    #[serde(rename = "isApplying")]
    pub is_applying: bool,
    /// Natal planet being aspected. Always English, whatever the lang parameter says. Use natalPlanetLocalized for anything a reader sees.
    #[serde(rename = "natalPlanet")]
    pub natal_planet: String,
    /// Natal planet name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "natalPlanetLocalized", skip_serializing_if = "Option::is_none")]
    pub natal_planet_localized: Option<String>,
    /// Aspect nature: harmonious (trine, sextile), challenging (square, opposition), or neutral (conjunction).
    pub nature: String,
    /// Distance from exact aspect in degrees. Tighter orb = stronger influence.
    pub orb: f64,
    /// Aspect strength percentage (0-100) based on orb tightness, where 100 is exact.
    pub strength: f64,
    /// Transiting planet forming the aspect. Always English, whatever the lang parameter says. Use transitPlanetLocalized for anything a reader sees.
    #[serde(rename = "transitPlanet")]
    pub transit_planet: String,
    /// Transiting planet name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "transitPlanetLocalized", skip_serializing_if = "Option::is_none")]
    pub transit_planet_localized: Option<String>,
    /// Aspect type (CONJUNCTION, OPPOSITION, TRINE, SQUARE, SEXTILE, etc.). Always English, whatever the lang parameter says. Use typeLocalized for anything a reader sees.
    pub r#type: String,
    /// Aspect type name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "typeLocalized", skip_serializing_if = "Option::is_none")]
    pub type_localized: Option<String>,
}
/// Rich interpretation of the transit aspect including narrative summary, timing, impact assessment, practical guidance, and keywords.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct TransitsResponseTransitAspectsItemInterpretation {
    /// Practical advice for working with or navigating this transit energy.
    pub guidance: String,
    /// Strength and nature of the transit impact on your natal chart.
    pub impact: String,
    /// Key themes activated by this transit aspect.
    pub keywords: Vec<String>,
    /// Narrative interpretation of what this transit aspect means and how it manifests.
    pub summary: String,
    /// How long this transit influence lasts, localized. The bucket follows the speed of the transiting body: a few hours for the Moon, a few days for the Sun, Mercury, Venus and Mars, one to two weeks for Jupiter, several weeks for Saturn, and an extended period for Uranus, Neptune and Pluto.
    pub timing: String,
}
/// Transit aspect summary counts (only included when natalChart is provided). Quick overview of the current transit weather.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct TransitsResponseSummary {
    /// Count of challenging aspects (square, opposition).
    pub challenging: f64,
    /// Count of harmonious aspects (trine, sextile).
    pub harmonious: f64,
    /// Count of neutral aspects (conjunction).
    pub neutral: f64,
    /// Total transit-to-natal aspects found.
    #[serde(rename = "totalAspects")]
    pub total_aspects: f64,
}
/// Request body of `calculateTransits`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct TransitsRequest {
    /// Transit date in YYYY-MM-DD format (defaults to current date)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Optional natal chart data to compare transits against
    #[serde(rename = "natalChart", skip_serializing_if = "Option::is_none")]
    pub natal_chart: Option<TransitsRequestNatalChart>,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<TransitsRequestNodeType>,
    /// Transit time in HH:MM:SS format (defaults to current time)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub time: Option<String>,
    /// Transit timezone: decimal hours from UTC OR IANA name (e.g. "America/New_York"). IANA resolved to the DST-correct offset for the transit date. Defaults to 0 (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<TransitsRequestTimezone>,
}
/// Transit timezone: decimal hours from UTC OR IANA name (e.g. "America/New_York"). IANA resolved to the DST-correct offset for the transit date. Defaults to 0 (UTC).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum TransitsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    TransitsRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Optional natal chart data to compare transits against
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct TransitsRequestNatalChart {
    /// Date in YYYY-MM-DD format. A single-digit month or day is accepted and zero-padded (2026-3-5 becomes 2026-03-05). Impossible calendar dates are rejected. Calculations that read planetary positions support 1550-01-02 to 2650-01-22; outside that span they answer 400 with code date_out_of_range, and a calculation that reads a window around the date (a sunrise search, a run of days) may answer the same 400 for a date within a few days of either end.
    pub date: String,
    /// Natal birth latitude in decimal degrees, positive north. Sets the local sidereal time behind the natal Ascendant and house cusps that the transits are measured against.
    pub latitude: f64,
    /// Natal birth longitude in decimal degrees, positive east and negative west. Example: New York -74.0060, London -0.1276, Sydney 151.2093.
    pub longitude: f64,
    /// Time in 24-hour format. Seconds are optional and default to 00 (14:30 becomes 14:30:00); a single-digit hour is zero-padded. Out-of-range values are rejected.
    pub time: String,
    /// Natal timezone: decimal hours OR IANA name (e.g. "America/New_York"). IANA resolved to the DST-correct offset for the natal date.
    pub timezone: TransitsRequestNatalChartTimezone,
}
/// Natal timezone: decimal hours OR IANA name (e.g. "America/New_York"). IANA resolved to the DST-correct offset for the natal date.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum TransitsRequestNatalChartTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
/// Response body of `generateSolarArc`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct SolarArcResponse {
    /// Echo of the birth moment and place used to compute the natal chart and the solar arc.
    #[serde(rename = "birthDetails")]
    pub birth_details: SolarArcResponseBirthDetails,
    /// Every natal point advanced by the solar arc: the planets and bodies in canonical order first, then the Ascendant and the Midheaven.
    pub directed: Vec<SolarArcResponseDirectedItem>,
    /// The solar arc in degrees: the secondary-progressed Sun longitude minus the natal Sun longitude. Approximately one degree per year of life. Every natal point is advanced by exactly this arc.
    #[serde(rename = "solarArc")]
    pub solar_arc: f64,
    /// Short overview of the directed chart for previews and report intros. Localized to the requested language.
    pub summary: String,
    /// Echo of the date the chart was directed to.
    #[serde(rename = "targetDate")]
    pub target_date: String,
}
/// One entry of `directed`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct SolarArcResponseDirectedItem {
    /// Degree of the directed point within its zodiac sign (0 to 29.999).
    pub degree: f64,
    /// Absolute tropical ecliptic longitude after directing, in degrees (0 to 360). Equals the natal longitude plus the solar arc, normalized to a full circle.
    #[serde(rename = "directedLongitude")]
    pub directed_longitude: f64,
    /// Plain language meaning of this directed point, suitable for chart reports and AI agents. Localized to the requested language.
    pub interpretation: String,
    /// Name of the directed point, covering the planets and the two angles, the Ascendant and the Midheaven, alike. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Directed point name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Absolute tropical ecliptic longitude of the point in the natal chart, in degrees (0 to 360).
    #[serde(rename = "natalLongitude")]
    pub natal_longitude: f64,
    /// Tropical zodiac sign the directed point falls in. A directed point crossing into a new sign marks a developmental turning point.
    pub sign: String,
}
/// Echo of the birth moment and place used to compute the natal chart and the solar arc.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct SolarArcResponseBirthDetails {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone offset from UTC in decimal hours, resolved for the birth date. Examples: New York = -5 in winter and -4 in summer, London = 0, India = 5.5, Tokyo = 9.
    pub timezone: f64,
}
/// Request body of `generateSolarArc`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct SolarArcRequest {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<SolarArcRequestNodeType>,
    /// Date to direct the chart to, in YYYY-MM-DD format. Every natal point is advanced by the solar arc accumulated from birth to this date, about one degree for each year of life.
    #[serde(rename = "targetDate")]
    pub target_date: String,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
    pub timezone: SolarArcRequestTimezone,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum SolarArcRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    SolarArcRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Complete Shadbala (six-fold planetary strength) analysis for a birth chart per Brihat Parashara Hora Shastra (BPHS).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ShadbalaResponse {
    /// Localized name and one-line meaning for each of the six Shadbala components, keyed by the same field names each planet entry uses. Join it to render a readable strength breakdown in any of the eight supported languages instead of showing six untranslated Sanskrit terms.
    #[serde(rename = "balaThemes")]
    pub bala_themes: ShadbalaResponseBalaThemes,
    /// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
    pub frame: ShadbalaResponseFrame,
    /// Shadbala analysis for all 7 classical planets. Ordered: Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn. Each entry contains all 6 strength components, total strength in virupas and Rupas, Ishta/Kashta Phala, minimum required threshold, strength ratio, and relative rank.
    pub planets: Vec<ShadbalaResponsePlanetsItem>,
}
/// Shadbala (six-fold strength) analysis for a single planet with all components, totals, Ishta/Kashta Phala, and relative ranking.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ShadbalaResponsePlanetsItem {
    /// Chesta Bala (Motional Strength) in virupas. Based on planetary motion, so a retrograde graha scores higher because it is closer to Earth and working hardest. The Sun uses its Ayana Bala and the Moon its elongation from the Sun, per BPHS. Mars, Mercury, Jupiter, Venus and Saturn use the Sheeghra Kendra, the arc between the sheeghrochcha and the mean of the true and mean longitudes, with the roles of the mean Sun and the graha swapped for Mercury and Venus. Range 0 to 60.
    #[serde(rename = "chestaBala")]
    pub chesta_bala: f64,
    /// Dig Bala (Directional Strength) in virupas. Based on angular distance from the planets directional strength house. Sun and Mars are strong at MC (10th), Moon and Venus at IC (4th), Mercury and Jupiter at ASC (1st), Saturn at DSC (7th). Range 0 to 60.
    #[serde(rename = "digBala")]
    pub dig_bala: f64,
    /// Drik Bala (Aspectual Strength) in virupas. Strength gained or lost from the aspects a graha receives. Benefic aspects add strength and malefic aspects reduce it, so this value is negative when malefics dominate. Mercury counts as benefic or malefic by the company it keeps in its own sign, decided by count with the nearest graha breaking a tie, and the Moon by its paksha. Uses the graded Sputa Drishti curve of BPHS Ch. 26 with the Vishesha (special) aspects of Mars, Jupiter and Saturn applied at their precise DEGREE ranges rather than by whole sign.
    #[serde(rename = "drikBala")]
    pub drik_bala: f64,
    /// Ishta Phala (auspicious strength) in virupas. Derived from Uchcha Bala and Chesta Bala: sqrt(ucchaBala * chestaBala). Indicates the planets capacity to produce favorable results during its dasha and transit periods.
    #[serde(rename = "ishtaPhala")]
    pub ishta_phala: f64,
    /// Kala Bala (Temporal Strength) in virupas. Sum of 8 sub-components: Nathonnatha (day/night strength), Paksha (lunar phase), Tribhaga (third of day/night), Vara (weekday lord), Hora (planetary hour), Abda (year lord), Masa (month lord), and Ayana (declination-based seasonal strength).
    #[serde(rename = "kalaBala")]
    pub kala_bala: f64,
    /// Kashta Phala (malefic strength) in virupas. Derived from complements of Uchcha and Chesta Bala: sqrt((60 - ucchaBala) * (60 - chestaBala)). Indicates the planets capacity to produce unfavorable results. Zero when both Uchcha and Chesta exceed 60.
    #[serde(rename = "kashtaPhala")]
    pub kashta_phala: f64,
    /// Minimum required strength in Rupas per BPHS. Sun 5.0, Moon 6.0, Mars 5.0, Mercury 7.0, Jupiter 6.5, Venus 5.5, Saturn 5.0. A planet below its minimum is considered weak and may underperform in its dasha periods.
    #[serde(rename = "minRequired")]
    pub min_required: f64,
    /// Naisargika Bala (Natural Strength) in virupas. Fixed luminosity-based values per BPHS: Sun 60.00, Moon 51.43, Venus 42.86, Jupiter 34.29, Mercury 25.71, Mars 17.14, Saturn 8.57. Invariant across all charts.
    #[serde(rename = "naisargikaBala")]
    pub naisargika_bala: f64,
    /// Planet name. One of the 7 classical Vedic planets (Saptgraha): Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn. Rahu and Ketu are excluded from Shadbala per BPHS.
    pub planet: String,
    /// Relative strength rank among the 7 planets (1 = strongest, 7 = weakest). Ranked by strengthRatio (actual/required), not raw virupas, so each planet is compared fairly against its own BPHS threshold.
    #[serde(rename = "relativeRank")]
    pub relative_rank: f64,
    /// Sthana Bala (Positional Strength) in virupas. Sum of 5 sub-components: Uchcha Bala (exaltation strength), Saptavargaja Bala (7-divisional friendship), Ojayugma Bala (odd/even sign placement), Kendradi Bala (angular house strength), and Drekkana Bala (decanate gender match). Higher values indicate stronger positional placement.
    #[serde(rename = "sthanaBala")]
    pub sthana_bala: f64,
    /// Ratio of actual Rupas to minimum required (totalRupas / minRequired). Values above 1.0 indicate sufficient strength. Higher ratios mean proportionally stronger planets. Used for ranking planets by relative strength.
    #[serde(rename = "strengthRatio")]
    pub strength_ratio: f64,
    /// Total Shadbala in Rupas (totalVirupas / 60). 1 Rupa equals 60 virupas. Rupas are the standard unit for comparing planetary strength against minimum required thresholds.
    #[serde(rename = "totalRupas")]
    pub total_rupas: f64,
    /// Total Shadbala in virupas (Shashtiamsas). Sum of all 6 strength components. Higher total indicates a stronger planet in the birth chart. Used for comparing relative planetary strength and evaluating dasha period potential.
    #[serde(rename = "totalVirupas")]
    pub total_virupas: f64,
}
/// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ShadbalaResponseFrame {
    /// Sidereal frame this chart was cast in, echoing the ayanamsa request field. "lahiri" when the field was omitted.
    pub ayanamsa: String,
    /// Degrees actually subtracted from every tropical longitude to produce this chart, read at the birth instant. Subtract it back to recover the tropical positions, or compare it against your reference software to confirm you are in the same frame before chasing a placement difference.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
}
/// Localized name and one-line meaning for each of the six Shadbala components, keyed by the same field names each planet entry uses. Join it to render a readable strength breakdown in any of the eight supported languages instead of showing six untranslated Sanskrit terms.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ShadbalaResponseBalaThemes {
    /// Localized label and meaning for one Shadbala component.
    #[serde(rename = "chestaBala")]
    pub chesta_bala: ShadbalaResponseBalaThemesChestaBala,
    /// Localized label and meaning for one Shadbala component.
    #[serde(rename = "digBala")]
    pub dig_bala: ShadbalaResponseBalaThemesDigBala,
    /// Localized label and meaning for one Shadbala component.
    #[serde(rename = "drikBala")]
    pub drik_bala: ShadbalaResponseBalaThemesDrikBala,
    /// Localized label and meaning for one Shadbala component.
    #[serde(rename = "kalaBala")]
    pub kala_bala: ShadbalaResponseBalaThemesKalaBala,
    /// Localized label and meaning for one Shadbala component.
    #[serde(rename = "naisargikaBala")]
    pub naisargika_bala: ShadbalaResponseBalaThemesNaisargikaBala,
    /// Localized label and meaning for one Shadbala component.
    #[serde(rename = "sthanaBala")]
    pub sthana_bala: ShadbalaResponseBalaThemesSthanaBala,
}
/// Localized label and meaning for one Shadbala component.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ShadbalaResponseBalaThemesSthanaBala {
    /// One-line localized explanation of what this component measures.
    pub meaning: String,
    /// Localized name of this Shadbala component, suitable for a table header or a bar label.
    pub name: String,
}
/// Localized label and meaning for one Shadbala component.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ShadbalaResponseBalaThemesNaisargikaBala {
    /// One-line localized explanation of what this component measures.
    pub meaning: String,
    /// Localized name of this Shadbala component, suitable for a table header or a bar label.
    pub name: String,
}
/// Localized label and meaning for one Shadbala component.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ShadbalaResponseBalaThemesKalaBala {
    /// One-line localized explanation of what this component measures.
    pub meaning: String,
    /// Localized name of this Shadbala component, suitable for a table header or a bar label.
    pub name: String,
}
/// Localized label and meaning for one Shadbala component.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ShadbalaResponseBalaThemesDrikBala {
    /// One-line localized explanation of what this component measures.
    pub meaning: String,
    /// Localized name of this Shadbala component, suitable for a table header or a bar label.
    pub name: String,
}
/// Localized label and meaning for one Shadbala component.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ShadbalaResponseBalaThemesDigBala {
    /// One-line localized explanation of what this component measures.
    pub meaning: String,
    /// Localized name of this Shadbala component, suitable for a table header or a bar label.
    pub name: String,
}
/// Localized label and meaning for one Shadbala component.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ShadbalaResponseBalaThemesChestaBala {
    /// One-line localized explanation of what this component measures.
    pub meaning: String,
    /// Localized name of this Shadbala component, suitable for a table header or a bar label.
    pub name: String,
}
/// Request body of `calculateShadbala`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ShadbalaRequest {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<ShadbalaRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<ShadbalaRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum ShadbalaRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    ShadbalaRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Response body of `searchDreamSymbols`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct SearchDreamSymbolsResponse {
    /// Page size used for this response.
    pub limit: f64,
    /// Number of symbols skipped. Use with limit for pagination.
    pub offset: f64,
    /// Dream symbols for the current page, in alphabetical order by name. With q, symbols whose name starts with the query come first, then names containing it, then symbols whose meaning mentions it, each group alphabetical. Use /symbols/{id} to get full interpretation.
    pub symbols: Vec<BasicDreamSymbol>,
    /// Total number of dream symbols matching your search or filter criteria.
    pub total: f64,
}
/// One entry of `symbols`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BasicDreamSymbol {
    /// Unique symbol identifier in kebab-case.
    pub id: String,
    /// Starting letter for alphabetical filtering.
    pub letter: String,
    /// Display name of the dream symbol.
    pub name: String,
}
/// Response body of `searchCrystals`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct SearchCrystalsResponse {
    /// Matching crystal summaries. Call /crystals/{id} for full healing properties.
    pub crystals: Vec<SearchCrystalsResponseCrystalsItem>,
    /// Maximum crystals returned per page.
    pub limit: f64,
    /// Number of crystals skipped.
    pub offset: f64,
    /// The search query that was used.
    pub query: String,
    /// Total number of crystals matching the query.
    pub total: f64,
}
/// One entry of `crystals`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct SearchCrystalsResponseCrystalsItem {
    /// Primary colors of this crystal variety. Null when color data is unavailable.
    pub colors: Option<Vec<String>>,
    /// URL-safe crystal identifier for detail lookup.
    pub id: String,
    /// URL to crystal photograph for visual identification.
    #[serde(rename = "imageUrl")]
    pub image_url: Option<String>,
    /// Crystal display name.
    pub name: String,
}
/// Path and query parameters of `searchCrystals`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct SearchCrystalsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<SearchCrystalsParamsLang>,
    /// Maximum items to return per page. Range: 1-50, default 20.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
    /// Search query (2-50 characters). Matches against crystal names, keywords, descriptions, and meaning fields. Case-insensitive partial matching.
    pub q: String,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    SearchCrystalsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `searchCities`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct SearchCitiesResponse {
    /// Matching places for the current page, best match first. Ordered by match quality, then population within equal quality: an exact name beats a qualified name such as richfield, utah, which beats a name merely starting with the query, which beats an incidental match on state or country. Take the first entry when total is 1, otherwise disambiguate on province and country.
    pub cities: Vec<SearchCitiesResponseCitiesItem>,
    /// Page size used for this response.
    pub limit: f64,
    /// Number of places skipped. Use with limit to page through results.
    pub offset: f64,
    /// Number of places matching the query across all pages, not the number returned in this response. Greater than 1 means the name is ambiguous, so show province and country and let the user confirm before using the result for a chart.
    pub total: f64,
}
/// Geographic location with coordinates, timezone, and UTC offset. Every field is designed for direct use as input parameters in astrology, horoscope, and location-dependent API calculations.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct SearchCitiesResponseCitiesItem {
    /// City name as commonly used. Matches the local or internationally recognized name for the location.
    pub city: String,
    /// Full country name in English.
    pub country: String,
    /// ISO 3166-1 alpha-2 country code. Use for filtering cities by country or building country-specific location pickers.
    pub iso2: String,
    /// Geographic latitude in decimal degrees (-90 to 90). Pass directly to birth chart, natal chart, horoscope, synastry, transit, kundli, and panchang API endpoints as the latitude parameter.
    pub latitude: f64,
    /// Geographic longitude in decimal degrees (-180 to 180). Pass directly to astrology, horoscope, and panchang API endpoints alongside latitude.
    pub longitude: f64,
    /// Population estimate for the place. Breaks ties between results of equal match quality, so among several places matching equally well the largest leads. It never outranks a better match, which is why a small town still wins when its name is typed exactly. May be 0 for a hamlet or administrative seat that carries no published figure.
    pub population: f64,
    /// State, province, canton, or administrative region. Show it whenever more than one result comes back: it is what separates Richfield, Utah from Richfield, Minnesota, and the six US Springfields from each other. Empty for the small number of places with no administrative division recorded.
    pub province: String,
    /// IANA timezone identifier following the tz database standard (e.g. Europe/Berlin, America/New_York, Asia/Tokyo). Always present. Pass THIS, not the numeric offset, into any chart or panchang request for a past date: the calculation endpoints resolve it to the offset that was actually in force on that date, including historical daylight saving. Also works directly with JavaScript Date, Luxon, day.js, or any date library.
    pub timezone: String,
    /// UTC offset in decimal hours for TODAY at this place, already adjusted for daylight saving. Convenient for displaying local time now. For a birth date or any past date use the `timezone` field instead, since the offset in force then may differ. Examples: 1 for CET, 2 for CEST, -5 for EST, 5.5 for IST, 5.75 for Nepal.
    #[serde(rename = "utcOffset")]
    pub utc_offset: f64,
}
/// Response body of `checkSadhesati`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct SadhesatiResponse {
    /// Human-readable Sadhesati analysis with current Saturn transit phase relative to natal Moon
    pub description: String,
    /// Sadhesati effects by transit phase with general and phase-specific impacts
    #[serde(skip_serializing_if = "Option::is_none")]
    pub effects: Option<SadhesatiResponseEffects>,
    /// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
    pub frame: SadhesatiResponseFrame,
    /// Whether Sade Sati is currently active, Saturn transiting 12th, 1st, or 2nd house from natal Moon
    pub present: bool,
    /// Traditional Vedic remedies for Shani Sade Sati including Shani mantras, donations, and worship
    #[serde(skip_serializing_if = "Option::is_none")]
    pub remedies: Option<Vec<String>>,
    /// Sadhesati intensity: Moderate for Rising/Setting phases, Severe for Peak phase (Saturn over natal Moon)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub severity: Option<SadhesatiResponseSeverity>,
    /// Current Sadhesati phase: Rising (12th house), Peak (1st house), or Setting (2nd house)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}
string_enum! {
    /// Sadhesati intensity: Moderate for Rising/Setting phases, Severe for Peak phase (Saturn over natal Moon)
    SadhesatiResponseSeverity {
        Mild = "Mild",
        Moderate = "Moderate",
        Severe = "Severe",
    }
}
/// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct SadhesatiResponseFrame {
    /// Sidereal frame this chart was cast in, echoing the ayanamsa request field. "lahiri" when the field was omitted.
    pub ayanamsa: String,
    /// Degrees actually subtracted from every tropical longitude to produce this chart, read at the birth instant. Subtract it back to recover the tropical positions, or compare it against your reference software to confirm you are in the same frame before chasing a placement difference.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
}
/// Sadhesati effects by transit phase with general and phase-specific impacts
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct SadhesatiResponseEffects {
    /// Overall impact of Saturn transit during Sade Sati period
    pub general: String,
    /// Phase-specific effects for the current Sadhesati stage (Rising/Peak/Setting)
    pub phases: SadhesatiResponseEffectsPhases,
}
/// Phase-specific effects for the current Sadhesati stage (Rising/Peak/Setting)
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct SadhesatiResponseEffectsPhases {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, String>,
}
/// Request body of `checkSadhesati`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct SadhesatiRequest {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<SadhesatiRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<SadhesatiRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum SadhesatiRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    SadhesatiRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Response body of `generateRelocationChart`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct RelocationChartResponse {
    /// Relocated Ascendant (rising sign). The eastern horizon at the new place, defining how you come across there.
    pub ascendant: RelocationChartResponseAscendant,
    /// Birthplace details echoed back. The birth instant is unchanged by relocation.
    #[serde(rename = "birthDetails")]
    pub birth_details: RelocationChartResponseBirthDetails,
    /// How relocation reshapes the chart: Ascendant shift, planets that change house, angular planets, and the move geometry from the birthplace.
    pub changes: RelocationChartResponseChanges,
    /// House system used for the relocated chart (placidus, whole-sign, equal, or koch). Quadrant systems fall back to whole-sign above the polar circle.
    #[serde(rename = "houseSystem")]
    pub house_system: String,
    /// All 12 relocated house cusps with zodiac positions for the new location.
    pub houses: Vec<RelocationChartResponseHousesItem>,
    /// Relocation interpretation summary.
    pub interpretation: RelocationChartResponseInterpretation,
    /// Relocated Midheaven (MC). The highest point of the ecliptic at the new place, tied to career and public image there.
    pub midheaven: RelocationChartResponseMidheaven,
    /// All 14 celestial bodies with their unchanged natal signs and degrees, reassigned to the houses they occupy in the relocated chart.
    pub planets: Vec<RelocationPlanet>,
    /// New location the chart was recomputed for.
    pub relocation: RelocationChartResponseRelocation,
    /// Relocated Vertex. The western prime-vertical and ecliptic intersection at the new place, read as a point of fated encounters.
    pub vertex: RelocationChartResponseVertex,
}
/// Relocated Vertex. The western prime-vertical and ecliptic intersection at the new place, read as a point of fated encounters.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct RelocationChartResponseVertex {
    /// Degree within the Vertex sign (0-29.999).
    pub degree: f64,
    /// House containing this point, resolved against the same cusps as `planets[].house` and using the requested house system. Read this field rather than inferring a house from the sign: the two disagree whenever a house spans more than one sign, which is most of the time outside Whole Sign.
    pub house: i64,
    /// Absolute ecliptic longitude of the Vertex (0-360).
    pub longitude: f64,
    /// Zodiac sign holding the Vertex.
    pub sign: String,
    /// Vertex sign name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
}
/// New location the chart was recomputed for.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct RelocationChartResponseRelocation {
    /// New location latitude in decimal degrees.
    pub latitude: f64,
    /// New location longitude in decimal degrees.
    pub longitude: f64,
}
/// One entry of `planets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct RelocationPlanet {
    /// Degree within the zodiac sign (0-29.999). Indicates how far the planet has progressed through the sign.
    pub degree: f64,
    /// House placement (1-12). Determined by the selected house system and birth location.
    pub house: i64,
    /// Relocated placement interpretation. The planet keeps its natal sign, so this reads its meaning through the new house it occupies at this location.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interpretation: Option<RelocationPlanetInterpretation>,
    /// Whether the planet appears to move backward from Earth perspective. Retrograde periods signal review and introspection.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Apparent geocentric ecliptic latitude of date, in degrees. Near zero for most planets, varies for the Moon and Pluto, and reaches up to about 5 degrees for Black Moon Lilith (projected from the inclined mean lunar orbit).
    pub latitude: f64,
    /// Apparent geocentric tropical longitude on the true ecliptic of date, in degrees (0-360): light time and aberration applied, nutation included, the convention desktop chart software and the NASA JPL Horizons observer tables print, so it compares directly with either. Primary coordinate for zodiac sign and aspect calculations.
    pub longitude: f64,
    /// Body name. One of the 10 classical planets (Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto), the lunar nodes (North Node, South Node), Chiron, or Black Moon Lilith (the mean lunar apogee). The lunar nodes follow the request nodeType, which defaults to the true (osculating) node; pass "mean" for the smoothed node. The two differ by up to about 1.8 degrees and no other body is affected.
    pub name: RelocationPlanetName,
    /// Body name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tropical zodiac sign this planet occupies. Determined by 30-degree divisions of ecliptic longitude.
    pub sign: String,
    /// Zodiac sign name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
    /// Daily motion in degrees per day. Negative values indicate retrograde motion.
    pub speed: f64,
}
string_enum! {
    /// Body name. One of the 10 classical planets (Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto), the lunar nodes (North Node, South Node), Chiron, or Black Moon Lilith (the mean lunar apogee). The lunar nodes follow the request nodeType, which defaults to the true (osculating) node; pass "mean" for the smoothed node. The two differ by up to about 1.8 degrees and no other body is affected.
    RelocationPlanetName {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
/// Relocated placement interpretation. The planet keeps its natal sign, so this reads its meaning through the new house it occupies at this location.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct RelocationPlanetInterpretation {
    /// Multi-sentence interpretation of this relocated placement.
    pub detailed: String,
    /// Key themes for this relocated placement.
    pub keywords: Vec<String>,
    /// One-sentence interpretation of this planet in its sign and relocated house.
    pub summary: String,
}
/// Relocated Midheaven (MC). The highest point of the ecliptic at the new place, tied to career and public image there.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct RelocationChartResponseMidheaven {
    /// Degree within the zodiac sign on this angle (0-29.999).
    pub degree: f64,
    /// Absolute ecliptic longitude of this angle in degrees (0-360).
    pub longitude: f64,
    /// Tropical zodiac sign on this relocated angle. Always English, whatever the lang parameter says. Use signLocalized for anything a reader sees.
    pub sign: String,
    /// Zodiac sign name on this angle in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
}
/// Relocation interpretation summary.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct RelocationChartResponseInterpretation {
    /// Narrative summary of the relocation: the new Ascendant and Midheaven signs and any planets that move onto the angles. Localized via the lang query parameter.
    pub summary: String,
}
/// One entry of `houses`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct RelocationChartResponseHousesItem {
    /// Degree within the zodiac sign on this cusp (0-29.999).
    pub degree: f64,
    /// Ecliptic longitude of this house cusp in degrees (0-360).
    pub longitude: f64,
    /// House number (1-12). Each house governs specific life themes in Western astrology.
    pub number: i64,
    /// Zodiac sign on this house cusp. Colors the themes of this life area.
    pub sign: String,
    /// Zodiac sign name on this cusp in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
}
/// How relocation reshapes the chart: Ascendant shift, planets that change house, angular planets, and the move geometry from the birthplace.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct RelocationChartResponseChanges {
    /// Bodies within three degrees of a relocated angle (Ascendant, Imum Coeli, Descendant, or Midheaven), where their influence is strongest at this location. Always English, whatever the lang parameter says. Use angularPlanetsLocalized for anything a reader sees.
    #[serde(rename = "angularPlanets")]
    pub angular_planets: Vec<String>,
    /// The same angular bodies in the requested language, for display only. Index aligned with angularPlanets. Present only when lang is set to a language other than English.
    #[serde(rename = "angularPlanetsLocalized", skip_serializing_if = "Option::is_none")]
    pub angular_planets_localized: Option<Vec<String>>,
    /// Whether the Ascendant sign differs between the birthplace chart and the relocated chart.
    #[serde(rename = "ascendantSignChanged")]
    pub ascendant_sign_changed: bool,
    /// Compass direction (16-point) from the birthplace to the new location.
    pub direction: String,
    /// Great-circle distance from the birthplace to the new location in kilometers.
    #[serde(rename = "distanceKm")]
    pub distance_km: f64,
    /// Bodies whose house placement shifts from the birthplace chart to the relocated chart. Empty when nothing changes house.
    #[serde(rename = "planetsChangedHouse")]
    pub planets_changed_house: Vec<
        RelocationChartResponseChangesPlanetsChangedHouseItem,
    >,
}
/// One entry of `planetsChangedHouse`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct RelocationChartResponseChangesPlanetsChangedHouseItem {
    /// House this body occupied in the birthplace chart (1-12).
    #[serde(rename = "natalHouse")]
    pub natal_house: f64,
    /// Body that occupies a different house after relocation. Always English, whatever the lang parameter says. Use planetLocalized for anything a reader sees.
    pub planet: String,
    /// Body name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "planetLocalized", skip_serializing_if = "Option::is_none")]
    pub planet_localized: Option<String>,
    /// House this body occupies in the relocated chart (1-12).
    #[serde(rename = "relocatedHouse")]
    pub relocated_house: f64,
}
/// Birthplace details echoed back. The birth instant is unchanged by relocation.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct RelocationChartResponseBirthDetails {
    /// Birth date used for this chart (YYYY-MM-DD).
    pub date: String,
    /// Birthplace latitude in decimal degrees.
    pub latitude: f64,
    /// Birthplace longitude in decimal degrees.
    pub longitude: f64,
    /// Birth time used for this chart (HH:MM:SS, 24-hour).
    pub time: String,
    /// Birth timezone offset from UTC in decimal hours.
    pub timezone: f64,
}
/// Relocated Ascendant (rising sign). The eastern horizon at the new place, defining how you come across there.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct RelocationChartResponseAscendant {
    /// Degree within the zodiac sign on this angle (0-29.999).
    pub degree: f64,
    /// Absolute ecliptic longitude of this angle in degrees (0-360).
    pub longitude: f64,
    /// Tropical zodiac sign on this relocated angle. Always English, whatever the lang parameter says. Use signLocalized for anything a reader sees.
    pub sign: String,
    /// Zodiac sign name on this angle in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
}
/// Request body of `generateRelocationChart`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct RelocationChartRequest {
    /// Birthplace latitude in decimal degrees (-90 to 90). Used for the original natal angles and houses that the relocated chart is compared against.
    #[serde(rename = "birthLatitude")]
    pub birth_latitude: f64,
    /// Birthplace longitude in decimal degrees (-180 to 180). Positive East, negative West.
    #[serde(rename = "birthLongitude")]
    pub birth_longitude: f64,
    /// Birth date in YYYY-MM-DD format. The birth moment is unchanged by relocation, so this still defines the planetary positions of the chart.
    pub date: String,
    /// House system for dividing the relocated chart into 12 houses. Placidus (default) is time-sensitive and most popular in Western astrology. Whole Sign assigns one sign per house. Equal divides into 30 degree segments from the Ascendant. Koch emphasizes higher latitudes. Quadrant systems fall back to Whole Sign above the polar circle.
    #[serde(rename = "houseSystem", skip_serializing_if = "Option::is_none")]
    pub house_system: Option<RelocationChartRequestHouseSystem>,
    /// New location latitude in decimal degrees (-90 to 90). The relocated Ascendant and house cusps are most sensitive to north-south movement.
    #[serde(rename = "relocationLatitude")]
    pub relocation_latitude: f64,
    /// New location longitude in decimal degrees (-180 to 180). The relocated Midheaven shifts roughly one degree per degree of longitude moved.
    #[serde(rename = "relocationLongitude")]
    pub relocation_longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Combined with the timezone it fixes the exact birth instant, which the relocated angles and houses are recomputed for.
    pub time: String,
    /// Birth timezone: decimal hours from UTC (e.g. -5 for EST, 5.5 for IST) OR IANA name (e.g. "America/New_York"). Resolved to the offset in force at the birth date and time. This is the birthplace timezone, not the new location timezone.
    pub timezone: RelocationChartRequestTimezone,
}
/// Birth timezone: decimal hours from UTC (e.g. -5 for EST, 5.5 for IST) OR IANA name (e.g. "America/New_York"). Resolved to the offset in force at the birth date and time. This is the birthplace timezone, not the new location timezone.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum RelocationChartRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// House system for dividing the relocated chart into 12 houses. Placidus (default) is time-sensitive and most popular in Western astrology. Whole Sign assigns one sign per house. Equal divides into 30 degree segments from the Ascendant. Koch emphasizes higher latitudes. Quadrant systems fall back to Whole Sign above the polar circle.
    RelocationChartRequestHouseSystem {
        Placidus = "placidus",
        WholeSign = "whole-sign",
        Equal = "equal",
        Koch = "koch",
    }
}
/// Response body of `listRashis`.
pub type RashiListResponse = Vec<RashiListResponseItem>;
/// One form of \[`RashiListResponse`\].
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct RashiListResponseItem {
    /// Key personality traits and behavioral tendencies of natives born under this rashi.
    pub characteristics: String,
    /// Approximate sidereal date range when the Sun transits this rashi.
    #[serde(rename = "dateRange")]
    pub date_range: String,
    /// Aditya (solar deity) governing this rashi in Vedic tradition.
    pub energy: String,
    /// Unique slug identifier for the rashi. Used in URL paths and cross-references.
    pub id: String,
    /// Western zodiac sign name corresponding to this Vedic rashi.
    pub name: String,
    /// Traditional symbol associated with this zodiac sign.
    pub symbol: String,
    /// Sanskrit name of the rashi as used in Vedic astrology (Jyotish).
    #[serde(rename = "vedicName")]
    pub vedic_name: String,
}
/// Response body of `generateProgressions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ProgressionsResponse {
    /// Progressed Ascendant, the rising degree advanced by the Naibod arc per year. Marks the evolving outward style and immediate environment.
    pub ascendant: ProgressionsResponseAscendant,
    /// Echo of the birth moment and place the progressed chart is built from.
    #[serde(rename = "birthDetails")]
    pub birth_details: ProgressionsResponseBirthDetails,
    /// Years elapsed between birth and the target date, measured in mean tropical years. Drives both the progressed planets and the Naibod progression of the angles. Negative values progress the chart converse (before birth).
    #[serde(rename = "elapsedYears")]
    pub elapsed_years: f64,
    /// Progressed Midheaven, the culminating degree advanced by the Naibod arc per year. Marks the evolving vocation and public direction.
    pub midheaven: ProgressionsResponseMidheaven,
    /// Every progressed body in canonical order: the 10 classical planets, the lunar nodes, Chiron, and Black Moon Lilith. The progressed Sun moves about one degree per year and the progressed Moon about one sign per two and a half years, so these two are the headline movers in any progressed reading.
    pub planets: Vec<ProgressionsResponsePlanetsItem>,
    /// UTC calendar date of the progressed moment, the ephemeris day whose real positions stand in for the target date. One day after birth per year of elapsed life.
    #[serde(rename = "progressedDate")]
    pub progressed_date: String,
    /// Short overview of the progressed chart led by the progressed Sun and Moon. Localized to the requested language.
    pub summary: String,
    /// The requested date the chart was progressed to.
    #[serde(rename = "targetDate")]
    pub target_date: String,
}
/// One entry of `planets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ProgressionsResponsePlanetsItem {
    /// Degree of the progressed body within its zodiac sign (0 to 29.999).
    pub degree: f64,
    /// Whole-sign house (1 to 12) counted from the progressed Ascendant sign. The 1st house is the entire sign the progressed Ascendant falls in.
    pub house: i64,
    /// Plain language meaning of this progressed body in its sign, suitable for chart reports and AI agents. Localized to the requested language.
    pub interpretation: String,
    /// Whether the body is retrograde at the progressed instant, true when the daily speed is negative.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Progressed tropical ecliptic longitude in degrees (0 to 360).
    pub longitude: f64,
    /// Body name in canonical English. One of the 10 classical planets, the lunar nodes, Chiron, or Black Moon Lilith. Unchanged by the lang parameter, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Body name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tropical zodiac sign the progressed body falls in. Always English, whatever the lang parameter says. Use signLocalized for anything a reader sees.
    pub sign: String,
    /// Zodiac sign name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
    /// Daily motion of the body at the progressed instant in degrees per day. Negative values indicate retrograde motion.
    pub speed: f64,
}
/// Progressed Midheaven, the culminating degree advanced by the Naibod arc per year. Marks the evolving vocation and public direction.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ProgressionsResponseMidheaven {
    /// Degree of the progressed angle within its zodiac sign (0 to 29.999).
    pub degree: f64,
    /// Absolute tropical ecliptic longitude of the progressed angle in degrees (0 to 360).
    pub longitude: f64,
    /// Tropical zodiac sign the progressed angle falls in. Always English, whatever the lang parameter says. Use signLocalized for anything a reader sees.
    pub sign: String,
    /// Zodiac sign name on this angle in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
}
/// Echo of the birth moment and place the progressed chart is built from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ProgressionsResponseBirthDetails {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone offset from UTC in decimal hours, resolved for the birth date. Examples: New York = -5 in winter and -4 in summer, London = 0, India = 5.5, Tokyo = 9.
    pub timezone: f64,
}
/// Progressed Ascendant, the rising degree advanced by the Naibod arc per year. Marks the evolving outward style and immediate environment.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ProgressionsResponseAscendant {
    /// Degree of the progressed angle within its zodiac sign (0 to 29.999).
    pub degree: f64,
    /// Absolute tropical ecliptic longitude of the progressed angle in degrees (0 to 360).
    pub longitude: f64,
    /// Tropical zodiac sign the progressed angle falls in. Always English, whatever the lang parameter says. Use signLocalized for anything a reader sees.
    pub sign: String,
    /// Zodiac sign name on this angle in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
}
/// Request body of `generateProgressions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ProgressionsRequest {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<ProgressionsRequestNodeType>,
    /// Date to progress the chart to, in YYYY-MM-DD format. Usually today or a forecast date. The day-for-a-year key turns the elapsed years since birth into the same number of ephemeris days after the birth moment.
    #[serde(rename = "targetDate")]
    pub target_date: String,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
    pub timezone: ProgressionsRequestTimezone,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum ProgressionsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    ProgressionsRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Response body of `generateProfections`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ProfectionsResponse {
    /// Completed whole years from birth to the target date. Age 0 is the birth year and profects the first house.
    pub age: i64,
    /// Echo of the birth moment and place used to derive the natal Ascendant and the lord of the year placement.
    #[serde(rename = "birthDetails")]
    pub birth_details: ProfectionsResponseBirthDetails,
    /// Plain language reading of the profection year, combining the profected house theme, the profected sign, and the lord of the year. Localized to the requested language.
    pub interpretation: String,
    /// Where the lord of the year sits in the birth chart: the natal sign and house that ground the theme of the profection year.
    #[serde(rename = "lordNatalPosition")]
    pub lord_natal_position: ProfectionsResponseLordNatalPosition,
    /// Lord of the year (annual time lord): the traditional ruling planet of the profected sign whose natal condition and transits color the themes of the year.
    #[serde(rename = "lordOfYear")]
    pub lord_of_year: String,
    /// Profected whole sign house activated for the year (1 to 12), computed as age modulo 12 plus 1. House 1 is the rising sign and the cycle repeats every twelve years.
    #[serde(rename = "profectedHouse")]
    pub profected_house: i64,
    /// Tropical zodiac sign on the profected house: the rising sign advanced by one whole sign for each completed year.
    #[serde(rename = "profectedSign")]
    pub profected_sign: String,
    /// Short overview of the profection year for previews and report intros.
    pub summary: String,
    /// Target date whose profection year was computed, echoed from the request.
    #[serde(rename = "targetDate")]
    pub target_date: String,
}
/// Where the lord of the year sits in the birth chart: the natal sign and house that ground the theme of the profection year.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ProfectionsResponseLordNatalPosition {
    /// Natal house the lord of the year occupies (1 to 12), in the requested house system.
    pub house: i64,
    /// Zodiac sign the lord of the year occupies in the natal chart.
    pub sign: String,
}
/// Echo of the birth moment and place used to derive the natal Ascendant and the lord of the year placement.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ProfectionsResponseBirthDetails {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone offset from UTC in decimal hours, resolved for the birth date. Examples: New York = -5 in winter and -4 in summer, London = 0, India = 5.5, Tokyo = 9.
    pub timezone: f64,
}
/// Request body of `generateProfections`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ProfectionsRequest {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// House system used only to report where the lord of the year sits in the natal chart. The profected house and sign always use whole sign profection from the rising sign. Placidus (default), Whole Sign, Equal, or Koch.
    #[serde(rename = "houseSystem", skip_serializing_if = "Option::is_none")]
    pub house_system: Option<ProfectionsRequestHouseSystem>,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<ProfectionsRequestNodeType>,
    /// Date whose profection year you want, in YYYY-MM-DD format. The completed whole years from the birth date to this date select the profected house and sign. Must fall on or after the birth date.
    #[serde(rename = "targetDate")]
    pub target_date: String,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
    pub timezone: ProfectionsRequestTimezone,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum ProfectionsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    ProfectionsRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// House system used only to report where the lord of the year sits in the natal chart. The profected house and sign always use whole sign profection from the rising sign. Placidus (default), Whole Sign, Equal, or Koch.
    ProfectionsRequestHouseSystem {
        Placidus = "placidus",
        WholeSign = "whole-sign",
        Equal = "equal",
        Koch = "koch",
    }
}
/// Every graha keyed by its English name: Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn, Rahu, Ketu, plus Lagna for the Ascendant. Read a placement straight off the key you want, such as `response.Sun`, and iterate the keys to render a full navagraha table.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct PlanetaryPositionsResponse {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<
        String,
        PlanetaryPositionsResponseAdditionalProperty,
    >,
}
/// Everything computed for one graha: its rashi and sidereal longitude, the nakshatra and pada it falls in, its Whole Sign house from the Lagna, retrogression, combustion where the question applies, and the Baladi avastha. Lagna carries the same shape as a planet.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct PlanetaryPositionsResponseAdditionalProperty {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awastha: Option<PlanetaryPositionsResponseAdditionalPropertyAwastha>,
    /// Angular distance from the Sun in degrees (0-180). Smaller values indicate closer proximity. Null for Sun, Rahu, Ketu, and Lagna. Useful for gauging combustion severity and planetary strength analysis.
    #[serde(rename = "combustionDistance", skip_serializing_if = "Option::is_none")]
    pub combustion_distance: Option<f64>,
    /// Vedic planet (graha) name. One of the Navagraha: Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn, Rahu, Ketu, or Lagna (Ascendant).
    pub graha: String,
    /// House number (1-12) the planet occupies using Whole Sign house system. House 1 is the Lagna (Ascendant) sign. Essential for bhava analysis and house-level predictions.
    pub house: f64,
    /// Whether the planet is combust (asta, moudhya). A planet is combust when too close to the Sun, weakening its significations. Limits per Surya Siddhanta: Moon 12 deg, Mars 17 deg, Mercury 14 deg (12 deg if retrograde), Jupiter 11 deg, Venus 10 deg (8 deg if retrograde), Saturn 15 deg. Compared against the difference in ecliptic longitude, which is the standard interpretive convention and matches what other Vedic software reports. It is a chart judgement and not a statement about naked-eye visibility, which additionally depends on the observer latitude: for that use the heliacal endpoint, which applies the same limits in the classical degrees of time. The field is omitted entirely for Sun, Rahu, Ketu and Lagna, since the question does not apply to them rather than the answer being no.
    #[serde(rename = "isCombust", skip_serializing_if = "Option::is_none")]
    pub is_combust: Option<bool>,
    /// Whether the planet is in retrograde motion (vakri). Rahu and Ketu are always retrograde in Vedic astrology.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Ecliptic latitude in degrees, the angular distance north (positive) or south (negative) of the ecliptic. Used in planetary war (graha yuddha) winner resolution and latitude-sensitive analysis. Omitted for the Lagna (Ascendant).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Sidereal longitude in degrees (0-360) using Lahiri ayanamsa. Precise planetary position for chart calculations.
    pub longitude: f64,
    /// Nakshatra (lunar mansion) data with optional interpretive details from Vedic tradition.
    pub nakshatra: PlanetaryPositionsResponseAdditionalPropertyNakshatra,
    /// Zodiac sign (rashi) the planet occupies. One of 12 Vedic rashis from Aries to Pisces.
    pub rashi: String,
    /// Vedic zodiac sign (rashi) details including Sanskrit name, symbol, elemental energy, and personality characteristics. Present when interpretation data is available.
    #[serde(rename = "rashiDetails", skip_serializing_if = "Option::is_none")]
    pub rashi_details: Option<PlanetaryPositionsResponseAdditionalPropertyRashiDetails>,
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}
/// Vedic zodiac sign (rashi) details including Sanskrit name, symbol, elemental energy, and personality characteristics. Present when interpretation data is available.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct PlanetaryPositionsResponseAdditionalPropertyRashiDetails {
    /// Key personality traits and behavioral tendencies of this zodiac sign in Vedic astrology.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub characteristics: Option<String>,
    /// Elemental and gender classification of the rashi (Masculine/Feminine, Fire/Earth/Air/Water).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub energy: Option<String>,
    /// Traditional symbol representing this zodiac sign.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub symbol: Option<String>,
    /// Sanskrit name of the zodiac sign as used in traditional Jyotish texts.
    #[serde(rename = "vedicName", skip_serializing_if = "Option::is_none")]
    pub vedic_name: Option<String>,
}
/// Nakshatra (lunar mansion) data with optional interpretive details from Vedic tradition.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct PlanetaryPositionsResponseAdditionalPropertyNakshatra {
    /// Personality traits and behavioral tendencies when a planet occupies this nakshatra. Used for character analysis and prediction.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub characteristics: Option<String>,
    /// Presiding deity of the nakshatra from Vedic mythology. Influences the spiritual quality and karmic themes of the planet placement.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deity: Option<String>,
    /// Nakshatra sequence number (1-27) in zodiac order starting from Ashwini. Used for Tara Bala and dasha calculations.
    pub key: f64,
    /// Nakshatra (lunar mansion) the planet occupies. One of 27 Vedic nakshatras spanning 13 degrees 20 minutes each.
    pub name: String,
    /// Nakshatra pada (quarter, 1-4). Each nakshatra divides into 4 padas of 3 degrees 20 minutes. Determines Navamsa sign.
    pub pada: f64,
    /// Traditional symbol representing the nakshatra. Reflects core energy and life themes associated with this lunar mansion.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub symbol: Option<String>,
}
string_enum! {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs.
    PlanetaryPositionsResponseAdditionalPropertyAwastha {
        Bala = "Bala",
        Kumara = "Kumara",
        Yuva = "Yuva",
        Vriddha = "Vriddha",
        Mrita = "Mrita",
    }
}
/// Request body of `getPlanetPositions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct PlanetaryPositionsRequest {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<PlanetaryPositionsRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<PlanetaryPositionsRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum PlanetaryPositionsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    PlanetaryPositionsRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Response body of `calculatePapasamyam`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct PapasamyamResponse {
    /// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
    pub frame: PapasamyamResponseFrame,
    /// Papa count of the groom chart, with the working shown per reference.
    pub person1: PapasamyamResponsePerson1,
    /// Papa count of the bride chart, with the working shown per reference.
    pub person2: PapasamyamResponsePerson2,
    /// One sentence stating the comparison and what it means, localized by the lang query parameter. Renders directly; the machine value to branch on is verdict.
    pub recommendation: String,
    /// Whether the two charts carry comparable affliction. "balanced" when the bride total is equal to or below the groom total, "unbalanced" when the bride carries more. Canonical English, never translated, so it is safe to branch on. Both totals are published, so a desk that also caps how far the groom may exceed the bride, or that allows the bride a small tolerance, can apply its own band without a second request.
    pub verdict: PapasamyamResponseVerdict,
}
string_enum! {
    /// Whether the two charts carry comparable affliction. "balanced" when the bride total is equal to or below the groom total, "unbalanced" when the bride carries more. Canonical English, never translated, so it is safe to branch on. Both totals are published, so a desk that also caps how far the groom may exceed the bride, or that allows the bride a small tolerance, can apply its own band without a second request.
    PapasamyamResponseVerdict {
        Balanced = "balanced",
        Unbalanced = "unbalanced",
    }
}
/// Papa count of the bride chart, with the working shown per reference.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct PapasamyamResponsePerson2 {
    /// The count broken out by the three reference points, in the order Lagna, Moon, Venus. A Kuja Dosha check reads only the first of these and only Mars, which is why a Manglik verdict and a Papasamyam count answer different questions.
    #[serde(rename = "byReference")]
    pub by_reference: Vec<PapasamyamResponsePerson2ByReferenceItem>,
    /// Papa points this chart carries, summed across the three reference points with each hit multiplied by that reference weight. The range is 0 to 7, and quarter points are normal because a hit read from Venus is worth 0.25. The number is never a verdict on one person: only the comparison between the two totals means anything.
    pub total: f64,
}
/// One entry of `byReference`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct PapasamyamResponsePerson2ByReferenceItem {
    /// Every malefic this reference point sees in an afflicting bhava, one entry per point contributed. An empty array means this reference point contributes nothing, which is a clean reading rather than missing data. The length of the array is the points from this reference, so it is not published a second time as a number.
    pub afflictions: Vec<PapasamyamResponsePerson2ByReferenceItemAfflictionsItem>,
    /// Which point the houses on this row were counted from. Lagna is the Ascendant, Moon is the Chandra lagna and Venus is the karaka of marriage. Canonical English, never translated.
    pub reference: PapasamyamResponsePerson2ByReferenceItemReference,
    /// What one affliction seen from this reference is worth: 1 from the Lagna, 0.5 from the Moon, 0.25 from Venus. Published rather than assumed because a school that weights the three equally exists, and a caller reconciling against one can see exactly which number to change. The points from this row are the length of afflictions multiplied by this weight.
    pub weight: f64,
}
string_enum! {
    /// Which point the houses on this row were counted from. Lagna is the Ascendant, Moon is the Chandra lagna and Venus is the karaka of marriage. Canonical English, never translated.
    PapasamyamResponsePerson2ByReferenceItemReference {
        Lagna = "Lagna",
        Moon = "Moon",
        Venus = "Venus",
    }
}
/// One entry of `afflictions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct PapasamyamResponsePerson2ByReferenceItemAfflictionsItem {
    /// The malefic contributing this point. Canonical English, never translated, so it is safe to switch on or use as a glyph key.
    pub graha: PapasamyamResponsePerson2ByReferenceItemAfflictionsItemGraha,
    /// Whole-sign bhava 1 to 12 counted from the reference on this row, which is NOT the bhava from the Lagna unless the reference is the Lagna. Only the six afflicting bhavas 1, 2, 4, 7, 8 and 12 appear here, because a malefic anywhere else contributes nothing.
    pub house: f64,
}
string_enum! {
    /// The malefic contributing this point. Canonical English, never translated, so it is safe to switch on or use as a glyph key.
    PapasamyamResponsePerson2ByReferenceItemAfflictionsItemGraha {
        Mars = "Mars",
        Saturn = "Saturn",
        Sun = "Sun",
        Rahu = "Rahu",
    }
}
/// Papa count of the groom chart, with the working shown per reference.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct PapasamyamResponsePerson1 {
    /// The count broken out by the three reference points, in the order Lagna, Moon, Venus. A Kuja Dosha check reads only the first of these and only Mars, which is why a Manglik verdict and a Papasamyam count answer different questions.
    #[serde(rename = "byReference")]
    pub by_reference: Vec<PapasamyamResponsePerson1ByReferenceItem>,
    /// Papa points this chart carries, summed across the three reference points with each hit multiplied by that reference weight. The range is 0 to 7, and quarter points are normal because a hit read from Venus is worth 0.25. The number is never a verdict on one person: only the comparison between the two totals means anything.
    pub total: f64,
}
/// One entry of `byReference`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct PapasamyamResponsePerson1ByReferenceItem {
    /// Every malefic this reference point sees in an afflicting bhava, one entry per point contributed. An empty array means this reference point contributes nothing, which is a clean reading rather than missing data. The length of the array is the points from this reference, so it is not published a second time as a number.
    pub afflictions: Vec<PapasamyamResponsePerson1ByReferenceItemAfflictionsItem>,
    /// Which point the houses on this row were counted from. Lagna is the Ascendant, Moon is the Chandra lagna and Venus is the karaka of marriage. Canonical English, never translated.
    pub reference: PapasamyamResponsePerson1ByReferenceItemReference,
    /// What one affliction seen from this reference is worth: 1 from the Lagna, 0.5 from the Moon, 0.25 from Venus. Published rather than assumed because a school that weights the three equally exists, and a caller reconciling against one can see exactly which number to change. The points from this row are the length of afflictions multiplied by this weight.
    pub weight: f64,
}
string_enum! {
    /// Which point the houses on this row were counted from. Lagna is the Ascendant, Moon is the Chandra lagna and Venus is the karaka of marriage. Canonical English, never translated.
    PapasamyamResponsePerson1ByReferenceItemReference {
        Lagna = "Lagna",
        Moon = "Moon",
        Venus = "Venus",
    }
}
/// One entry of `afflictions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct PapasamyamResponsePerson1ByReferenceItemAfflictionsItem {
    /// The malefic contributing this point. Canonical English, never translated, so it is safe to switch on or use as a glyph key.
    pub graha: PapasamyamResponsePerson1ByReferenceItemAfflictionsItemGraha,
    /// Whole-sign bhava 1 to 12 counted from the reference on this row, which is NOT the bhava from the Lagna unless the reference is the Lagna. Only the six afflicting bhavas 1, 2, 4, 7, 8 and 12 appear here, because a malefic anywhere else contributes nothing.
    pub house: f64,
}
string_enum! {
    /// The malefic contributing this point. Canonical English, never translated, so it is safe to switch on or use as a glyph key.
    PapasamyamResponsePerson1ByReferenceItemAfflictionsItemGraha {
        Mars = "Mars",
        Saturn = "Saturn",
        Sun = "Sun",
        Rahu = "Rahu",
    }
}
/// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct PapasamyamResponseFrame {
    /// Sidereal frame this chart was cast in, echoing the ayanamsa request field. "lahiri" when the field was omitted.
    pub ayanamsa: String,
    /// Degrees actually subtracted from every tropical longitude to produce this chart, read at the birth instant. Subtract it back to recover the tropical positions, or compare it against your reference software to confirm you are in the same frame before chasing a placement difference.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
}
/// Request body of `calculatePapasamyam`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct PapasamyamRequest {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<PapasamyamRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth data of the GROOM. The comparison is directional, so this field is not interchangeable with person2: the match reads as balanced only when the bride carries no more affliction than the groom, and swapping the two people can flip the verdict.
    pub person1: PapasamyamRequestPerson1,
    /// Birth data of the BRIDE. Date, time and location determine the Lagna, the Moon and Venus, which are the three points every papa point is counted from.
    pub person2: PapasamyamRequestPerson2,
}
/// Birth data of the BRIDE. Date, time and location determine the Lagna, the Moon and Venus, which are the three points every papa point is counted from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct PapasamyamRequestPerson2 {
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<PapasamyamRequestPerson2Timezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum PapasamyamRequestPerson2Timezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
/// Birth data of the GROOM. The comparison is directional, so this field is not interchangeable with person2: the match reads as balanced only when the bride carries no more affliction than the groom, and swapping the two people can flip the verdict.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct PapasamyamRequestPerson1 {
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<PapasamyamRequestPerson1Timezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum PapasamyamRequestPerson1Timezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    PapasamyamRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Response body of `generateNavamsa`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NavamsaResponse {
    /// Navamsa (D9) divisional chart showing planetary positions across 12 rashi houses plus a meta lookup. Same structure as the birth chart response.
    pub chart: NavamsaResponseChart,
    /// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
    pub frame: NavamsaResponseFrame,
    /// Planets that are Vargottama (same sign in D1 and D9)
    pub vargottama: Vec<String>,
    /// Explanation of Vargottama significance
    #[serde(rename = "vargottamaExplanation")]
    pub vargottama_explanation: String,
}
/// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NavamsaResponseFrame {
    /// Sidereal frame this chart was cast in, echoing the ayanamsa request field. "lahiri" when the field was omitted.
    pub ayanamsa: String,
    /// Degrees actually subtracted from every tropical longitude to produce this chart, read at the birth instant. Subtract it back to recover the tropical positions, or compare it against your reference software to confirm you are in the same frame before chasing a placement difference.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
}
/// Navamsa (D9) divisional chart showing planetary positions across 12 rashi houses plus a meta lookup. Same structure as the birth chart response.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NavamsaResponseChart {
    /// One of the 12 navamsa rashi-house buckets (aries shown; taurus through pisces follow the identical shape). Each lists the planets placed in that sign.
    pub aries: NavamsaResponseChartAries,
    /// Planet positions in the Navamsa (D9) chart keyed by planet name. Contains all 9 Navagraha plus Lagna.
    pub meta: NavamsaResponseChartMeta,
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}
/// Planet positions in the Navamsa (D9) chart keyed by planet name. Contains all 9 Navagraha plus Lagna.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NavamsaResponseChartMeta {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<
        String,
        NavamsaResponseChartMetaAdditionalProperty,
    >,
}
/// One graha as the D9 chart places it: its Navamsa rashi and house, with the D1 longitude and nakshatra carried over so the two charts can be read side by side.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NavamsaResponseChartMetaAdditionalProperty {
    /// Planet (graha) name. One of 9 Navagraha (Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn, Rahu, Ketu) or Lagna (Ascendant). In Navamsa, Venus and Jupiter placements are especially significant for marriage and spiritual growth.
    pub graha: String,
    /// Bhava (house) number 1-12 in the Navamsa chart, counted whole-sign from the D9 Lagna. This is the Navamsa-specific house and differs from the D1 birth-chart house.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub house: Option<i64>,
    /// True if the planet is in retrograde motion (appears to move backward through the zodiac). Retrograde planets carry intensified or internalized significations in Vedic interpretation.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Sidereal longitude in degrees (0-360) using Lahiri ayanamsa. Same as D1 birth chart longitude, preserved for cross-chart reference and aspect analysis.
    pub longitude: f64,
    /// Nakshatra (lunar mansion) data for this planet. Nakshatras are the 27-fold division of the zodiac central to Vedic timing and compatibility systems.
    pub nakshatra: NavamsaResponseChartMetaAdditionalPropertyNakshatra,
    /// Zodiac sign (rashi) the planet occupies in the Navamsa (D9) chart. D9 sign placement reveals the deeper quality of a planet and is critical for spouse characteristics and marriage timing.
    pub rashi: String,
}
/// Nakshatra (lunar mansion) data for this planet. Nakshatras are the 27-fold division of the zodiac central to Vedic timing and compatibility systems.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NavamsaResponseChartMetaAdditionalPropertyNakshatra {
    /// Nakshatra sequence number (1-27) in zodiac order starting from Ashwini. Used for Tara Bala compatibility and dasha calculations.
    pub key: f64,
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Carried over from the D1 nakshatra.
    pub lord: NavamsaResponseChartMetaAdditionalPropertyNakshatraLord,
    /// Nakshatra (lunar mansion) the planet occupies. One of 27 Vedic nakshatras spanning 13 degrees 20 minutes each. Determines dasha lord and behavioral qualities.
    pub name: String,
    /// Nakshatra pada (quarter, 1-4). Each nakshatra divides into 4 padas of 3 degrees 20 minutes. Pada determines Navamsa sign and refines personality traits.
    pub pada: f64,
}
string_enum! {
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Carried over from the D1 nakshatra.
    NavamsaResponseChartMetaAdditionalPropertyNakshatraLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// One of the 12 navamsa rashi-house buckets (aries shown; taurus through pisces follow the identical shape). Each lists the planets placed in that sign.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NavamsaResponseChartAries {
    /// Zodiac sign name in lowercase. Always equals the key of the navamsa rashi-house block it sits in.
    pub rashi: String,
    /// Planets placed in this navamsa sign.
    pub signs: Vec<NavamsaResponseChartAriesSignsItem>,
}
/// One entry of `signs`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NavamsaResponseChartAriesSignsItem {
    /// Planet (graha) placed in this navamsa sign.
    pub graha: String,
    /// Bhava (house) number 1-12 in the Navamsa chart, counted whole-sign from the D9 Lagna.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub house: Option<i64>,
    /// True if the planet is in retrograde motion.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Original sidereal longitude in degrees (0-360), same as the D1 birth chart. Preserved for cross-chart reference.
    pub longitude: f64,
    /// Nakshatra (lunar mansion) data for this planet, carried over from the D1 chart.
    pub nakshatra: NavamsaResponseChartAriesSignsItemNakshatra,
}
/// Nakshatra (lunar mansion) data for this planet, carried over from the D1 chart.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NavamsaResponseChartAriesSignsItemNakshatra {
    /// Nakshatra index (1-27) in the zodiac sequence starting from Ashwini.
    pub key: f64,
    /// Vimshottari ruling planet of this nakshatra.
    pub lord: NavamsaResponseChartAriesSignsItemNakshatraLord,
    /// Nakshatra (lunar mansion) the planet occupies.
    pub name: String,
    /// Nakshatra pada (quarter, 1-4).
    pub pada: f64,
}
string_enum! {
    /// Vimshottari ruling planet of this nakshatra.
    NavamsaResponseChartAriesSignsItemNakshatraLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Request body of `generateNavamsa`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NavamsaRequest {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<NavamsaRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<NavamsaRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum NavamsaRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    NavamsaRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Response body of `generateNatalChart`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NatalChartResponse {
    /// Ascendant (rising sign). The eastern horizon at birth, defining outward personality and physical appearance.
    pub ascendant: NatalChartResponseAscendant,
    /// All planetary aspects found in this chart with orbs, strength, and interpretation.
    pub aspects: Vec<NatalChartResponseAspectsItem>,
    /// Aspect pattern analysis showing the balance of harmonious vs challenging energies in the chart.
    #[serde(rename = "aspectsInterpretation")]
    pub aspects_interpretation: NatalChartResponseAspectsInterpretation,
    /// Birth details echoed back from the request. Confirms the input used for this chart calculation.
    #[serde(rename = "birthDetails")]
    pub birth_details: NatalChartResponseBirthDetails,
    /// House system used for this chart (placidus, whole-sign, equal, or koch).
    #[serde(rename = "houseSystem")]
    pub house_system: String,
    /// All 12 house cusps with zodiac positions. House cusps divide the chart into life areas.
    pub houses: Vec<NatalChartResponseHousesItem>,
    /// Midheaven (MC). The highest point of the ecliptic at birth, representing career direction and public image.
    pub midheaven: NatalChartResponseMidheaven,
    /// Part of Fortune (Lot of Fortune). A point derived from the Ascendant and the two luminaries that marks an area of ease, vitality, and material wellbeing in the chart.
    #[serde(rename = "partOfFortune")]
    pub part_of_fortune: NatalChartResponsePartOfFortune,
    /// Detected multi-planet aspect configurations (Grand Trine, Kite, T-Square, Grand Cross, Yod, Mystic Rectangle, Stellium). Grand Cross suppresses contained T-Squares, Kite suppresses underlying Grand Trine.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub patterns: Option<Vec<NatalChartResponsePatternsItem>>,
    /// All 14 celestial bodies (10 classical planets, lunar nodes, Chiron, Black Moon Lilith) with zodiac signs, house placements, and interpretations.
    pub planets: Vec<NatalChartResponsePlanetsItem>,
    /// Chart summary with dominant element, modality, retrograde planets, and distribution analysis.
    pub summary: NatalChartResponseSummary,
    /// Vertex. The western intersection of the prime vertical with the ecliptic, often read as a point of fated encounters and turning-point relationships. The opposite point is the Anti-Vertex.
    pub vertex: NatalChartResponseVertex,
}
/// Vertex. The western intersection of the prime vertical with the ecliptic, often read as a point of fated encounters and turning-point relationships. The opposite point is the Anti-Vertex.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NatalChartResponseVertex {
    /// Degree within the Vertex sign (0-29.999).
    pub degree: f64,
    /// House containing this point, resolved against the same cusps as `planets[].house` and using the requested house system. Read this field rather than inferring a house from the sign: the two disagree whenever a house spans more than one sign, which is most of the time outside Whole Sign.
    pub house: i64,
    /// Absolute ecliptic longitude of the Vertex (0-360).
    pub longitude: f64,
    /// Zodiac sign holding the Vertex.
    pub sign: String,
    /// Vertex sign name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
}
/// Chart summary with dominant element, modality, retrograde planets, and distribution analysis.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NatalChartResponseSummary {
    /// Element holding the most of the ten planets, Sun through Pluto (Fire, Earth, Air, Water). A tie goes to the tied element holding the Sun, else the Moon, else the Ascendant, else the first of Mercury through Pluto. Always English, whatever the lang parameter says. Use dominantElementLocalized for anything a reader sees.
    #[serde(rename = "dominantElement")]
    pub dominant_element: String,
    /// Element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(
        rename = "dominantElementLocalized",
        skip_serializing_if = "Option::is_none"
    )]
    pub dominant_element_localized: Option<String>,
    /// Modality holding the most of the ten planets, Sun through Pluto (Cardinal, Fixed, Mutable). A tie is broken as for dominantElement: the Sun, then the Moon, then the Ascendant, then Mercury through Pluto. Always English, whatever the lang parameter says. Use dominantModalityLocalized for anything a reader sees.
    #[serde(rename = "dominantModality")]
    pub dominant_modality: String,
    /// Modality name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(
        rename = "dominantModalityLocalized",
        skip_serializing_if = "Option::is_none"
    )]
    pub dominant_modality_localized: Option<String>,
    /// Count of the ten planets, Sun through Pluto, in each element; the four counts sum to 10. The lunar nodes, Chiron and Lilith are points, not planets, and are not counted. Shows elemental emphasis in the personality.
    #[serde(rename = "elementDistribution")]
    pub element_distribution: NatalChartResponseSummaryElementDistribution,
    /// Count of the ten planets, Sun through Pluto, in each modality; the three counts sum to 10, and the lunar nodes, Chiron and Lilith are not counted. Shows the dominant operating mode.
    #[serde(rename = "modalityDistribution")]
    pub modality_distribution: NatalChartResponseSummaryModalityDistribution,
    /// Bodies in retrograde motion at the time of birth: the ten planets and the chart points (lunar nodes, Chiron, Lilith) alike. Always English, whatever the lang parameter says. Use retrogradePlanetsLocalized for anything a reader sees.
    #[serde(rename = "retrogradePlanets")]
    pub retrograde_planets: Vec<String>,
    /// The same retrograde bodies in the requested language, for display only. Index aligned with retrogradePlanets, so entry n of one names entry n of the other. Present only when lang is set to a language other than English, since in English it would repeat retrogradePlanets exactly.
    #[serde(
        rename = "retrogradePlanetsLocalized",
        skip_serializing_if = "Option::is_none"
    )]
    pub retrograde_planets_localized: Option<Vec<String>>,
}
/// Count of the ten planets, Sun through Pluto, in each modality; the three counts sum to 10, and the lunar nodes, Chiron and Lilith are not counted. Shows the dominant operating mode.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NatalChartResponseSummaryModalityDistribution {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, f64>,
}
/// Count of the ten planets, Sun through Pluto, in each element; the four counts sum to 10. The lunar nodes, Chiron and Lilith are points, not planets, and are not counted. Shows elemental emphasis in the personality.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NatalChartResponseSummaryElementDistribution {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, f64>,
}
/// One entry of `planets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NatalChartResponsePlanetsItem {
    /// Degree within the zodiac sign (0-29.999).
    pub degree: f64,
    /// Essential dignity of this body in the sign it occupies: domicile (the sign it rules, its strongest placement), exaltation (honoured and amplified), detriment (opposite its rulership, where it struggles), fall (opposite its exaltation, where it is weakened), or peregrine (in none of its own dignity signs). Absent for the lunar nodes, Chiron and Black Moon Lilith, which rule no sign and therefore hold no dignity at all, so an absent field and peregrine are different answers. Derived by sign only, so triplicity, bounds and face are not considered. Always English, whatever the lang parameter says, so it stays safe to compare against in code. The four dignity signs behind it are published per body by GET /planet-meanings/{id}.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dignity: Option<NatalChartResponsePlanetsItemDignity>,
    /// House placement (1-12) based on the selected house system.
    pub house: f64,
    /// Planet-in-sign-in-house interpretation. Narrative analysis of what this placement means in the natal chart.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interpretation: Option<NatalChartResponsePlanetsItemInterpretation>,
    /// Whether the planet is in retrograde motion.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Apparent geocentric ecliptic latitude of date, in degrees.
    pub latitude: f64,
    /// Apparent geocentric tropical longitude on the true ecliptic of date, in degrees (0-360): light time and aberration applied, nutation included, the convention desktop chart software and the NASA JPL Horizons observer tables print, so it compares directly with either.
    pub longitude: f64,
    /// Planet or point name (Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto, North Node, South Node, Chiron, Black Moon Lilith). Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees. The lunar nodes follow the request nodeType, which defaults to the true (osculating) node; pass "mean" for the smoothed node. The two differ by up to about 1.8 degrees and no other body is affected. Black Moon Lilith is always the mean lunar apogee, whatever nodeType says. POST /lilith returns the mean and the true (osculating) apogee side by side, each labelled by its variant.
    pub name: String,
    /// Planet or point name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tropical zodiac sign this planet occupies. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use signLocalized for anything a reader sees.
    pub sign: String,
    /// Zodiac sign name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
    /// Daily motion in degrees per day. Negative values indicate retrograde.
    pub speed: f64,
}
/// Planet-in-sign-in-house interpretation. Narrative analysis of what this placement means in the natal chart.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NatalChartResponsePlanetsItemInterpretation {
    /// Multi-sentence detailed interpretation with personality insights.
    pub detailed: String,
    /// Key personality traits and themes for this placement.
    pub keywords: Vec<String>,
    /// One-sentence interpretation of this planet in its sign and house placement.
    pub summary: String,
}
string_enum! {
    /// Essential dignity of this body in the sign it occupies: domicile (the sign it rules, its strongest placement), exaltation (honoured and amplified), detriment (opposite its rulership, where it struggles), fall (opposite its exaltation, where it is weakened), or peregrine (in none of its own dignity signs). Absent for the lunar nodes, Chiron and Black Moon Lilith, which rule no sign and therefore hold no dignity at all, so an absent field and peregrine are different answers. Derived by sign only, so triplicity, bounds and face are not considered. Always English, whatever the lang parameter says, so it stays safe to compare against in code. The four dignity signs behind it are published per body by GET /planet-meanings/{id}.
    NatalChartResponsePlanetsItemDignity {
        Domicile = "domicile",
        Exaltation = "exaltation",
        Detriment = "detriment",
        Fall = "fall",
        Peregrine = "peregrine",
    }
}
/// One entry of `patterns`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NatalChartResponsePatternsItem {
    /// Focal planet for Kite, T-Square, and Yod patterns. Receives the released energy of the configuration and is the recommended integration point.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub apex: Option<String>,
    /// True if the pattern is out-of-sign (one or more planets in a neighboring element or modality). Dissociate patterns are still valid but operate with weakened thematic coherence.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dissociate: Option<bool>,
    /// Dominant element when the pattern is element-coherent (Grand Trine, Kite). Reported lowercase. Absent for patterns whose meaning does not pivot on element.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub element: Option<NatalChartResponsePatternsItemElement>,
    /// Concise one-line interpretation naming the participating planets and theme. Localized to the requested language via the lang query parameter (defaults to English).
    pub interpretation: String,
    /// Stable template identifier used to render the interpretation. Useful for clients that wish to swap in a custom narrative template while preserving the structured variables.
    #[serde(rename = "interpretationKey")]
    pub interpretation_key: String,
    /// Variables that were interpolated into the interpretation template. Names already resolved to the requested language where appropriate.
    #[serde(rename = "interpretationVars")]
    pub interpretation_vars: NatalChartResponsePatternsItemInterpretationVars,
    /// Pattern kind identifier. GRAND_TRINE (3 trines, harmonious flow), KITE (Grand Trine with a focal outlet planet), T_SQUARE (opposition with squared apex, growth engine), GRAND_CROSS (4 planets in 2 oppositions and 4 squares, peak tension), YOD (Finger of Fate, fated adjustment), MYSTIC_RECTANGLE (oppositions softened by trines and sextiles), STELLIUM (3+ planets clustered in a sign or 10-degree arc).
    pub kind: NatalChartResponsePatternsItemKind,
    /// Dominant modality for tension-based patterns (T-Square, Grand Cross). Cardinal initiates, Fixed sustains, Mutable adapts.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub modality: Option<NatalChartResponsePatternsItemModality>,
    /// Human-readable name of the configuration as used in astrological literature.
    pub name: String,
    /// Participating bodies in canonical order. For Kite, T-Square, and Yod the apex planet appears first.
    pub planets: Vec<String>,
    /// Tightness score (0-100) derived from the average orb tightness across all defining aspects. Higher means closer to exact and stronger thematic expression.
    pub tightness: f64,
}
string_enum! {
    /// Dominant modality for tension-based patterns (T-Square, Grand Cross). Cardinal initiates, Fixed sustains, Mutable adapts.
    NatalChartResponsePatternsItemModality {
        Cardinal = "cardinal",
        Fixed = "fixed",
        Mutable = "mutable",
    }
}
string_enum! {
    /// Pattern kind identifier. GRAND_TRINE (3 trines, harmonious flow), KITE (Grand Trine with a focal outlet planet), T_SQUARE (opposition with squared apex, growth engine), GRAND_CROSS (4 planets in 2 oppositions and 4 squares, peak tension), YOD (Finger of Fate, fated adjustment), MYSTIC_RECTANGLE (oppositions softened by trines and sextiles), STELLIUM (3+ planets clustered in a sign or 10-degree arc).
    NatalChartResponsePatternsItemKind {
        GrandTrine = "GRAND_TRINE",
        Kite = "KITE",
        TSquare = "T_SQUARE",
        GrandCross = "GRAND_CROSS",
        Yod = "YOD",
        MysticRectangle = "MYSTIC_RECTANGLE",
        Stellium = "STELLIUM",
    }
}
/// Variables that were interpolated into the interpretation template. Names already resolved to the requested language where appropriate.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NatalChartResponsePatternsItemInterpretationVars {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, String>,
}
string_enum! {
    /// Dominant element when the pattern is element-coherent (Grand Trine, Kite). Reported lowercase. Absent for patterns whose meaning does not pivot on element.
    NatalChartResponsePatternsItemElement {
        Fire = "fire",
        Earth = "earth",
        Air = "air",
        Water = "water",
    }
}
/// Part of Fortune (Lot of Fortune). A point derived from the Ascendant and the two luminaries that marks an area of ease, vitality, and material wellbeing in the chart.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NatalChartResponsePartOfFortune {
    /// Degree within the Part of Fortune sign (0-29.999).
    pub degree: f64,
    /// House containing this point, resolved against the same cusps as `planets[].house` and using the requested house system. Read this field rather than inferring a house from the sign: the two disagree whenever a house spans more than one sign, which is most of the time outside Whole Sign.
    pub house: i64,
    /// Absolute ecliptic longitude of the Part of Fortune (0-360).
    pub longitude: f64,
    /// Chart sect used for the calculation. Day (diurnal) when the Sun is above the horizon, night (nocturnal) when below. Day charts use Ascendant plus Moon minus Sun, night charts use Ascendant plus Sun minus Moon.
    pub sect: NatalChartResponsePartOfFortuneSect,
    /// Zodiac sign holding the Part of Fortune.
    pub sign: String,
    /// Part of Fortune sign name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
}
string_enum! {
    /// Chart sect used for the calculation. Day (diurnal) when the Sun is above the horizon, night (nocturnal) when below. Day charts use Ascendant plus Moon minus Sun, night charts use Ascendant plus Sun minus Moon.
    NatalChartResponsePartOfFortuneSect {
        Day = "day",
        Night = "night",
    }
}
/// Midheaven (MC). The highest point of the ecliptic at birth, representing career direction and public image.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NatalChartResponseMidheaven {
    /// Degree within the Midheaven sign (0-29.999).
    pub degree: f64,
    /// Absolute ecliptic longitude of the Midheaven (0-360).
    pub longitude: f64,
    /// Zodiac sign on the Midheaven (MC). Always English, whatever the lang parameter says. Use signLocalized for anything a reader sees.
    pub sign: String,
    /// Midheaven sign name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
}
/// One entry of `houses`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NatalChartResponseHousesItem {
    /// Degree within the zodiac sign (0-29.999).
    pub degree: f64,
    /// Ecliptic longitude of this house cusp (0-360).
    pub longitude: f64,
    /// House number (1-12).
    pub number: f64,
    /// Zodiac sign on this house cusp. Always English, whatever the lang parameter says. Use signLocalized for anything a reader sees.
    pub sign: String,
    /// Zodiac sign name on this cusp in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
}
/// Birth details echoed back from the request. Confirms the input used for this chart calculation.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NatalChartResponseBirthDetails {
    /// Birth date used for this chart (YYYY-MM-DD).
    pub date: String,
    /// Birth latitude in decimal degrees.
    pub latitude: f64,
    /// Birth longitude in decimal degrees.
    pub longitude: f64,
    /// Birth time used for this chart (HH:MM:SS, 24-hour).
    pub time: String,
    /// Timezone offset from UTC in decimal hours.
    pub timezone: f64,
}
/// Aspect pattern analysis showing the balance of harmonious vs challenging energies in the chart.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NatalChartResponseAspectsInterpretation {
    /// Count of challenging aspects (square, opposition).
    pub challenging: f64,
    /// Whether the chart is predominantly harmonious, challenging, or balanced.
    pub dominant: String,
    /// Count of harmonious aspects (trine, sextile).
    pub harmonious: f64,
    /// Count of neutral aspects (conjunction).
    pub neutral: f64,
    /// Narrative summary of the overall aspect pattern in this chart.
    pub summary: String,
}
/// One entry of `aspects`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NatalChartResponseAspectsItem {
    /// Exact angle of this aspect type in degrees.
    pub angle: f64,
    /// Narrative interpretation of this aspect for this chart. The reference description of the aspect TYPE is not repeated per row, use GET or POST /astrology/aspects for that card.
    #[serde(rename = "aspectInterpretation")]
    pub aspect_interpretation: NatalChartResponseAspectsItemAspectInterpretation,
    /// Aspect nature: harmonious, challenging, or neutral. Always English, whatever the lang parameter says, because it is an identifier to compare and style on. Read aspectInterpretation for the sentence a reader sees.
    pub interpretation: String,
    /// Whether the aspect is applying (growing stronger) or separating (fading).
    #[serde(rename = "isApplying")]
    pub is_applying: bool,
    /// Distance from exact aspect in degrees. Tighter orb means stronger influence.
    pub orb: f64,
    /// First planet in the aspect pair. Always English, whatever the lang parameter says. Use planet1Localized for anything a reader sees.
    pub planet1: String,
    /// First planet name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "planet1Localized", skip_serializing_if = "Option::is_none")]
    pub planet1_localized: Option<String>,
    /// Second planet in the aspect pair. Always English, whatever the lang parameter says. Use planet2Localized for anything a reader sees.
    pub planet2: String,
    /// Second planet name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "planet2Localized", skip_serializing_if = "Option::is_none")]
    pub planet2_localized: Option<String>,
    /// Aspect strength percentage (0-100) based on orb tightness.
    pub strength: f64,
    /// Aspect type (CONJUNCTION, OPPOSITION, TRINE, SQUARE, SEXTILE, etc.). Always English, whatever the lang parameter says. Use typeLocalized for anything a reader sees.
    pub r#type: String,
    /// Aspect type name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "typeLocalized", skip_serializing_if = "Option::is_none")]
    pub type_localized: Option<String>,
}
/// Narrative interpretation of this aspect for this chart. The reference description of the aspect TYPE is not repeated per row, use GET or POST /astrology/aspects for that card.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NatalChartResponseAspectsItemAspectInterpretation {
    /// Themes this aspect activates between the two bodies. Translated in place, so they arrive in the requested language.
    pub keywords: Vec<String>,
    /// One-sentence read of THIS pair: which two bodies, how tight the aspect is, whether it is applying or separating, and how it is classified. Translated in place, so it arrives in the requested language.
    pub summary: String,
}
/// Ascendant (rising sign). The eastern horizon at birth, defining outward personality and physical appearance.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NatalChartResponseAscendant {
    /// Degree within the Ascendant sign (0-29.999).
    pub degree: f64,
    /// Absolute ecliptic longitude of the Ascendant (0-360).
    pub longitude: f64,
    /// Zodiac sign on the Ascendant (rising sign). Always English, whatever the lang parameter says. Use signLocalized for anything a reader sees.
    pub sign: String,
    /// Ascendant sign name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
}
/// Request body of `generateNatalChart`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NatalChartRequest {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// House system for dividing the chart into 12 houses. Placidus (default) is most popular in Western astrology and time-sensitive. Whole Sign assigns one sign per house (simpler, ancient). Equal houses divide chart into 30° segments from Ascendant. Koch emphasizes houses in high latitudes.
    #[serde(rename = "houseSystem", skip_serializing_if = "Option::is_none")]
    pub house_system: Option<NatalChartRequestHouseSystem>,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<NatalChartRequestNodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
    pub timezone: NatalChartRequestTimezone,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum NatalChartRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    NatalChartRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// House system for dividing the chart into 12 houses. Placidus (default) is most popular in Western astrology and time-sensitive. Whole Sign assigns one sign per house (simpler, ancient). Equal houses divide chart into 30° segments from Ascendant. Koch emphasizes houses in high latitudes.
    NatalChartRequestHouseSystem {
        Placidus = "placidus",
        WholeSign = "whole-sign",
        Equal = "equal",
        Koch = "koch",
    }
}
/// Response body of `getNakshatra`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NakshatraResponse {
    /// Personality traits, behavioral tendencies, and life themes for natives born under this nakshatra.
    pub characteristics: String,
    /// Presiding deity of the nakshatra. Influences the spiritual qualities and mythology associated with natives.
    pub deity: String,
    /// Unique slug identifier for the nakshatra. Used in URL paths and cross-references.
    pub id: String,
    /// Ruling planet (nakshatra lord) used in Vimshottari dasha calculations. Determines the planetary period sequence.
    pub lord: String,
    /// Nakshatra name as used in Vedic astrology. One of 27 lunar mansions spanning 13 degrees 20 minutes each.
    pub name: String,
    /// Sequential number (1-27) of this nakshatra in the zodiac starting from 0 degrees Aries.
    pub number: f64,
    /// Sidereal longitude range this nakshatra occupies within its zodiac sign.
    pub range: String,
    /// Traditional Vedic remedies including mantras, gemstones, and rituals for this nakshatra.
    pub remedies: NakshatraResponseRemedies,
    /// Traditional symbol representing this nakshatra. Reflects its core nature and energy.
    pub symbol: String,
}
/// Traditional Vedic remedies including mantras, gemstones, and rituals for this nakshatra.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NakshatraResponseRemedies {
    /// Recommended gemstones aligned with the ruling planet of this nakshatra.
    pub gemstones: String,
    /// Recommended mantras for this nakshatra to enhance positive qualities.
    pub mantras: String,
    /// Spiritual practices and daily rituals beneficial for natives of this nakshatra.
    pub rituals: String,
}
/// Response body of `listNakshatras`.
pub type NakshatraListResponse = Vec<NakshatraListResponseItem>;
/// One form of \[`NakshatraListResponse`\].
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NakshatraListResponseItem {
    /// Personality traits, behavioral tendencies, and life themes for natives born under this nakshatra.
    pub characteristics: String,
    /// Presiding deity of the nakshatra. Influences the spiritual qualities and mythology associated with natives.
    pub deity: String,
    /// Unique slug identifier for the nakshatra. Used in URL paths and cross-references.
    pub id: String,
    /// Ruling planet (nakshatra lord) used in Vimshottari dasha calculations. Determines the planetary period sequence.
    pub lord: String,
    /// Nakshatra name as used in Vedic astrology. One of 27 lunar mansions spanning 13 degrees 20 minutes each.
    pub name: String,
    /// Sequential number (1-27) of this nakshatra in the zodiac starting from 0 degrees Aries.
    pub number: f64,
    /// Sidereal longitude range this nakshatra occupies within its zodiac sign.
    pub range: String,
    /// Traditional Vedic remedies including mantras, gemstones, and rituals for this nakshatra.
    pub remedies: NakshatraListResponseItemRemedies,
    /// Traditional symbol representing this nakshatra. Reflects its core nature and energy.
    pub symbol: String,
}
/// Traditional Vedic remedies including mantras, gemstones, and rituals for this nakshatra.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct NakshatraListResponseItemRemedies {
    /// Recommended gemstones aligned with the ruling planet of this nakshatra.
    pub gemstones: String,
    /// Recommended mantras for this nakshatra to enhance positive qualities.
    pub mantras: String,
    /// Spiritual practices and daily rituals beneficial for natives of this nakshatra.
    pub rituals: String,
}
/// Response body of `checkManglikDosha`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ManglikResponse {
    /// Human-readable Manglik dosha analysis with Mars house placement
    pub description: String,
    /// Manglik dosha effects on marriage, personality, and relationships
    #[serde(skip_serializing_if = "Option::is_none")]
    pub effects: Option<ManglikResponseEffects>,
    /// Classical cancellation factors that reduce Manglik dosha severity (own sign, exaltation, benefic aspects)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub exceptions: Option<Vec<String>>,
    /// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
    pub frame: ManglikResponseFrame,
    /// Whether Manglik dosha (Kuja dosha) is present based on Mars placement from Lagna
    pub present: bool,
    /// Traditional Vedic remedies for Manglik dosha mitigation based on severity level
    #[serde(skip_serializing_if = "Option::is_none")]
    pub remedies: Option<Vec<String>>,
    /// Manglik dosha intensity, Mild (houses 2, 12), Moderate (houses 4, 7), Severe (houses 1, 8)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub severity: Option<ManglikResponseSeverity>,
}
string_enum! {
    /// Manglik dosha intensity, Mild (houses 2, 12), Moderate (houses 4, 7), Severe (houses 1, 8)
    ManglikResponseSeverity {
        Mild = "Mild",
        Moderate = "Moderate",
        Severe = "Severe",
    }
}
/// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ManglikResponseFrame {
    /// Sidereal frame this chart was cast in, echoing the ayanamsa request field. "lahiri" when the field was omitted.
    pub ayanamsa: String,
    /// Degrees actually subtracted from every tropical longitude to produce this chart, read at the birth instant. Subtract it back to recover the tropical positions, or compare it against your reference software to confirm you are in the same frame before chasing a placement difference.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
}
/// Manglik dosha effects on marriage, personality, and relationships
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ManglikResponseEffects {
    /// Impact of Manglik dosha on marriage and marital harmony
    pub marriage: String,
    /// Influence on temperament and behavioral traits
    pub personality: String,
    /// Impact on interpersonal and spousal relationships
    pub relationships: String,
    /// Age-related intensity and Mars maturity effects
    pub timing: String,
}
/// Request body of `checkManglikDosha`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ManglikRequest {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<ManglikRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<ManglikRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum ManglikRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    ManglikRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Path and query parameters of `lookupHexagram`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct LookupHexagramParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<LookupHexagramParamsLang>,
    /// Six-digit binary pattern (0=yin/broken, 1=yang/solid) from bottom to top.
    pub lines: String,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    LookupHexagramParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `lookupAuspiciousDays`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct LookupAuspiciousDaysResponse {
    /// Echo of the activity searched for, folded to its canonical identifier.
    pub activity: String,
    /// Display label for the activity in the requested language.
    #[serde(rename = "activityLabel")]
    pub activity_label: String,
    /// Echo of the animal protected. Absent when none was sent, rather than null.
    #[serde(rename = "avoidAnimal", skip_serializing_if = "Option::is_none")]
    pub avoid_animal: Option<String>,
    /// Display name of the protected animal in the requested language, beside the avoidAnimal identifier. Absent when no animal was sent and absent when lang is en, so an English response is unchanged.
    #[serde(rename = "avoidAnimalLocalized", skip_serializing_if = "Option::is_none")]
    pub avoid_animal_localized: Option<String>,
    /// The favoured days, in date order.
    pub days: Vec<LookupAuspiciousDaysResponseDaysItem>,
    /// Number of days in the range, counting both ends.
    #[serde(rename = "daysSearched")]
    pub days_searched: f64,
    /// Echo of the last date of the range.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Echo of the first date of the range.
    #[serde(rename = "startDate")]
    pub start_date: String,
    /// Number of favoured days found. This is the count after the clash filter, not the number of days searched.
    pub total: f64,
}
/// One entry of `days`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct LookupAuspiciousDaysResponseDaysItem {
    /// Activity identifiers, always English kebab case so they stay safe to compare against in code. Use the /calendar/auspicious-days endpoint to search a date range for one of them.
    pub avoids: Vec<String>,
    /// The zodiac animal the day clashes with, which is the animal six branches away from the day branch. Anyone born in that animal year traditionally avoids the day for anything important.
    #[serde(rename = "clashAnimal")]
    pub clash_animal: String,
    /// Display name of the clashing animal in the requested language. Absent when lang is en, so an English response is unchanged.
    #[serde(rename = "clashAnimalLocalized", skip_serializing_if = "Option::is_none")]
    pub clash_animal_localized: Option<String>,
    /// The Gregorian date of the day, at the reference meridian.
    pub date: String,
    /// The `dayOfficer` field.
    #[serde(rename = "dayOfficer")]
    pub day_officer: LookupAuspiciousDaysResponseDaysItemDayOfficer,
    /// The `dayPillar` field.
    #[serde(rename = "dayPillar")]
    pub day_pillar: LookupAuspiciousDaysResponseDaysItemDayPillar,
    /// Activity identifiers, always English kebab case so they stay safe to compare against in code. Use the /calendar/auspicious-days endpoint to search a date range for one of them.
    pub favours: Vec<String>,
    /// The `lunar` field.
    pub lunar: LookupAuspiciousDaysResponseDaysItemLunar,
    /// The `mansion` field.
    pub mansion: LookupAuspiciousDaysResponseDaysItemMansion,
    /// Sexagenary month pillar of the day, and the pillar the day officer is counted from. Attributed by whole days like the year pillar, so the day a minor solar term falls on belongs to the new month even when the term arrives late in the evening. This is what an almanac prints, and it is not the same as the month pillar of a birth moment inside that day.
    #[serde(rename = "monthPillar")]
    pub month_pillar: LookupAuspiciousDaysResponseDaysItemMonthPillar,
    /// Sexagenary year pillar of the day. Attributed by whole days, so the day Li Chun falls on belongs to the new year for its whole length. A BaZi chart built from a birth TIME uses the term instant instead, so a birth in the hours before the term on that same day carries the previous year pillar.
    #[serde(rename = "yearPillar")]
    pub year_pillar: LookupAuspiciousDaysResponseDaysItemYearPillar,
}
/// Sexagenary year pillar of the day. Attributed by whole days, so the day Li Chun falls on belongs to the new year for its whole length. A BaZi chart built from a birth TIME uses the term instant instead, so a birth in the hours before the term on that same day carries the previous year pillar.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct LookupAuspiciousDaysResponseDaysItemYearPillar {
    /// Earthly Branch of the pillar, one of zi chou yin mao chen si wu wei shen you xu hai.
    pub branch: String,
    /// The pillar in Chinese characters. A data field, identical in every language.
    pub chinese: String,
    /// Pillar identifier as stem-branch, e.g. jia-zi. Always English pinyin, whatever the lang parameter says, so it stays safe to compare against in code.
    pub id: String,
    /// Na Yin sound element of the pillar. It is a property of the pair, not of the stem, so it often names a different phase from the stem itself.
    #[serde(rename = "naYin")]
    pub na_yin: String,
    /// Five phase the Na Yin resolves to. Always English, so it stays safe to compare against in code.
    #[serde(rename = "naYinElement")]
    pub na_yin_element: String,
    /// Position in the sixty year cycle, 1 to 60. jia-zi is 1 and gui-hai is 60.
    pub number: f64,
    /// Heavenly Stem of the pillar, one of jia yi bing ding wu ji geng xin ren gui.
    pub stem: String,
}
/// Sexagenary month pillar of the day, and the pillar the day officer is counted from. Attributed by whole days like the year pillar, so the day a minor solar term falls on belongs to the new month even when the term arrives late in the evening. This is what an almanac prints, and it is not the same as the month pillar of a birth moment inside that day.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct LookupAuspiciousDaysResponseDaysItemMonthPillar {
    /// Earthly Branch of the pillar, one of zi chou yin mao chen si wu wei shen you xu hai.
    pub branch: String,
    /// The pillar in Chinese characters. A data field, identical in every language.
    pub chinese: String,
    /// Pillar identifier as stem-branch, e.g. jia-zi. Always English pinyin, whatever the lang parameter says, so it stays safe to compare against in code.
    pub id: String,
    /// Na Yin sound element of the pillar. It is a property of the pair, not of the stem, so it often names a different phase from the stem itself.
    #[serde(rename = "naYin")]
    pub na_yin: String,
    /// Five phase the Na Yin resolves to. Always English, so it stays safe to compare against in code.
    #[serde(rename = "naYinElement")]
    pub na_yin_element: String,
    /// Position in the sixty year cycle, 1 to 60. jia-zi is 1 and gui-hai is 60.
    pub number: f64,
    /// Heavenly Stem of the pillar, one of jia yi bing ding wu ji geng xin ren gui.
    pub stem: String,
}
/// The `mansion` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct LookupAuspiciousDaysResponseDaysItemMansion {
    /// Animal emblem of the mansion, the third character of its full Chinese name. English and canonical, identical in every language, matching how clashAnimal behaves on the same response. The translation is in animalLocalized.
    pub animal: String,
    /// Animal emblem in the requested language. Absent when lang is en, and absent when a language has no entry, so a caller falls back to animal.
    #[serde(rename = "animalLocalized", skip_serializing_if = "Option::is_none")]
    pub animal_localized: Option<String>,
    /// The mansion in Chinese. A data field, identical in every language.
    pub chinese: String,
    /// English display name of the mansion. Canonical, identical in every language. The translation is in nameLocalized. Note the mansion has no string id: number is the stable 1 to 28 key, because five of the 28 share a pinyin spelling.
    pub name: String,
    /// Display name of the mansion in the requested language. Absent when lang is en, and absent when a language has no entry for this mansion, so a caller falls back to name rather than rendering a blank.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Mansion number, 1 to 28, counted from the Horn. This is the identifier: three mansions share the pinyin wei and two share bi, so there is no unique pinyin key.
    pub number: f64,
    /// One of the four palaces, seven mansions each: azure-dragon, black-tortoise, white-tiger, vermilion-bird. Always English, so it stays safe to compare against in code.
    pub palace: String,
    /// Tone marked pinyin for the character.
    pub pinyin: String,
    /// The luminary the mansion belongs to, one of Wood Metal Earth Sun Moon Fire Water. Twenty eight mansions over seven luminaries is four weeks exactly, which is why a mansion always falls on the same weekday.
    pub planet: String,
}
/// The `lunar` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct LookupAuspiciousDaysResponseDaysItemLunar {
    /// The Gregorian date this lunar day covers, evaluated at the reference meridian.
    pub date: String,
    /// Day of the lunar month, 1 to 30. A lunar month never has 31 days.
    pub day: f64,
    /// True when this is the leap repetition of the month number rather than the first pass through it.
    #[serde(rename = "isLeapMonth")]
    pub is_leap_month: bool,
    /// Lunar month, 1 to 12. A leap month repeats the number of the month it follows.
    pub month: f64,
    /// Days in this lunar month, 29 for a short month or 30 for a long one. It is the interval between two new moons, so it varies month to month.
    #[serde(rename = "monthLength")]
    pub month_length: f64,
    /// Lunisolar year. It advances on the first day of month 1, not at Li Chun, so it can lag the Gregorian year by up to seven weeks.
    pub year: f64,
}
/// The `dayPillar` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct LookupAuspiciousDaysResponseDaysItemDayPillar {
    /// Earthly Branch of the pillar, one of zi chou yin mao chen si wu wei shen you xu hai.
    pub branch: String,
    /// The pillar in Chinese characters. A data field, identical in every language.
    pub chinese: String,
    /// Pillar identifier as stem-branch, e.g. jia-zi. Always English pinyin, whatever the lang parameter says, so it stays safe to compare against in code.
    pub id: String,
    /// Na Yin sound element of the pillar. It is a property of the pair, not of the stem, so it often names a different phase from the stem itself.
    #[serde(rename = "naYin")]
    pub na_yin: String,
    /// Five phase the Na Yin resolves to. Always English, so it stays safe to compare against in code.
    #[serde(rename = "naYinElement")]
    pub na_yin_element: String,
    /// Position in the sixty year cycle, 1 to 60. jia-zi is 1 and gui-hai is 60.
    pub number: f64,
    /// Heavenly Stem of the pillar, one of jia yi bing ding wu ji geng xin ren gui.
    pub stem: String,
}
/// The `dayOfficer` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct LookupAuspiciousDaysResponseDaysItemDayOfficer {
    /// The officer in Chinese. A data field, identical in every language.
    pub chinese: String,
    /// Day officer identifier, one of jian chu man ping ding zhi po wei cheng shou kai bi. Always English pinyin, so it stays safe to compare against in code.
    pub id: String,
    /// What the officer means, in the terms a date choice uses it in.
    pub meaning: String,
    /// English display name of the officer. Canonical, identical in every language, so it stays safe to compare against in code. The translation is in nameLocalized.
    pub name: String,
    /// Display name of the officer in the requested language. Absent when lang is en, so an English response is unchanged.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone marked pinyin for the character.
    pub pinyin: String,
    /// Whether the officer falls on the auspicious or the inauspicious side of the coarse yellow and black split. Read favours and avoids for what the day actually rules on.
    pub quality: String,
}
/// Request body of `lookupAuspiciousDays`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct LookupAuspiciousDaysRequest {
    /// Activity to choose a date for. One of wedding, travel, moving-house, opening-business, signing-contracts, construction, groundbreaking, burial, medical-treatment, praying. Matching folds case and punctuation, so moving-house and MOVING_HOUSE both resolve.
    pub activity: LookupAuspiciousDaysRequestActivity,
    /// Zodiac animal to protect. Days that clash with this animal are dropped from the results, which is how a date is chosen around the people attending rather than in the abstract. One of rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, pig.
    #[serde(rename = "avoidAnimal", skip_serializing_if = "Option::is_none")]
    pub avoid_animal: Option<LookupAuspiciousDaysRequestAvoidAnimal>,
    /// Last date of the range to search, inclusive. The range may not exceed 93 days.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// First date of the range to search, inclusive.
    #[serde(rename = "startDate")]
    pub start_date: String,
}
string_enum! {
    /// Zodiac animal to protect. Days that clash with this animal are dropped from the results, which is how a date is chosen around the people attending rather than in the abstract. One of rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, pig.
    LookupAuspiciousDaysRequestAvoidAnimal {
        Rat = "rat",
        Ox = "ox",
        Tiger = "tiger",
        Rabbit = "rabbit",
        Dragon = "dragon",
        Snake = "snake",
        Horse = "horse",
        Goat = "goat",
        Monkey = "monkey",
        Rooster = "rooster",
        Dog = "dog",
        Pig = "pig",
    }
}
string_enum! {
    /// Activity to choose a date for. One of wedding, travel, moving-house, opening-business, signing-contracts, construction, groundbreaking, burial, medical-treatment, praying. Matching folds case and punctuation, so moving-house and MOVING_HOUSE both resolve.
    LookupAuspiciousDaysRequestActivity {
        Wedding = "wedding",
        Travel = "travel",
        MovingHouse = "moving-house",
        OpeningBusiness = "opening-business",
        SigningContracts = "signing-contracts",
        Construction = "construction",
        Groundbreaking = "groundbreaking",
        Burial = "burial",
        MedicalTreatment = "medical-treatment",
        Praying = "praying",
    }
}
/// Path and query parameters of `lookupAuspiciousDays`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct LookupAuspiciousDaysParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<LookupAuspiciousDaysParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    LookupAuspiciousDaysParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `generateLocalSpace`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct LocalSpaceResponse {
    /// The birthplace and birth instant the map was computed for.
    #[serde(rename = "birthDetails")]
    pub birth_details: LocalSpaceResponseBirthDetails,
    /// Every requested body with its horizon direction, altitude, compass direction, great-circle line, and interpretation.
    pub bodies: Vec<LocalSpaceResponseBodiesItem>,
    /// One-line overview of the local space map.
    pub summary: String,
}
/// One entry of `bodies`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct LocalSpaceResponseBodiesItem {
    /// True when the body is above the local horizon (altitude greater than 0) at the birth moment.
    #[serde(rename = "aboveHorizon")]
    pub above_horizon: bool,
    /// Angular height of the body above (positive) or below (negative) the local horizon at birth, in degrees (-90 to 90).
    pub altitude: f64,
    /// Compass bearing of the body as seen from the birthplace, in degrees clockwise from true north (0 = north, 90 = east, 180 = south, 270 = west). This is the direction the local space line points.
    pub azimuth: f64,
    /// Nearest 16-point compass abbreviation for the azimuth (N, NNE, NE, ENE, E, ESE, SE, SSE, S, SSW, SW, WSW, W, WNW, NW, NNW).
    #[serde(rename = "compassDirection")]
    pub compass_direction: String,
    /// Plain-language reading of what travelling or facing along this body line tends to emphasize. Localized when a translation exists.
    pub interpretation: String,
    /// The great-circle directional line for this body, ready to plot on a map.
    pub line: LocalSpaceResponseBodiesItemLine,
    /// Body name (Sun, Moon, Mercury through Pluto, plus North Node, Chiron, or Black Moon Lilith when requested). Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use planetLocalized for anything a reader sees.
    pub planet: String,
    /// Body name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "planetLocalized", skip_serializing_if = "Option::is_none")]
    pub planet_localized: Option<String>,
    /// Unicode astronomical symbol for this body.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub symbol: Option<String>,
}
/// The great-circle directional line for this body, ready to plot on a map.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct LocalSpaceResponseBodiesItemLine {
    /// Ordered latitude and longitude waypoints tracing the great-circle local space line from the birthplace along the body azimuth. The first point is the birthplace itself.
    pub points: Vec<LocalSpaceResponseBodiesItemLinePointsItem>,
}
/// One entry of `points`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct LocalSpaceResponseBodiesItemLinePointsItem {
    /// Waypoint latitude in decimal degrees.
    pub latitude: f64,
    /// Waypoint longitude in decimal degrees.
    pub longitude: f64,
}
/// The birthplace and birth instant the map was computed for.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct LocalSpaceResponseBirthDetails {
    /// Birth date echoed from the request.
    pub date: String,
    /// Birthplace latitude, the origin of every local space line.
    pub latitude: f64,
    /// Birthplace longitude, the origin of every local space line.
    pub longitude: f64,
    /// Birth time echoed from the request.
    pub time: String,
    /// Timezone offset from UTC applied to the birth instant.
    pub timezone: f64,
}
/// All 12 tropical zodiac signs with names, symbols, elements, date ranges, and descriptions.
pub type ListZodiacSignsResponse = Vec<ListZodiacSignsResponseItem>;
/// One form of \[`ListZodiacSignsResponse`\].
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListZodiacSignsResponseItem {
    /// Tropical zodiac date range for this sign.
    pub dates: ListZodiacSignsResponseItemDates,
    /// Brief overview of this zodiac sign personality and themes.
    pub description: String,
    /// Elemental classification: fire, earth, air, or water. Always one of these four English literals, whatever the lang parameter says, so it stays safe to compare against in code. Use elementLocalized for anything a reader sees.
    pub element: ListZodiacSignsResponseItemElement,
    /// Element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Lowercase sign identifier (e.g., aries, taurus, gemini).
    pub id: String,
    /// Display name of the zodiac sign.
    pub name: String,
    /// Unicode zodiac symbol for this sign.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub symbol: Option<String>,
}
string_enum! {
    /// Elemental classification: fire, earth, air, or water. Always one of these four English literals, whatever the lang parameter says, so it stays safe to compare against in code. Use elementLocalized for anything a reader sees.
    ListZodiacSignsResponseItemElement {
        Fire = "fire",
        Earth = "earth",
        Air = "air",
        Water = "water",
    }
}
/// Tropical zodiac date range for this sign.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListZodiacSignsResponseItemDates {
    /// End date of this sign in the tropical zodiac.
    pub end: String,
    /// Start date of this sign in the tropical zodiac.
    pub start: String,
}
/// Path and query parameters of `listZodiacSigns`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListZodiacSignsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListZodiacSignsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListZodiacSignsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listZodiacAnimals`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListZodiacAnimalsResponse {
    /// Animals for the current page, in cycle order. Use /zodiac/animals/{id} for the full record with strengths, weaknesses, element variants and relationship partners.
    pub animals: Vec<ListZodiacAnimalsResponseAnimalsItem>,
    /// Maximum items returned for this page.
    pub limit: f64,
    /// Number of items skipped before this page.
    pub offset: f64,
    /// Total animals in the cycle. Always 12; the zodiac is a closed set.
    pub total: f64,
}
/// One entry of `animals`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListZodiacAnimalsResponseAnimalsItem {
    /// Earthly Branch this animal names, as its pinyin identifier. The twelve branches are zi, chou, yin, mao, chen, si, wu, wei, shen, you, xu, hai, and they run in the same order as the animals. Every animal element, polarity and double-hour is a property of this branch.
    pub branch: String,
    /// Traditional hanzi character for the animal itself, not for its Earthly Branch. Data rather than a translation, so it is identical under every lang.
    pub chinese: String,
    /// Fixed Five Element (Wu Xing) phase of the animal own branch: Wood, Fire, Earth, Metal or Water. This never changes for a sign. It is NOT the year phase that makes a Metal Rat differ from a Water Rat, which comes from the year Heavenly Stem. Always English so it stays safe to compare against and to key colours off.
    pub element: String,
    /// Five Element phase name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Stable machine identifier for the animal. Always English and lowercase, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees. The twelve ids are rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, pig.
    pub id: String,
    /// Display name of the animal in English. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Animal name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone-marked Hanyu Pinyin for the animal name. Data rather than a translation, so it is identical under every lang.
    pub pinyin: String,
    /// Yin or yang polarity of the branch. The twelve branches alternate, starting yang at zi, so the six odd-numbered animals are yang and the six even-numbered are yin.
    pub polarity: String,
    /// Short trait keywords for the sign, lowercase in English. Built for tag clouds, sign cards and compatibility widgets that need a glanceable character sketch rather than a paragraph.
    pub traits: Vec<String>,
}
/// Path and query parameters of `listZodiacAnimals`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListZodiacAnimalsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListZodiacAnimalsParamsLang>,
    /// Maximum items to return per page. Range: 1-12, default 12.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListZodiacAnimalsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listYogas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListYogasResponse {
    /// Number of yogas in this response, which is the filtered count when `family` is supplied and the full catalog size otherwise. Includes Raj Yogas, Dhan Yogas, Pancha Mahapurusha Yogas, Nabhasa Yogas, and more.
    pub total: f64,
    /// Array of planetary yogas with basic identifiers, narrowed by `family` when that filter is supplied. Use GET /yoga/{id} for formation rules, effects, and quality classification.
    pub yogas: Vec<ListYogasResponseYogasItem>,
}
/// One entry of `yogas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListYogasResponseYogasItem {
    /// Nabhasa family, present only on the 32 Nabhasa distribution yogas and absent on every other catalog row. Never translated, so it groups identically under any lang.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub family: Option<ListYogasResponseYogasItemFamily>,
    /// Unique yoga identifier in lowercase kebab-case. Use this to fetch full details via GET /yoga/{id}.
    pub id: String,
    /// Traditional Sanskrit name of the planetary yoga combination.
    pub name: String,
}
string_enum! {
    /// Nabhasa family, present only on the 32 Nabhasa distribution yogas and absent on every other catalog row. Never translated, so it groups identically under any lang.
    ListYogasResponseYogasItemFamily {
        Classical = "classical",
        Asraya = "asraya",
        Dala = "dala",
        Akriti = "akriti",
        Sankhya = "sankhya",
    }
}
/// Path and query parameters of `listYogas`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListYogasParams {
    /// Filter the catalog to one Nabhasa family: asraya (3), dala (2), akriti (20) or sankhya (7). Omit for the full catalog. `classical` is accepted but matches nothing here, because it is a detection-verdict value for single-combination yogas rather than a catalog grouping.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub family: Option<ListYogasParamsFamily>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListYogasParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListYogasParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Filter the catalog to one Nabhasa family: asraya (3), dala (2), akriti (20) or sankhya (7). Omit for the full catalog. `classical` is accepted but matches nothing here, because it is a detection-verdict value for single-combination yogas rather than a catalog grouping.
    ListYogasParamsFamily {
        Classical = "classical",
        Asraya = "asraya",
        Dala = "dala",
        Akriti = "akriti",
        Sankhya = "sankhya",
    }
}
/// Response body of `listTrigrams`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListTrigramsResponse {
    /// Total number of I-Ching trigrams (always 8).
    pub total: f64,
    /// All 8 trigrams (bagua) with basic details.
    pub trigrams: Vec<BasicTrigram>,
}
/// One entry of `trigrams`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BasicTrigram {
    /// Core attribute/quality
    pub attribute: String,
    /// Binary representation (1=Yang solid, 0=Yin broken)
    pub binary: String,
    /// Chinese name
    pub chinese: String,
    /// English name
    pub english: String,
    /// Trigram number (1-8)
    pub number: f64,
    /// Pinyin romanization
    pub pinyin: String,
    /// Unicode trigram symbol
    pub symbol: String,
}
/// Path and query parameters of `listTrigrams`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListTrigramsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListTrigramsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListTrigramsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listTrecenas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListTrecenasResponse {
    /// Maximum items returned for this page.
    pub limit: f64,
    /// Number of items skipped before this page.
    pub offset: f64,
    /// Total trecenas in the round. Always 20, because 260 divided by 13 is exactly 20.
    pub total: f64,
    /// Trecenas for the current page, in order from the one that opens on 1 Imix.
    pub trecenas: Vec<ListTrecenasResponseTrecenasItem>,
}
/// One entry of `trecenas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListTrecenasResponseTrecenasItem {
    /// Days in the period. Always 13, which is what the word trecena means.
    pub length: f64,
    /// Which of the twenty thirteen day periods this is, 1 to 20. Trecena 1 opens on 1 Imix and the openers step thirteen signs at a time from there.
    pub number: f64,
    /// The composed reading of the period, built from the sign it opens on. Composed rather than stored, so it can never drift away from the day sign it is drawn from.
    pub reading: String,
    /// Machine identifier of the day sign the period opens on, which the tradition reads as colouring all thirteen of its days.
    #[serde(rename = "rulingSign")]
    pub ruling_sign: String,
    /// Kʼicheʼ name of the same sign, the vocabulary a highland reading uses.
    #[serde(rename = "rulingSignKiche")]
    pub ruling_sign_kiche: String,
    /// Display name of the sign the period opens on. A proper noun carried as data.
    #[serde(rename = "rulingSignName")]
    pub ruling_sign_name: String,
}
/// Path and query parameters of `listTrecenas`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListTrecenasParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListTrecenasParamsLang>,
    /// Maximum items to return per page. Range: 1-20, default 20.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListTrecenasParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listSolarTerms`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListSolarTermsResponse {
    /// Decimal UTC offset of the reference meridian the local fields are given at. Fixed at 8 for the Chinese calendar.
    #[serde(rename = "referenceOffset")]
    pub reference_offset: f64,
    /// The `terms` field.
    pub terms: Vec<ListSolarTermsResponseTermsItem>,
    /// Number of terms returned, which is always 24.
    pub total: f64,
    /// Echo of the solar year requested.
    pub year: f64,
}
/// One entry of `terms`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListSolarTermsResponseTermsItem {
    /// The term in Chinese. A data field, identical in every language.
    pub chinese: String,
    /// Solar term identifier in kebab case pinyin. Always English pinyin, whatever the lang parameter says, because the English names are not standardised and would not be safe to compare against.
    pub id: String,
    /// The instant the sun reaches the longitude, in UTC.
    #[serde(rename = "instantUtc")]
    pub instant_utc: String,
    /// Calendar date of the instant at the reference meridian. This is the date printed in an almanac.
    #[serde(rename = "localDate")]
    pub local_date: String,
    /// Time of day of the instant at the reference meridian.
    #[serde(rename = "localTime")]
    pub local_time: String,
    /// Apparent solar longitude in degrees that defines the term. A multiple of 15, and the only thing about a term that is not a convention.
    pub longitude: f64,
    /// Display name of the term. Several English renderings are in circulation, so treat this as a label and the id as the value.
    pub name: String,
    /// Tone marked pinyin for the characters.
    pub pinyin: String,
    /// Either minor or major. The month pillar changes at the twelve MINOR terms, and a lunar month containing no MAJOR term is the leap month.
    pub r#type: String,
}
/// Path and query parameters of `listSolarTerms`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListSolarTermsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListSolarTermsParamsLang>,
    /// Solar year, 1900 to 2100. The year opens at Li Chun rather than on 1 January, so its last two terms fall in the following January.
    pub year: i64,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListSolarTermsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listShemNames`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListShemNamesResponse {
    /// How many rows this page carries at most.
    pub limit: f64,
    /// Echo of the longitude looked up. Absent when the whole list was requested.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// The `names` field.
    pub names: Vec<ListShemNamesResponseNamesItem>,
    /// How many rows were skipped before this page.
    pub offset: f64,
    /// Number of names matching the request before paging, which is 72 for the list and 1 for a longitude lookup.
    pub total: f64,
}
/// One entry of `names`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListShemNamesResponseNamesItem {
    /// Last degree of the arc, EXCLUSIVE. Seventy two arcs of five degrees tile the circle exactly, which only works if the upper bound is exclusive.
    #[serde(rename = "arcEnd")]
    pub arc_end: f64,
    /// First degree of the ecliptic arc this name governs, measured from 0 Aries. Inclusive.
    #[serde(rename = "arcStart")]
    pub arc_start: f64,
    /// The angelic choir this name belongs to under the published Renaissance table. Nine choirs of exactly eight names each.
    pub choir: String,
    /// Where the arc opens inside its sign, 0 to 25 in steps of five.
    #[serde(rename = "degreeInSign")]
    pub degree_in_sign: f64,
    /// The three letters read out of the verses, with any word final form written as its base letter, which is how every published list prints them.
    pub letters: String,
    /// The three letters exactly as they stand in the verses. Eighteen of the seventy two pick up a word final form because the source letter falls at a word end, and keeping this beside the normalized form is what makes the rule auditable.
    #[serde(rename = "lettersAsWritten")]
    pub letters_as_written: String,
    /// The suffixed name in Hebrew. Data, identical in every language.
    pub name: String,
    /// Index of the name, 1 to 72. The index is the identifier here, because the Latin spellings differ between published tables while the index never does.
    pub number: f64,
    /// Present only on the rows where a named published list differs from the derivation. Recorded rather than silently corrected, because a reader comparing two sources deserves to know which one moved. Absent on every other row, so a caller can branch on presence.
    #[serde(rename = "publishedDisagreement", skip_serializing_if = "Option::is_none")]
    pub published_disagreement: Option<
        ListShemNamesResponseNamesItemPublishedDisagreement,
    >,
    /// Latin transcription of the Hebrew, from the one mechanical letter map. A label for reading the string back, and NOT the spelling the published tables print, which is in traditionalName.
    pub romanization: String,
    /// Which sign the arc falls in. Always English lowercase, so it stays safe to compare against in code. Six names fall in each sign.
    pub sign: String,
    /// The divine name suffix added to make the triplet pronounceable. Forty of the seventy two take one and thirty two take the other.
    pub suffix: String,
    /// The Latin spelling the published tables print. This is the search term a reader knows the name by. Several rows have two attested spellings across tables and the one used here is stated on the methodology page.
    #[serde(rename = "traditionalName")]
    pub traditional_name: String,
}
/// Present only on the rows where a named published list differs from the derivation. Recorded rather than silently corrected, because a reader comparing two sources deserves to know which one moved. Absent on every other row, so a caller can branch on presence.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListShemNamesResponseNamesItemPublishedDisagreement {
    /// Which published list prints something different on this row.
    pub list: String,
    /// What that list prints, so a caller matching against it can see why.
    pub prints: String,
}
/// Path and query parameters of `listShemNames`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListShemNamesParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListShemNamesParamsLang>,
    /// Maximum items to return per page. Range: 1-72, default 20.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Ecliptic longitude in degrees, 0 inclusive to 360 exclusive, measured from 0 Aries. Returns the single name governing that degree instead of the list. 360 is rejected because it is the same point as 0 and the arcs are half open at the top.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListShemNamesParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `listRashis`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListRashisParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListRashisParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListRashisParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listRasas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListRasasResponse {
    /// Maximum tastes returned in this page.
    pub limit: f64,
    /// The same eighteen cells indexed by dosha rather than by taste, keyed vata, pitta and kapha. Derived from the rows above rather than restated, so the two views cannot disagree.
    pub matrix: ListRasasResponseMatrix,
    /// Scope of the response.
    pub meta: ListRasasResponseMeta,
    /// Number of tastes skipped before this page.
    pub offset: f64,
    /// The tastes for this page, in the order the root verse names them.
    pub rasas: Vec<ListRasasResponseRasasItem>,
    /// Every work behind this response, once each.
    pub sources: Vec<ListRasasResponseSourcesItem>,
    /// The six in the order the verse names them, which the verse then says is the order in which they give strength, most first. The order is a claim rather than a presentation choice, so it is published separately from the page above.
    #[serde(rename = "strengthOrder")]
    pub strength_order: Vec<String>,
    /// Total number of tastes, which is always six.
    pub total: f64,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListRasasResponseSourcesItem {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// One of the six tastes.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListRasasResponseRasasItem {
    /// The doshas this taste lowers, as Sanskrit identifiers. Each taste lowers exactly three across the three doshas and raises the others, which is the structure that makes the matrix complete.
    pub decreases: Vec<String>,
    /// The same name in Devanagari. Data, identical in every language.
    pub devanagari: String,
    /// The mahabhutas the taste arises from. Single-sourced, and from an edition that is not public domain, so the reference ships and the wording does not. That edition gives the sweet taste ONE element where material in general circulation gives it a pair.
    pub elements: Vec<String>,
    /// The taste in the requested language. This is the gloss and it does translate.
    pub english: String,
    /// The taste as a Sanskrit identifier. Never translated, so it stays safe to compare against and to key a lookup on. The six are madhura, amla, lavana, tikta, katu and kashaya.
    pub id: String,
    /// The doshas this taste raises, as Sanskrit identifiers.
    pub increases: Vec<String>,
    /// The same name in the standard diacritic transliteration.
    #[serde(rename = "sanskritName")]
    pub sanskrit_name: String,
    /// The form the root verse itself uses, where it differs from the identifier. The verse spells the pungent taste one way and the rest of the literature spells it another, and both are carried so a reader checking the Sanskrit does not conclude a row is missing.
    #[serde(rename = "textForm")]
    pub text_form: String,
}
/// Scope of the response.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListRasasResponseMeta {
    /// The scope of everything in this response, in the requested language. Present on every response from this API, and intended to be shown to the reader rather than stripped.
    pub disclaimer: String,
}
/// The same eighteen cells indexed by dosha rather than by taste, keyed vata, pitta and kapha. Derived from the rows above rather than restated, so the two views cannot disagree.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListRasasResponseMatrix {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<
        String,
        ListRasasResponseMatrixAdditionalProperty,
    >,
}
/// What a caller finds under any dosha key: the three tastes that lower it and the three that raise it.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListRasasResponseMatrixAdditionalProperty {
    /// The three tastes that lower this dosha.
    #[serde(rename = "decreasedBy")]
    pub decreased_by: Vec<String>,
    /// The three tastes that raise it.
    #[serde(rename = "increasedBy")]
    pub increased_by: Vec<String>,
}
/// Path and query parameters of `listRasas`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListRasasParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListRasasParamsLang>,
    /// Maximum items to return per page. Range: 1-6, default 6.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListRasasParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// All 14 astrological bodies with names, symbols, taglines, categories, and brief descriptions.
pub type ListPlanetMeaningsResponse = Vec<ListPlanetMeaningsResponseItem>;
/// One form of \[`ListPlanetMeaningsResponse`\].
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListPlanetMeaningsResponseItem {
    /// Planet classification: personal (Sun-Mars), social (Jupiter-Saturn), or generational (Uranus-Pluto).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub category: Option<String>,
    /// Brief overview of the planet and its astrological significance.
    pub description: String,
    /// Lowercase planet identifier (e.g., sun, moon, mercury).
    pub id: String,
    /// Display name of the planet.
    pub name: String,
    /// Zodiac sign this planet rules. The sign where the planet operates most naturally. Absent for the lunar nodes, Chiron, and Black Moon Lilith.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rulership: Option<String>,
    /// Unicode astronomical symbol for this planet.
    pub symbol: String,
    /// Short tagline summarizing this planet in astrology.
    pub tagline: String,
}
/// Path and query parameters of `listPlanetMeanings`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListPlanetMeaningsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListPlanetMeaningsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListPlanetMeaningsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listNinePeriods`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListNinePeriodsResponse {
    /// The period in force on that date. Resolved at Li Chun, so a date in January belongs to the previous solar year and can fall in the previous period. A date is read at the start of its day in the Chinese calendar frame (UTC+8) and Li Chun falls part-way through its own day, so the date a period opens on still reads as the previous period, the same reading the Kua route gives a birth date.
    #[serde(rename = "currentPeriod")]
    pub current_period: f64,
    /// Last solar year of the recorded cycle. The cycle then repeats, so 2044 opens Period 1 again.
    #[serde(rename = "cycleEndYear")]
    pub cycle_end_year: f64,
    /// First solar year of the recorded 180 year cycle.
    #[serde(rename = "cycleStartYear")]
    pub cycle_start_year: f64,
    /// The date the current period was resolved for. Echoes the date requested, or the current UTC date when it was omitted.
    pub date: String,
    /// All nine periods of the 180 year cycle in order, each with its ruling star, element, palace and exact opening date.
    pub periods: Vec<ListNinePeriodsResponsePeriodsItem>,
    /// Number of periods in the cycle. Always nine.
    pub total: f64,
}
/// One entry of `periods`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListNinePeriodsResponsePeriodsItem {
    /// Flying star number, 1 to 9. The number IS the identifier of the star: 8 is always the Eight White Earth star whichever plate it appears on.
    pub base: f64,
    /// Five phase of this entry: Wood, Fire, Earth, Metal or Water. Always English so it stays safe to compare against and to key styling on. The full cycles live on the Chinese astrology elements endpoint.
    pub element: String,
    /// Last solar year of the period. The next period opens at Li Chun of the year after.
    #[serde(rename = "endYear")]
    pub end_year: f64,
    /// Which sixty year era the period belongs to: upper, middle or lower, three periods each. Always English, safe to compare against.
    pub era: String,
    /// Display name of the era.
    #[serde(rename = "eraName")]
    pub era_name: String,
    /// Period number, 1 to 9. A building takes the period it was completed in and keeps that period plate for its whole life, so this is the first input to every natal chart.
    pub number: f64,
    /// Palace the ruling star owns on the Lo Shu base plate. Always English, safe to compare against.
    pub palace: String,
    /// Flying star number, 1 to 9. The number IS the identifier of the star: 8 is always the Eight White Earth star whichever plate it appears on.
    #[serde(rename = "rulingStar")]
    pub ruling_star: f64,
    /// Display name of the ruling star. Always English, whatever the lang parameter says. Use rulingStarNameLocalized for anything a reader sees.
    #[serde(rename = "rulingStarName")]
    pub ruling_star_name: String,
    /// Ruling star name in the requested language, for display only. Present only when lang is set to a language other than English.
    #[serde(rename = "rulingStarNameLocalized", skip_serializing_if = "Option::is_none")]
    pub ruling_star_name_localized: Option<String>,
    /// Exact date the period opened, computed astronomically. Li Chun is commonly quoted as 4 February and falls on the 3rd or the 5th in roughly one year in four, which is what decides whether a building finished in early February belongs to this period or the last.
    #[serde(rename = "startDate")]
    pub start_date: String,
    /// First solar year of the period. The period opens at Li Chun of this year, in early February, not on 1 January.
    #[serde(rename = "startYear")]
    pub start_year: f64,
    /// Trigram of the ruling star palace. Absent for Period 5, whose star owns the centre and has no trigram.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trigram: Option<ListNinePeriodsResponsePeriodsItemTrigram>,
}
/// Trigram of the ruling star palace. Absent for Period 5, whose star owns the centre and has no trigram.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListNinePeriodsResponsePeriodsItemTrigram {
    /// Chinese character for the trigram. Data, identical in every language.
    pub chinese: String,
    /// English name of the trigram, byte identical to the I-Ching catalogue.
    pub english: String,
    /// Trigram number, the same identifier the I-Ching trigram endpoints use.
    pub number: f64,
}
/// Path and query parameters of `listNinePeriods`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListNinePeriodsParams {
    /// Date to resolve the current period for, in YYYY-MM-DD format. Defaults to today in UTC. Useful for asking which period a building was completed in. A date landing exactly on the Li Chun day a period opens is placed in the outgoing period.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListNinePeriodsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListNinePeriodsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `listNakshatras`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListNakshatrasParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListNakshatrasParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListNakshatrasParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listMayanDaySigns`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListMayanDaySignsResponse {
    /// The conventions this listing was served under. Only the direction scheme applies here, because it is the only field on a catalogue row that a school split moves.
    pub conventions: ListMayanDaySignsResponseConventions,
    /// Day signs for the current page, in sequence order. Use /mayan/day-signs/{id} for the full record with the composed reading, strengths, challenges and guidance.
    #[serde(rename = "daySigns")]
    pub day_signs: Vec<ListMayanDaySignsResponseDaySignsItem>,
    /// Maximum items returned for this page.
    pub limit: f64,
    /// Number of items skipped before this page.
    pub offset: f64,
    /// Total signs in the cycle. Always 20; the Tzolkin sign set is closed.
    pub total: f64,
}
/// One entry of `daySigns`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListMayanDaySignsResponseDaySignsItem {
    /// Colour paired with the direction: red for east, white for north, black for west, yellow for south. Always English so it stays safe to key a palette off.
    pub color: String,
    /// World direction this sign belongs to under the requested scheme: east, north, west or south. The twenty signs divide evenly into four groups of five, so exactly five signs share each quarter.
    pub direction: String,
    /// The short day-name association, translated in place because it is a common noun rather than a name. Two published readings of the twenty signs disagree on six of them, so the alternate reading ships beside this one rather than one being resolved away.
    pub gloss: String,
    /// The glyph-table reading of the same sign, translated in place. On the six signs where the two readings disagree this is the one the composed prose follows, so a reading that seems to ignore the gloss above is doing so deliberately.
    #[serde(rename = "glossAlternate")]
    pub gloss_alternate: String,
    /// Machine identifier of the day sign, always lowercase ASCII Yucatec whatever the lang parameter says, so it stays safe to compare against in code and to use as a path parameter. The twenty ids run imix, ik, akbal, kan, chikchan, kimi, manik, lamat, muluk, ok, chuwen, eb, ben, ix, men, kib, kaban, etznab, kawak, ajaw.
    pub id: String,
    /// The sixteenth century Yucatec spelling of the same sign, which is the form most printed reference tables and older books use.
    #[serde(rename = "nameClassic")]
    pub name_classic: String,
    /// The Kʼicheʼ name from the living highland daykeeping tradition, which is the vocabulary a nawal reading in Guatemala uses. A parallel naming tradition rather than a translation, so it is identical under every lang.
    #[serde(rename = "nameKiche")]
    pub name_kiche: String,
    /// Display name in the standard Maya orthography, where an ejective is written with a modifier letter rather than a typewriter quote. A proper noun carried as data, identical under every lang.
    #[serde(rename = "nameYucatec")]
    pub name_yucatec: String,
    /// Place in the twenty sign sequence, 1 to 20, counting Imix as 1. The sequence never varies and is what every other cycle in the domain is indexed against.
    pub position: f64,
}
/// The conventions this listing was served under. Only the direction scheme applies here, because it is the only field on a catalogue row that a school split moves.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListMayanDaySignsResponseConventions {
    /// The direction reading actually applied. The two readings sit one quarter turn apart, so a direction stored without this value is ambiguous.
    #[serde(rename = "directionScheme")]
    pub direction_scheme: String,
}
/// Path and query parameters of `listMayanDaySigns`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListMayanDaySignsParams {
    /// Which reading of the world direction and colour to serve for a day sign. The two published assignments differ by exactly one quarter turn on all twenty signs, so neither is a rounding of the other and a silent pick would be a school choice. "madrid-codex" is the codex reading and the default; "landa" is the sixteenth century assignment recorded beside it.
    #[serde(rename = "directionScheme", skip_serializing_if = "Option::is_none")]
    pub direction_scheme: Option<ListMayanDaySignsParamsDirectionScheme>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListMayanDaySignsParamsLang>,
    /// Maximum items to return per page. Range: 1-20, default 20.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListMayanDaySignsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Which reading of the world direction and colour to serve for a day sign. The two published assignments differ by exactly one quarter turn on all twenty signs, so neither is a rounding of the other and a silent pick would be a school choice. "madrid-codex" is the codex reading and the default; "landa" is the sixteenth century assignment recorded beside it.
    ListMayanDaySignsParamsDirectionScheme {
        MadridCodex = "madrid-codex",
        Landa = "landa",
    }
}
/// Response body of `listLanguages`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListLanguagesResponse {
    /// All language codes accepted by the `lang` query parameter.
    pub languages: Vec<ListLanguagesResponseLanguagesItem>,
}
/// One entry of `languages`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListLanguagesResponseLanguagesItem {
    /// ISO 639-1 language code. Pass this value as the `lang` query parameter.
    pub code: ListLanguagesResponseLanguagesItemCode,
    /// Language name in English.
    pub name: String,
    /// Language name written in the language itself.
    #[serde(rename = "nativeName")]
    pub native_name: String,
}
string_enum! {
    /// ISO 639-1 language code. Pass this value as the `lang` query parameter.
    ListLanguagesResponseLanguagesItemCode {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listHexagrams`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListHexagramsResponse {
    /// Hexagrams for the current page. Use /hexagrams/{number} for full details.
    pub hexagrams: Vec<BasicHexagram>,
    /// Page size used for this response.
    pub limit: f64,
    /// Number of hexagrams skipped. Use with limit for pagination.
    pub offset: f64,
    /// Total number of I-Ching hexagrams (always 64).
    pub total: f64,
}
/// One entry of `hexagrams`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BasicHexagram {
    /// Original Chinese name of the hexagram.
    pub chinese: String,
    /// English translation of the hexagram name.
    pub english: String,
    /// Lower trigram (lines 1-3). Combines with upper trigram to form the hexagram.
    #[serde(rename = "lowerTrigram")]
    pub lower_trigram: String,
    /// Hexagram number in King Wen sequence (1-64).
    pub number: f64,
    /// Pinyin romanization of the Chinese name with tone marks.
    pub pinyin: String,
    /// Unicode hexagram symbol for display.
    pub symbol: String,
    /// Upper trigram (lines 4-6). One of 8 trigrams: Heaven, Earth, Thunder, Wind, Water, Fire, Mountain, Lake.
    #[serde(rename = "upperTrigram")]
    pub upper_trigram: String,
}
/// Path and query parameters of `listHexagrams`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListHexagramsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListHexagramsParamsLang>,
    /// Maximum items to return per page. Range: 1-64, default 20.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListHexagramsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listHebrewLetters`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListHebrewLettersResponse {
    /// Three, seven and twelve. Every recension agrees on the split even where it disagrees on what goes where.
    #[serde(rename = "classCounts")]
    pub class_counts: ListHebrewLettersResponseClassCounts,
    /// Echo of the reading the attributions were taken from.
    #[serde(rename = "letterAttribution")]
    pub letter_attribution: String,
    /// The `letters` field.
    pub letters: Vec<ListHebrewLettersResponseLettersItem>,
    /// Number of letters returned, which is always 22.
    pub total: f64,
}
/// One entry of `letters`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListHebrewLettersResponseLettersItem {
    /// The `attribution` field.
    pub attribution: ListHebrewLettersResponseLettersItemAttribution,
    /// What the class means, in the requested language.
    #[serde(rename = "classReading")]
    pub class_reading: String,
    /// The word final glyph, or null for the seventeen letters that have none. Five letters change shape at the end of a word and score differently there under one reading of mispar gadol.
    pub r#final: Option<String>,
    /// Value in final position under the finals-500-900 reading of mispar gadol, or null where the letter has no final form.
    #[serde(rename = "finalValue")]
    pub final_value: Option<f64>,
    /// Machine identifier of the letter, always English romanization so it stays safe to compare against in code.
    pub id: String,
    /// The base glyph. Data, identical in every language.
    pub letter: String,
    /// Sefer Yetzirah class: mother, double or simple. Three mothers take an element, seven doubles take a planet, twelve simples take a sign, and the three counts are the structure of the whole letter tradition.
    #[serde(rename = "letterClass")]
    pub letter_class: String,
    /// What the letter name means as an ordinary word, in the requested language. The names are object names, which is what the shapes were drawn from.
    pub meaning: String,
    /// Display name of the letter, in the requested language.
    pub name: String,
    /// Position in the alphabet, 1 to 22. A property of the letter, not a cipher reading.
    pub ordinal: f64,
    /// The path this letter sits on, numbered 11 to 32 to continue the ten sephirot into the thirty two Paths of Wisdom. Never null in practice: all 22 letters carry a path.
    pub path: Option<f64>,
    /// Latin transcription of the glyph, from the one mechanical letter map this API uses in both directions. A label, never a pronunciation claim.
    pub romanization: String,
    /// The `trump` field.
    pub trump: ListHebrewLettersResponseLettersItemTrump,
    /// Value under the standard reading. The 22 letters cover 1 to 9, 10 to 90 and 100 to 400.
    pub value: f64,
}
/// The `trump` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListHebrewLettersResponseLettersItemTrump {
    /// Identifier of the tarot trump on this letter path. It resolves in the Tarot API on the same key, so a caller can follow it straight to the card.
    pub id: String,
    /// Display name of the trump.
    pub name: String,
    /// The trump number as the deck prints it, in Roman numerals.
    pub number: String,
}
/// The `attribution` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListHebrewLettersResponseLettersItemAttribution {
    /// What the attribution names: element, planet or sign. Always English.
    pub kind: String,
    /// The element, planet or sign under the requested reading. Always English, so it stays safe to compare against in code.
    pub value: String,
}
/// Three, seven and twelve. Every recension agrees on the split even where it disagrees on what goes where.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListHebrewLettersResponseClassCounts {
    /// Double letters, which take a planet.
    pub double: f64,
    /// Mother letters, which take an element.
    pub mother: f64,
    /// Simple letters, which take a sign of the zodiac.
    pub simple: f64,
}
/// Path and query parameters of `listHebrewLetters`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListHebrewLettersParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListHebrewLettersParamsLang>,
    /// Which reading assigns the element, planet or sign to each letter. The seven double letters are the contested column and the four readings genuinely disagree on them; the twelve simple letters run in natural zodiacal order in all four. The golden-dawn member does NOT exchange He and Tzade, which is a later change from a different author.
    #[serde(rename = "letterAttribution", skip_serializing_if = "Option::is_none")]
    pub letter_attribution: Option<ListHebrewLettersParamsLetterAttribution>,
}
string_enum! {
    /// Which reading assigns the element, planet or sign to each letter. The seven double letters are the contested column and the four readings genuinely disagree on them; the twelve simple letters run in natural zodiacal order in all four. The golden-dawn member does NOT exchange He and Tzade, which is a later change from a different author.
    ListHebrewLettersParamsLetterAttribution {
        SeferYetzirahGra = "sefer-yetzirah-gra",
        SeferYetzirahShort = "sefer-yetzirah-short",
        SeferYetzirahSaadia = "sefer-yetzirah-saadia",
        GoldenDawn = "golden-dawn",
    }
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListHebrewLettersParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listHaabMonths`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListHaabMonthsResponse {
    /// Maximum items returned for this page.
    pub limit: f64,
    /// Periods for the current page, in order from Pop.
    pub months: Vec<ListHaabMonthsResponseMonthsItem>,
    /// Number of items skipped before this page.
    pub offset: f64,
    /// Total periods in the Haab year. Always 19: eighteen months plus Wayebʼ, which is a period of the year even though it is only five days.
    pub total: f64,
}
/// One entry of `months`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListHaabMonthsResponseMonthsItem {
    /// What the period name means, translated in place because it is a common noun rather than a name.
    pub gloss: String,
    /// Machine identifier of the Haab period, always lowercase ASCII, so it stays safe to compare against and to use as a path parameter. The nineteen ids run pop, wo, sip, sotz, sek, xul, yaxkin, mol, chen, yax, sak, keh, mak, kankin, muwan, pax, kayab, kumku, wayeb.
    pub id: String,
    /// Days in the period. Twenty for the eighteen months and five for Wayebʼ, which is never twenty. Days inside a period are numbered from 0, so a twenty day period runs 0 to 19.
    pub length: f64,
    /// The sixteenth century Yucatec spelling, which is the form most printed tables use.
    #[serde(rename = "nameClassic")]
    pub name_classic: String,
    /// Display name in the standard orthography. A proper noun carried as data, identical under every lang.
    #[serde(rename = "nameYucatec")]
    pub name_yucatec: String,
    /// Place in the Haab year, 1 to 19. Pop is 1 and Wayebʼ is 19, so a position of 19 always means the five short days.
    pub position: f64,
    /// The composed reading of the period, built from its position, its length and its gloss.
    pub reading: String,
}
/// Path and query parameters of `listHaabMonths`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListHaabMonthsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListHaabMonthsParamsLang>,
    /// Maximum items to return per page. Range: 1-19, default 19.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListHaabMonthsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listGunas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListGunasResponse {
    /// Maximum pairs returned in this page.
    pub limit: f64,
    /// Scope of the response.
    pub meta: ListGunasResponseMeta,
    /// Number of pairs skipped before this page.
    pub offset: f64,
    /// The pairs for this page. The root verse names only the first member of each and then says twenty counting their opposites; the opposites and every action word come from the commentaries.
    pub pairs: Vec<ListGunasResponsePairsItem>,
    /// The half-verse the whole domain turns on, translated in place. It is stated of ALL things rather than of food, which is why the same sentence governs the dosha states, the taste matrix, the seasonal regimen and the daily routine alike.
    pub rule: String,
    /// Every work behind this response, once each.
    pub sources: Vec<ListGunasResponseSourcesItem>,
    /// Total number of pairs, which is always ten, covering twenty qualities.
    pub total: f64,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListGunasResponseSourcesItem {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// One opposed pair of qualities.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListGunasResponsePairsItem {
    /// One of the twenty qualities.
    pub a: ListGunasResponsePairsItemA,
    /// One of the twenty qualities.
    pub b: ListGunasResponsePairsItemB,
    /// A recorded disagreement about this pair, present only where one exists. It is stated rather than resolved silently because the choice changes which dosha the pair joins to.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Position of the pair, 1 to 10, in the order the root verse names the first member of each.
    pub number: f64,
}
/// One of the twenty qualities.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListGunasResponsePairsItemB {
    /// What this quality does, from the one action word the commentary gives each of the twenty. This is what turns the list from a glossary into the mechanism the rest of the domain runs on.
    pub action: String,
    /// The same action word in Sanskrit. Data rather than a translation, so a reader can find the clause it comes from.
    #[serde(rename = "actionSanskrit")]
    pub action_sanskrit: String,
    /// Which doshas carry this quality, as Sanskrit identifiers, taken from the dosha catalogue rather than restated here. Empty where no dosha carries it under the same Sanskrit word, and note that the three dosha sets overlap, so the twenty are not partitioned three ways.
    pub doshas: Vec<String>,
    /// The quality in the requested language. This is the gloss and it does translate.
    pub english: String,
    /// The quality as a Sanskrit identifier. Never translated, so it stays safe to compare against and joins straight to the qualityGunas array on each dosha.
    pub id: String,
    /// The same name in the standard diacritic transliteration.
    #[serde(rename = "sanskritName")]
    pub sanskrit_name: String,
}
/// One of the twenty qualities.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListGunasResponsePairsItemA {
    /// What this quality does, from the one action word the commentary gives each of the twenty. This is what turns the list from a glossary into the mechanism the rest of the domain runs on.
    pub action: String,
    /// The same action word in Sanskrit. Data rather than a translation, so a reader can find the clause it comes from.
    #[serde(rename = "actionSanskrit")]
    pub action_sanskrit: String,
    /// Which doshas carry this quality, as Sanskrit identifiers, taken from the dosha catalogue rather than restated here. Empty where no dosha carries it under the same Sanskrit word, and note that the three dosha sets overlap, so the twenty are not partitioned three ways.
    pub doshas: Vec<String>,
    /// The quality in the requested language. This is the gloss and it does translate.
    pub english: String,
    /// The quality as a Sanskrit identifier. Never translated, so it stays safe to compare against and joins straight to the qualityGunas array on each dosha.
    pub id: String,
    /// The same name in the standard diacritic transliteration.
    #[serde(rename = "sanskritName")]
    pub sanskrit_name: String,
}
/// Scope of the response.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListGunasResponseMeta {
    /// The scope of everything in this response, in the requested language. Present on every response from this API, and intended to be shown to the reader rather than stripped.
    pub disclaimer: String,
}
/// Path and query parameters of `listGunas`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListGunasParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListGunasParamsLang>,
    /// Maximum items to return per page. Range: 1-10, default 10.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListGunasParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listGematriaCiphers`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListGematriaCiphersResponse {
    /// The rabbinic ciphers. Each returns a number from the letters of a Hebrew string.
    pub ciphers: Vec<ListGematriaCiphersResponseCiphersItem>,
    /// The Latin alphabet ciphers, scored on Latin letters directly. None is rabbinic and each carries the lineage that says so.
    #[serde(rename = "latinCiphers")]
    pub latin_ciphers: Vec<ListGematriaCiphersResponseLatinCiphersItem>,
    /// Number of entries across all three lists.
    pub total: f64,
    /// The rabbinic substitution transformations. Each exchanges letters for other letters and returns a WORD, whose value is then read the ordinary way.
    pub transformations: Vec<ListGematriaCiphersResponseTransformationsItem>,
}
/// One entry of `transformations`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListGematriaCiphersResponseTransformationsItem {
    /// The century the tradition this method belongs to is attested in, not a first publication date for the named variety.
    pub century: String,
    /// Whether the gematria endpoint returns a number for this cipher. False on the one method whose table is not published in two independent sources, which is stated rather than silently omitted.
    pub computed: bool,
    /// How the cipher turns letters into a number, in the requested language.
    pub definition: String,
    /// Machine identifier of the cipher, always English romanization so it stays safe to compare against in code. Pass it in the ciphers array on the gematria endpoint.
    pub id: String,
    /// Present and true where one spelling has several equally published totals. Absent otherwise, so a caller can branch on presence.
    #[serde(rename = "multiValued", skip_serializing_if = "Option::is_none")]
    pub multi_valued: Option<bool>,
    /// Display name of the cipher, in the requested language.
    pub name: String,
    /// Where the definition is published. Every cipher here carries at least two independent sources, which is why the catalogue is shorter than the ones that advertise a cipher count.
    pub sources: Vec<String>,
    /// Provenance class, one of rabbinic, renaissance-latin, golden-dawn-transliterated or modern. Always English. Read it before presenting a cipher as Jewish practice, because three of the ones here are not.
    pub tradition: String,
}
/// One entry of `latinCiphers`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListGematriaCiphersResponseLatinCiphersItem {
    /// The century the tradition this method belongs to is attested in, not a first publication date for the named variety.
    pub century: String,
    /// Whether the gematria endpoint returns a number for this cipher. False on the one method whose table is not published in two independent sources, which is stated rather than silently omitted.
    pub computed: bool,
    /// How the cipher turns letters into a number, in the requested language.
    pub definition: String,
    /// Machine identifier of the cipher, always English romanization so it stays safe to compare against in code. Pass it in the ciphers array on the gematria endpoint.
    pub id: String,
    /// Present and true where one spelling has several equally published totals. Absent otherwise, so a caller can branch on presence.
    #[serde(rename = "multiValued", skip_serializing_if = "Option::is_none")]
    pub multi_valued: Option<bool>,
    /// Display name of the cipher, in the requested language.
    pub name: String,
    /// Where the definition is published. Every cipher here carries at least two independent sources, which is why the catalogue is shorter than the ones that advertise a cipher count.
    pub sources: Vec<String>,
    /// Provenance class, one of rabbinic, renaissance-latin, golden-dawn-transliterated or modern. Always English. Read it before presenting a cipher as Jewish practice, because three of the ones here are not.
    pub tradition: String,
}
/// One entry of `ciphers`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListGematriaCiphersResponseCiphersItem {
    /// The century the tradition this method belongs to is attested in, not a first publication date for the named variety.
    pub century: String,
    /// Whether the gematria endpoint returns a number for this cipher. False on the one method whose table is not published in two independent sources, which is stated rather than silently omitted.
    pub computed: bool,
    /// How the cipher turns letters into a number, in the requested language.
    pub definition: String,
    /// Machine identifier of the cipher, always English romanization so it stays safe to compare against in code. Pass it in the ciphers array on the gematria endpoint.
    pub id: String,
    /// Present and true where one spelling has several equally published totals. Absent otherwise, so a caller can branch on presence.
    #[serde(rename = "multiValued", skip_serializing_if = "Option::is_none")]
    pub multi_valued: Option<bool>,
    /// Display name of the cipher, in the requested language.
    pub name: String,
    /// Where the definition is published. Every cipher here carries at least two independent sources, which is why the catalogue is shorter than the ones that advertise a cipher count.
    pub sources: Vec<String>,
    /// Provenance class, one of rabbinic, renaissance-latin, golden-dawn-transliterated or modern. Always English. Read it before presenting a cipher as Jewish practice, because three of the ones here are not.
    pub tradition: String,
}
/// Path and query parameters of `listGematriaCiphers`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListGematriaCiphersParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListGematriaCiphersParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListGematriaCiphersParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listFlyingStars`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListFlyingStarsResponse {
    /// Page size applied.
    pub limit: f64,
    /// Number of entries skipped.
    pub offset: f64,
    /// The nine flying stars in Lo Shu order, 1 through 9.
    pub stars: Vec<ListFlyingStarsResponseStarsItem>,
    /// Number of stars in the catalogue.
    pub total: f64,
}
/// One entry of `stars`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListFlyingStarsResponseStarsItem {
    /// Flying star number, 1 to 9. The number IS the identifier of the star: 8 is always the Eight White Earth star whichever plate it appears on.
    pub base: f64,
    /// Chinese characters for the star. Data, identical in every language.
    pub chinese: String,
    /// Five phase of this entry: Wood, Fire, Earth, Metal or Water. Always English so it stays safe to compare against and to key styling on. The full cycles live on the Chinese astrology elements endpoint.
    pub element: String,
    /// Five phase of this entry: Wood, Fire, Earth, Metal or Water. Always English so it stays safe to compare against and to key styling on. The full cycles live on the Chinese astrology elements endpoint.
    pub enhancer: String,
    /// Themes the star governs, for tagging and for quick summaries.
    pub keywords: Vec<String>,
    /// What the star does, how it reads when timely, and how it reads when it is not.
    pub meaning: String,
    /// Display name of the star. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Star name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat name exactly. Never compare against this value.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// The untimely reading of the star, auspicious or inauspicious. It is not the whole verdict: the ruling star of the period in force is prosperous whatever this says, and a star long past its period is the one that does damage. Only the 5 is harmful in every period.
    pub nature: String,
    /// Flying star number, 1 to 9. The number IS the identifier of the star: 8 is always the Eight White Earth star whichever plate it appears on.
    pub number: f64,
    /// Palace of the Lo Shu grid: one of the eight compass sectors, or Center. Always English, safe to compare against and to key a grid cell on.
    pub palace: String,
    /// The twenty year period this star rules. A star is at its strongest during its own period and weakest long after it.
    pub period: f64,
    /// Tone-marked pinyin for the star. Data, identical in every language.
    pub pinyin: String,
    /// Five phase of this entry: Wood, Fire, Earth, Metal or Water. Always English so it stays safe to compare against and to key styling on. The full cycles live on the Chinese astrology elements endpoint.
    pub remedy: String,
    /// The trigram of the star palace. Absent for the 5, which owns the centre and has no trigram, which is also why the 5 is the one star with no direction of its own.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trigram: Option<ListFlyingStarsResponseStarsItemTrigram>,
}
/// The trigram of the star palace. Absent for the 5, which owns the centre and has no trigram, which is also why the 5 is the one star with no direction of its own.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListFlyingStarsResponseStarsItemTrigram {
    /// Chinese character for the trigram. Data, identical in every language.
    pub chinese: String,
    /// English name of the trigram, byte identical to the I-Ching catalogue.
    pub english: String,
    /// Trigram number, the same identifier the I-Ching trigram endpoints use.
    pub number: f64,
}
/// Path and query parameters of `listFlyingStars`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListFlyingStarsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListFlyingStarsParamsLang>,
    /// Maximum items to return per page. Range: 1-9, default 9.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListFlyingStarsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listFiveElements`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListFiveElementsResponse {
    /// The restraining ring in order. Each phase controls the next and the last controls the first, so this list wraps too. It is the same five phases walked two steps at a time.
    #[serde(rename = "controllingCycle")]
    pub controlling_cycle: Vec<String>,
    /// The phases for this page, in generating cycle order.
    pub elements: Vec<ListFiveElementsResponseElementsItem>,
    /// The producing ring in order. Each phase generates the next and the last generates the first, so the list wraps.
    #[serde(rename = "generatingCycle")]
    pub generating_cycle: Vec<String>,
    /// Maximum phases returned in this page.
    pub limit: f64,
    /// Number of phases skipped before this page.
    pub offset: f64,
    /// Total number of phases, which is always five.
    pub total: f64,
}
/// One entry of `elements`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListFiveElementsResponseElementsItem {
    /// The Earthly Branches that carry this phase. Wood, Fire, Metal and Water take two each and Earth takes four, the branches that sit between the seasons.
    pub branches: Vec<String>,
    /// Chinese character for the phase. A data field, identical in every language.
    pub chinese: String,
    /// The phase that restrains this one. The inverse of the controls field.
    #[serde(rename = "controlledBy")]
    pub controlled_by: String,
    /// The phase this one restrains in the controlling cycle. Wood breaks Earth, Earth dams Water, Water quenches Fire, Fire melts Metal, Metal cuts Wood.
    pub controls: String,
    /// Compass direction of the phase. Earth returns Center, because it sits at the middle of the arrangement rather than on the ring.
    pub direction: String,
    /// The phase that produces this one. The inverse of the generates field.
    #[serde(rename = "generatedBy")]
    pub generated_by: String,
    /// The phase this one produces in the generating cycle. Wood feeds Fire, Fire makes Earth, Earth bears Metal, Metal condenses Water, Water grows Wood.
    pub generates: String,
    /// Five phase identifier. Always English, whatever the lang parameter says, so it stays safe to compare against in code. The same five values appear on stems, branches, pillars, Na Yin and every feng shui star.
    pub id: String,
    /// What the phase is and how it behaves, in the terms a reading uses it in. Translated in place.
    pub meaning: String,
    /// Display name of the phase in the requested language. Absent when lang is en, so an English response is unchanged.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone marked pinyin for the character. A data field, identical in every language.
    pub pinyin: String,
    /// Season the phase governs. Earth governs the transitions rather than a season of its own, and is reported as Late Summer.
    pub season: String,
    /// The two Heavenly Stems that carry this phase, yang first. Every phase has exactly two, which is why ten stems cover five phases.
    pub stems: Vec<String>,
}
/// Path and query parameters of `listFiveElements`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListFiveElementsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListFiveElementsParamsLang>,
    /// Maximum items to return per page. Range: 1-5, default 5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListFiveElementsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listDoshas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListDoshasResponse {
    /// The doshas for this page, in the standing order the texts name them.
    pub doshas: Vec<ListDoshasResponseDoshasItem>,
    /// Maximum doshas returned in this page.
    pub limit: f64,
    /// Scope of the response.
    pub meta: ListDoshasResponseMeta,
    /// Number of doshas skipped before this page.
    pub offset: f64,
    /// Every work behind this response, once each.
    pub sources: Vec<ListDoshasResponseSourcesItem>,
    /// Total number of doshas, which is always three.
    pub total: f64,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListDoshasResponseSourcesItem {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// Scope of the response.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListDoshasResponseMeta {
    /// The scope of everything in this response, in the requested language. Present on every response from this API, and intended to be shown to the reader rather than stripped.
    pub disclaimer: String,
}
/// One dosha with its qualities, seats, pentad and states.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListDoshasResponseDoshasItem {
    /// Other names the primary texts use for the same dosha. Data rather than translations, and useful when reading a verse that names one of them instead.
    #[serde(rename = "alsoCalled")]
    pub also_called: Vec<String>,
    /// The same name in Devanagari. Data, identical in every language.
    pub devanagari: String,
    /// The single mahabhuta the classical verses give this dosha. Classically each dosha gets one element, not a pair.
    pub element: String,
    /// What the dosha does when it is even. For vata the text states this for the dosha as a whole; for the other two it states it only through the five sub-doshas, and those are what appear here.
    pub functions: Vec<String>,
    /// The dosha as a Sanskrit identifier: vata, pitta or kapha. Never translated in any language, because a caller switches on it, and a translated dosha name is a different concept rather than the same one in another language.
    pub id: String,
    /// The two-element pairing in general modern circulation. It carries no classical citation in this API, which is why it travels in its own field instead of inside the cited one.
    #[serde(rename = "modernElementPair")]
    pub modern_element_pair: String,
    /// The qualities the frame chapter gives this dosha, each as its Sanskrit word and its gloss. The three sets overlap, so the twenty gunas are not partitioned three ways between them.
    pub qualities: Vec<String>,
    /// Identifiers from the twenty gunas for the qualities the guna verse names with the SAME Sanskrit word, so this joins straight to the qualities endpoint. Where the dosha chapter uses a synonym, or a word the guna verse does not carry, the entry is absent rather than mapped by resemblance.
    #[serde(rename = "qualityGunas")]
    pub quality_gunas: Vec<String>,
    /// The same name in the standard diacritic transliteration.
    #[serde(rename = "sanskritName")]
    pub sanskrit_name: String,
    /// Where the dosha sits, in the requested language.
    pub seats: Vec<String>,
    /// How the second primary text reads the same list. The two are recorded side by side and never merged, because the special seat of pitta genuinely differs between them.
    #[serde(rename = "seatsVariant")]
    pub seats_variant: String,
    /// Where one claim in this response comes from.
    pub source: ListDoshasResponseDoshasItemSource,
    /// The seat the chapter singles out above the others.
    #[serde(rename = "specialSeat")]
    pub special_seat: String,
    /// The three states, as positions and qualities.
    pub states: ListDoshasResponseDoshasItemStates,
    /// The five sub-doshas, each with its seat and its work. The five vata NAMES are carried by two texts; every seat and function of the fifteen rests on one chapter alone.
    #[serde(rename = "subDoshas")]
    pub sub_doshas: Vec<ListDoshasResponseDoshasItemSubDoshasItem>,
}
/// One of the five sub-doshas.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListDoshasResponseDoshasItemSubDoshasItem {
    /// The same name in Devanagari. Data rather than a translation, so it is identical under every language.
    pub devanagari: String,
    /// What the sub-dosha does, in the requested language.
    pub function: String,
    /// Stable identifier for the sub-dosha. Always English-safe and lowercase, and never translated, so it is safe to compare against.
    pub id: String,
    /// Where the sub-dosha moves, where the chapter states one. Present on the five vatas and absent elsewhere, because the chapter gives a range of movement only for those.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub moves: Option<String>,
    /// The same name in the standard diacritic transliteration.
    #[serde(rename = "sanskritName")]
    pub sanskrit_name: String,
    /// Where the sub-dosha sits, in the requested language.
    pub seat: String,
    /// Where one claim in this response comes from.
    pub source: ListDoshasResponseDoshasItemSubDoshasItemSource,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListDoshasResponseDoshasItemSubDoshasItemSource {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// The three states, as positions and qualities.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListDoshasResponseDoshasItemStates {
    /// The first state of the seasonal cycle, described the same way.
    pub accumulating: String,
    /// The second state of the seasonal cycle, described the same way.
    pub aggravated: String,
    /// The even state, described as a position and a quality rather than as an absence of complaints.
    pub balanced: String,
    /// The qualities that bring the dosha back to even, which is the like-increases-like rule applied in reverse.
    #[serde(rename = "settlesWith")]
    pub settles_with: String,
    /// Where one claim in this response comes from.
    pub source: ListDoshasResponseDoshasItemStatesSource,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListDoshasResponseDoshasItemStatesSource {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListDoshasResponseDoshasItemSource {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// Path and query parameters of `listDoshas`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListDoshasParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListDoshasParamsLang>,
    /// Maximum items to return per page. Range: 1-3, default 3.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListDoshasParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listDikpalaDirections`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListDikpalaDirectionsResponse {
    /// The directions on this page, in compass order from North.
    pub directions: Vec<ListDikpalaDirectionsResponseDirectionsItem>,
    /// How many were requested per page.
    pub limit: f64,
    /// How many were skipped.
    pub offset: f64,
    /// How many directions there are in all, which is always eight.
    pub total: f64,
}
/// One entry of `directions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListDikpalaDirectionsResponseDirectionsItem {
    /// The devatas of the squares this direction covers, in the same order as the squares list.
    pub devatas: Vec<ListDikpalaDirectionsResponseDirectionsItemDevatasItem>,
    /// The lord of this quarter of the horizon, per Brihat Samhita 54.3. A Sanskrit proper noun: romanised with the diacritics the transliteration carries in every language, and written in Devanagari as the Sanskrit text prints it when lang is hi. Compare on id, never on this. These are NOT the 45 mandala devatas and the two sets must not be merged: Agni is the north-east mandala square and the south-east dikpala.
    pub dikpala: String,
    /// The element conventionally assigned to this quarter: fire, earth, air or water. Present only on the four intercardinal quarters, because the cardinal ones carry none in this scheme, and it is labelled convention because the Brihat Samhita assigns no element to any direction at all.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub element: Option<String>,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against and against the same value on the feng shui and I Ching endpoints.
    pub id: String,
    /// Whether this is one of the four cardinal directions or one of the four intercardinal quarters. Always English.
    pub kind: String,
    /// What Brihat Samhita 53.118 puts on this side, in the chapter own terms. Present on the four intercardinal quarters, which are the only ones that verse places anything on.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub places: Option<String>,
    /// The verses behind each part of this entry, and the convention label on the element where no verse gives one.
    pub sources: Vec<ListDikpalaDirectionsResponseDirectionsItemSourcesItem>,
    /// The squares of the 81 pada grid this direction covers. For a cardinal direction those are its eight perimeter squares in the order the verses enumerate them; for an intercardinal quarter they are the corner square and the four single pada squares gathered around it.
    pub squares: Vec<f64>,
    /// What the chapter says about standing water here, which it gives for all eight directions.
    pub water: ListDikpalaDirectionsResponseDirectionsItemWater,
}
/// What the chapter says about standing water here, which it gives for all eight directions.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListDikpalaDirectionsResponseDirectionsItemWater {
    /// Whether that effect is a gain or a harm. Only the north and the north-east are gains. Always English.
    pub auspiciousness: String,
    /// What 53.119 says follows from standing water in this quarter, as original prose.
    pub effect: String,
}
/// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListDikpalaDirectionsResponseDirectionsItemSourcesItem {
    /// Why a convention rule says what it says. Present only when text is convention, and it names the tradition the rule comes from rather than a verse.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub basis: Option<String>,
    /// Chapter of the primary text. Absent on a convention, which has no chapter to cite.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chapter: Option<f64>,
    /// Whether the cited edition is in the public domain. True on the 1884 Brihat Samhita edition, whose verses are quoted. False on the 1933 Manasara edition behind the Ayadi formulas, from which only the multipliers, divisors and names are taken, never a sentence.
    #[serde(rename = "publicDomain", skip_serializing_if = "Option::is_none")]
    pub public_domain: Option<bool>,
    /// The primary text this verdict rests on, or the literal value convention where no verse states the rule. Always English, safe to compare against.
    pub text: String,
    /// Translator of the edition the verse was read in. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation: Option<String>,
    /// Verse or verse range inside the chapter. Absent on a convention. A range is written with a hyphen, as in 115-117.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub verse: Option<String>,
    /// Publication year of that edition. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<f64>,
}
/// One entry of `devatas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListDikpalaDirectionsResponseDirectionsItemDevatasItem {
    /// Identifier of the devata holding it. Always English transliteration, safe to compare against and to look up on the devatas endpoint.
    pub id: String,
    /// Display name of the devata. A Sanskrit proper noun: romanised with the diacritics the transliteration carries in every language, and written in Devanagari as the Sanskrit text prints it when lang is hi.
    pub name: String,
    /// Square number in the 81 pada grid.
    pub square: f64,
}
/// Path and query parameters of `listDikpalaDirections`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListDikpalaDirectionsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListDikpalaDirectionsParamsLang>,
    /// Maximum items to return per page. Range: 1-8, default 8.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListDikpalaDirectionsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listDevatas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListDevatasResponse {
    /// The devatas on this page, in the order the verses enumerate them: the east perimeter, then south, west and north, then inward to Brahma.
    pub devatas: Vec<ListDevatasResponseDevatasItem>,
    /// How many were requested per page.
    pub limit: f64,
    /// How many were skipped.
    pub offset: f64,
    /// How many devatas there are in all. Always 45 squares held, though the chapter prints only 44 distinct names because Indra appears twice.
    pub total: f64,
}
/// One entry of `devatas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListDevatasResponseDevatasItem {
    /// The same squares as row and column pairs, which is what you draw with. The corners of the grid are 1 north-east, 9 south-east, 73 north-west and 81 south-west.
    pub cells: Vec<ListDevatasResponseDevatasItemCellsItem>,
    /// Which ring of the mandala the devata belongs to: perimeter for the outer 32, innerRing for the eight around Brahma, innerCorner for the four on the inner diagonals, center for Brahma alone. 32 plus 8 plus 4 plus 1 is 45. Always English.
    pub class: ListDevatasResponseDevatasItemClass,
    /// The entrance pada this devata governs, 1 to 32. Present only on the outer 32, since only a perimeter square can hold a main door.
    #[serde(rename = "entrancePada", skip_serializing_if = "Option::is_none")]
    pub entrance_pada: Option<f64>,
    /// How many squares the devata holds under 53.49 to 50: padika for one, dvipada for two, tripada for three. Absent for Brahma, whom those verses leave outside the scheme while enumerating 44 devatas.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub group: Option<String>,
    /// Identifier of the devata, lower case transliteration. Always English, safe to compare against. Indra appears twice in the chapter, on the east perimeter and on the inner ring, so those two carry the ids indra-outer and indra-inner, which are ours: no source read for this package prints a distinguishing name for either.
    pub id: String,
    /// Display name of the devata. A Sanskrit proper noun: romanised with the diacritics the transliteration carries in every language, and written in Devanagari as the Sanskrit text prints it when lang is hi. Compare on id, never on this.
    pub name: String,
    /// Where the sources disagree or contradict themselves about this row, and where Brahma sits outside the pada-count scheme. Present on the six rows that carry a recorded divergence: the two Indras, the north-east and south-east corner devatas where the Manasara differs from the Brihat Samhita, Prthvidhara, whom the chapter places on two different squares in two different verses, and Brahma. Original prose, translated in place when lang is set.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// How many squares the devata holds: one, two or three for the 44 enumerated devatas, and nine for Brahma.
    #[serde(rename = "padaCount")]
    pub pada_count: f64,
    /// Which quarter of the mandala the devata occupies, where it sits in one. Absent for a devata spread along a side rather than gathered in a corner.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub quadrant: Option<String>,
    /// What the devata holds, as a sentence composed from the sourced structure. There is deliberately no meaning field: no source read for this package gives a devata a meaning, and inventing one would be unsourced content on a route that sells a citation per verdict. Translated in place when lang is set.
    pub role: String,
    /// Which side of the perimeter the devata sits on. Present only on the outer 32, which are the ones the verses enumerate side by side.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub side: Option<String>,
    /// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
    pub source: ListDevatasResponseDevatasItemSource,
    /// Which of the 81 squares the devata holds. The verses name one square per devata and fix the pada count of each, and the remaining squares follow from that count: a dvipada takes its named square plus the one a step inward, a tripada the three cell cardinal run of the second ring.
    pub squares: Vec<f64>,
    /// Which verses of chapter 53 place this devata and fix its pada count, so a report can print the citation.
    pub verses: Vec<String>,
}
/// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListDevatasResponseDevatasItemSource {
    /// Why a convention rule says what it says. Present only when text is convention, and it names the tradition the rule comes from rather than a verse.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub basis: Option<String>,
    /// Chapter of the primary text. Absent on a convention, which has no chapter to cite.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chapter: Option<f64>,
    /// Whether the cited edition is in the public domain. True on the 1884 Brihat Samhita edition, whose verses are quoted. False on the 1933 Manasara edition behind the Ayadi formulas, from which only the multipliers, divisors and names are taken, never a sentence.
    #[serde(rename = "publicDomain", skip_serializing_if = "Option::is_none")]
    pub public_domain: Option<bool>,
    /// The primary text this verdict rests on, or the literal value convention where no verse states the rule. Always English, safe to compare against.
    pub text: String,
    /// Translator of the edition the verse was read in. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation: Option<String>,
    /// Verse or verse range inside the chapter. Absent on a convention. A range is written with a hyphen, as in 115-117.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub verse: Option<String>,
    /// Publication year of that edition. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<f64>,
}
string_enum! {
    /// Which ring of the mandala the devata belongs to: perimeter for the outer 32, innerRing for the eight around Brahma, innerCorner for the four on the inner diagonals, center for Brahma alone. 32 plus 8 plus 4 plus 1 is 45. Always English.
    ListDevatasResponseDevatasItemClass {
        Perimeter = "perimeter",
        InnerRing = "innerRing",
        InnerCorner = "innerCorner",
        Center = "center",
    }
}
/// One entry of `cells`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListDevatasResponseDevatasItemCellsItem {
    /// Column of the grid, 1 at the western edge and 9 at the eastern one.
    #[serde(rename = "columnFromWest")]
    pub column_from_west: f64,
    /// Row of the grid, 1 at the northern edge and 9 at the southern one.
    #[serde(rename = "rowFromNorth")]
    pub row_from_north: f64,
}
/// Path and query parameters of `listDevatas`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListDevatasParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListDevatasParamsLang>,
    /// Maximum items to return per page. Range: 1-45, default 45.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListDevatasParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listCrystals`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListCrystalsResponse {
    /// Crystal summaries for the current page.
    pub crystals: Vec<ListCrystalsResponseCrystalsItem>,
    /// Maximum crystals returned per page.
    pub limit: f64,
    /// Number of crystals skipped.
    pub offset: f64,
    /// Total number of crystals matching the filter criteria.
    pub total: f64,
}
/// One entry of `crystals`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListCrystalsResponseCrystalsItem {
    /// Chakra energy centers this crystal resonates with. One of: Root, Sacral, Solar Plexus, Heart, Throat, Third Eye, Crown.
    pub chakras: Vec<String>,
    /// Primary colors of this crystal variety. Null when color data is unavailable.
    pub colors: Option<Vec<String>>,
    /// URL-safe crystal identifier for detail lookup.
    pub id: String,
    /// URL to crystal photograph for visual identification.
    #[serde(rename = "imageUrl")]
    pub image_url: Option<String>,
    /// Crystal display name.
    pub name: String,
}
/// Path and query parameters of `listCrystals`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListCrystalsParams {
    /// Filter by chakra association, case-insensitive. Valid values: Root, Sacral, Solar Plexus, Heart, Throat, Third Eye, Crown.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chakra: Option<ListCrystalsParamsChakra>,
    /// Filter by crystal color (partial match, case-insensitive). E.g., "pink", "green", "blue", "purple". Use GET /colors for valid values.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub color: Option<String>,
    /// Filter by elemental association, case-insensitive. Valid values: Earth, Water, Fire, Air, Storm.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub element: Option<ListCrystalsParamsElement>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListCrystalsParamsLang>,
    /// Maximum items to return per page. Range: 1-100, default 20.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
    /// Filter by planetary association (partial match, case-insensitive). E.g., "Venus", "Moon", "Jupiter". Use GET /planets for valid values.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub planet: Option<String>,
    /// Filter by zodiac sign, case-insensitive. Valid values: aries, taurus, gemini, cancer, leo, virgo, libra, scorpio, sagittarius, capricorn, aquarius, pisces.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub zodiac: Option<ListCrystalsParamsZodiac>,
}
string_enum! {
    /// Filter by zodiac sign, case-insensitive. Valid values: aries, taurus, gemini, cancer, leo, virgo, libra, scorpio, sagittarius, capricorn, aquarius, pisces.
    ListCrystalsParamsZodiac {
        Aries = "aries",
        Taurus = "taurus",
        Gemini = "gemini",
        Cancer = "cancer",
        Leo = "leo",
        Virgo = "virgo",
        Libra = "libra",
        Scorpio = "scorpio",
        Sagittarius = "sagittarius",
        Capricorn = "capricorn",
        Aquarius = "aquarius",
        Pisces = "pisces",
    }
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListCrystalsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Filter by elemental association, case-insensitive. Valid values: Earth, Water, Fire, Air, Storm.
    ListCrystalsParamsElement {
        Earth = "Earth",
        Water = "Water",
        Fire = "Fire",
        Air = "Air",
        Storm = "Storm",
    }
}
string_enum! {
    /// Filter by chakra association, case-insensitive. Valid values: Root, Sacral, Solar Plexus, Heart, Throat, Third Eye, Crown.
    ListCrystalsParamsChakra {
        Root = "Root",
        Sacral = "Sacral",
        SolarPlexus = "Solar Plexus",
        Heart = "Heart",
        Throat = "Throat",
        ThirdEye = "Third Eye",
        Crown = "Crown",
    }
}
/// Path and query parameters of `listCrystalPlanets`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListCrystalPlanetsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListCrystalPlanetsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListCrystalPlanetsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `listCrystalColors`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListCrystalColorsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListCrystalColorsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListCrystalColorsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listCountries`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListCountriesResponse {
    /// Countries for the current page, sorted alphabetically by name.
    pub countries: Vec<ListCountriesResponseCountriesItem>,
    /// Page size used for this response.
    pub limit: f64,
    /// Number of countries skipped. Use with limit for pagination.
    pub offset: f64,
    /// Total number of countries with at least one place in the dataset.
    pub total: f64,
}
/// Country with ISO 3166 codes and city coverage count. Use iso2 to query cities within a specific country.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListCountriesResponseCountriesItem {
    /// Number of searchable places in this country, including small towns and administrative seats. Useful for showing coverage in a UI or sizing a dependent city dropdown.
    #[serde(rename = "cityCount")]
    pub city_count: f64,
    /// ISO 3166-1 alpha-2 country code. Use as the identifier when fetching cities for a specific country via the /countries/{iso2} endpoint.
    pub iso2: String,
    /// ISO 3166-1 alpha-3 country code. Three-letter standard used in international data exchange.
    pub iso3: String,
    /// Full country name in English. Use for display in location pickers and dropdown menus.
    pub name: String,
}
/// Response body of `listCards`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListCardsResponse {
    /// Array of tarot cards with basic metadata. Use GET /cards/{id} for full upright and reversed interpretations.
    pub cards: Vec<BasicCard>,
    /// Maximum items returned per page.
    pub limit: f64,
    /// Number of items skipped from the start of the result set.
    pub offset: f64,
    /// Total number of tarot cards matching the applied filters. 78 for the full deck, 22 for Major Arcana, 56 for Minor Arcana, 14 per suit.
    pub total: f64,
}
/// Path and query parameters of `listCards`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListCardsParams {
    /// Filter by arcana type. Major arcana (0-21) represents life lessons and spiritual themes. Minor arcana (Ace-King in 4 suits) represents daily situations and practical matters.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub arcana: Option<ListCardsParamsArcana>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListCardsParamsLang>,
    /// Maximum items to return per page. Range: 1-100, default 20.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Filter by card number. Major Arcana: 0 (The Fool) through 21 (The World). Minor Arcana: 1 (Ace) through 14 (King). Combine with arcana or suit filters for precise results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub number: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
    /// Filter minor arcana by suit. Cups=emotions/relationships, Wands=creativity/passion, Swords=intellect/conflict, Pentacles=material/finances. Only applies to minor arcana cards.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub suit: Option<ListCardsParamsSuit>,
}
string_enum! {
    /// Filter minor arcana by suit. Cups=emotions/relationships, Wands=creativity/passion, Swords=intellect/conflict, Pentacles=material/finances. Only applies to minor arcana cards.
    ListCardsParamsSuit {
        Cups = "cups",
        Wands = "wands",
        Swords = "swords",
        Pentacles = "pentacles",
    }
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListCardsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Filter by arcana type. Major arcana (0-21) represents life lessons and spiritual themes. Minor arcana (Ace-King in 4 suits) represents daily situations and practical matters.
    ListCardsParamsArcana {
        Major = "major",
        Minor = "minor",
    }
}
/// Response body of `listBaguaSectors`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListBaguaSectorsResponse {
    /// Page size applied.
    pub limit: f64,
    /// Number of entries skipped.
    pub offset: f64,
    /// The nine palaces of the compass Bagua map, in Lo Shu palace order starting at North and ending with the centre.
    pub sectors: Vec<ListBaguaSectorsResponseSectorsItem>,
    /// Number of palaces in the map.
    pub total: f64,
}
/// One entry of `sectors`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListBaguaSectorsResponseSectorsItem {
    /// Colours of the phase this sector carries, for activating it. Derived from the element rather than assigned per sector, so they cannot disagree with the element beside them.
    pub colors: Vec<String>,
    /// Compass sector of the palace, taken from the trigram that sits there. Absent on the centre palace, which has no direction.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub direction: Option<String>,
    /// The trigram that sits in this direction under the Earlier Heaven arrangement, read for the symbolic relation between opposite sectors. A different question from the Later Heaven trigram, not a competing answer. Absent on the centre palace.
    #[serde(rename = "earlierHeavenTrigram", skip_serializing_if = "Option::is_none")]
    pub earlier_heaven_trigram: Option<
        ListBaguaSectorsResponseSectorsItemEarlierHeavenTrigram,
    >,
    /// Five phase of this entry: Wood, Fire, Earth, Metal or Water. Always English so it stays safe to compare against and to key styling on. The full cycles live on the Chinese astrology elements endpoint.
    pub element: String,
    /// What this sector governs, in a few words.
    pub focus: String,
    /// Life area id: career, knowledge, family, wealth, fame, love, children, helpful-people or health. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees.
    pub id: String,
    /// What the sector governs and how to work with it.
    pub meaning: String,
    /// Display name of the life area. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Life area name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat name exactly. Never compare against this value.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Lo Shu number of the palace, 1 to 9. This is the same number the flying stars use, so a chart palace and a Bagua sector line up by it.
    pub number: f64,
    /// Palace of the Lo Shu grid: one of the eight compass sectors, or Center for the ninth. Always English, safe to compare against.
    pub palace: String,
    /// The Later Heaven trigram of the sector, which is the arrangement every compass reading and every flying star chart uses. Absent on the centre palace.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trigram: Option<ListBaguaSectorsResponseSectorsItemTrigram>,
}
/// The Later Heaven trigram of the sector, which is the arrangement every compass reading and every flying star chart uses. Absent on the centre palace.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListBaguaSectorsResponseSectorsItemTrigram {
    /// Three lines bottom to top, 1 for yang and 0 for yin. The Eight Mansions classification of any sector is decided by which of these three lines differ from your own trigram.
    pub binary: String,
    /// Chinese character for the trigram. Data, identical in every language.
    pub chinese: String,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against in code and against the same value on the I-Ching trigram endpoints.
    pub direction: String,
    /// Compass sector in the requested language, for display only, the same word the composed readings use. Present only when lang is set to a language other than English. Never compare against this value.
    #[serde(rename = "directionLocalized", skip_serializing_if = "Option::is_none")]
    pub direction_localized: Option<String>,
    /// Five phase of this entry: Wood, Fire, Earth, Metal or Water. Always English so it stays safe to compare against and to key styling on. The full cycles live on the Chinese astrology elements endpoint.
    pub element: String,
    /// Five phase name in the requested language, for display only. Present only when lang is set to a language other than English. Never compare against this value.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// English name of the trigram, byte identical to the English value the I-Ching trigram endpoints publish for this number. Always English here, whatever the lang parameter says, so it stays safe to compare against. Use nameLocalized for anything a reader sees.
    pub english: String,
    /// Family role of the trigram. Read alongside an affliction to know which member of the household a sector points at. Always English, and it carries no localized sibling: no vocabulary this package ships names the eight family roles.
    #[serde(rename = "familyMember")]
    pub family_member: String,
    /// Trigram name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat english exactly. Never compare against this value.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Trigram number, 1 to 8, the same identifier the I-Ching trigram endpoints use. It is a lookup key, not a ranking.
    pub number: f64,
    /// Tone-marked pinyin for the trigram. Data, identical in every language.
    pub pinyin: String,
    /// Unicode trigram symbol, for rendering a Bagua diagram without an icon set.
    pub symbol: String,
}
/// The trigram that sits in this direction under the Earlier Heaven arrangement, read for the symbolic relation between opposite sectors. A different question from the Later Heaven trigram, not a competing answer. Absent on the centre palace.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListBaguaSectorsResponseSectorsItemEarlierHeavenTrigram {
    /// Three lines bottom to top, 1 for yang and 0 for yin. The Eight Mansions classification of any sector is decided by which of these three lines differ from your own trigram.
    pub binary: String,
    /// Chinese character for the trigram. Data, identical in every language.
    pub chinese: String,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against in code and against the same value on the I-Ching trigram endpoints.
    pub direction: String,
    /// Compass sector in the requested language, for display only, the same word the composed readings use. Present only when lang is set to a language other than English. Never compare against this value.
    #[serde(rename = "directionLocalized", skip_serializing_if = "Option::is_none")]
    pub direction_localized: Option<String>,
    /// Five phase of this entry: Wood, Fire, Earth, Metal or Water. Always English so it stays safe to compare against and to key styling on. The full cycles live on the Chinese astrology elements endpoint.
    pub element: String,
    /// Five phase name in the requested language, for display only. Present only when lang is set to a language other than English. Never compare against this value.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// English name of the trigram, byte identical to the English value the I-Ching trigram endpoints publish for this number. Always English here, whatever the lang parameter says, so it stays safe to compare against. Use nameLocalized for anything a reader sees.
    pub english: String,
    /// Family role of the trigram. Read alongside an affliction to know which member of the household a sector points at. Always English, and it carries no localized sibling: no vocabulary this package ships names the eight family roles.
    #[serde(rename = "familyMember")]
    pub family_member: String,
    /// Trigram name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat english exactly. Never compare against this value.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Trigram number, 1 to 8, the same identifier the I-Ching trigram endpoints use. It is a lookup key, not a ranking.
    pub number: f64,
    /// Tone-marked pinyin for the trigram. Data, identical in every language.
    pub pinyin: String,
    /// Unicode trigram symbol, for rendering a Bagua diagram without an icon set.
    pub symbol: String,
}
/// Path and query parameters of `listBaguaSectors`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListBaguaSectorsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListBaguaSectorsParamsLang>,
    /// Maximum items to return per page. Range: 1-9, default 9.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListBaguaSectorsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listAztecTrecenas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListAztecTrecenasResponse {
    /// Maximum items returned for this page.
    pub limit: f64,
    /// Number of items skipped before this page.
    pub offset: f64,
    /// Total trecenas in the count. Always 20, because 260 divided by 13 is exactly 20.
    pub total: f64,
    /// Trecenas for the current page, in order from the one that opens on 1 Cipactli.
    pub trecenas: Vec<ListAztecTrecenasResponseTrecenasItem>,
}
/// One entry of `trecenas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListAztecTrecenasResponseTrecenasItem {
    /// Days in the period. Always 13, which is what the word trecena means.
    pub length: f64,
    /// Which of the twenty thirteen day periods this is, 1 to 20. Trecena 1 opens on 1 Cipactli and the openers step thirteen signs at a time from there.
    pub number: f64,
    /// The composed reading of the period, built from the sign it opens on rather than stored, so the two can never drift apart. No patron deity is named, because two of the twenty published patrons are disputed and none ships rather than eighteen shipping beside two guesses.
    pub reading: String,
    /// Machine identifier of the day sign the period opens on.
    #[serde(rename = "startSign")]
    pub start_sign: String,
    /// Display name of the sign the period opens on. A proper noun carried as data.
    #[serde(rename = "startSignName")]
    pub start_sign_name: String,
}
/// Path and query parameters of `listAztecTrecenas`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListAztecTrecenasParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListAztecTrecenasParamsLang>,
    /// Maximum items to return per page. Range: 1-20, default 20.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListAztecTrecenasParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listAztecDaySigns`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListAztecDaySignsResponse {
    /// Day signs for the current page, in sequence order.
    #[serde(rename = "daySigns")]
    pub day_signs: Vec<ListAztecDaySignsResponseDaySignsItem>,
    /// Maximum items returned for this page.
    pub limit: f64,
    /// Number of items skipped before this page.
    pub offset: f64,
    /// Total signs in the cycle. Always 20; the sign set is closed.
    pub total: f64,
}
/// One entry of `daySigns`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListAztecDaySignsResponseDaySignsItem {
    /// World direction the sign belongs to: east, north, west or south. The twenty run through the four quarters in strict rotation, so every fourth sign shares a quarter.
    pub direction: String,
    /// What the sign is about, as a clause rather than a sentence, because it is spliced into composed prose elsewhere in the API. Translated in place.
    pub essence: String,
    /// What the sign name means, translated in place because it is a common noun. Where several English renderings are in circulation all of them are given rather than one being picked.
    pub gloss: String,
    /// The one thing worth doing differently under this sign.
    pub guidance: String,
    /// Machine identifier of the day sign, always lowercase ASCII Nahuatl whatever the lang parameter says, so it stays safe to compare against and to use as a path parameter. The twenty ids run cipactli, ehecatl, calli, cuetzpalin, coatl, miquiztli, mazatl, tochtli, atl, itzcuintli, ozomahtli, malinalli, acatl, ocelotl, cuauhtli, cozcacuauhtli, ollin, tecpatl, quiahuitl, xochitl.
    pub id: String,
    /// The sign in one composed sentence, built from the components above.
    pub keynote: String,
    /// Display name in Nahuatl with the vowel length marks the reference tables print. A proper noun carried as data, identical under every lang.
    #[serde(rename = "nameNahuatl")]
    pub name_nahuatl: String,
    /// Place in the twenty sign sequence, 1 to 20, counting Cipactli as 1. The sequence never varies and is what the trecenas are indexed against.
    pub position: f64,
}
/// Path and query parameters of `listAztecDaySigns`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListAztecDaySignsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListAztecDaySignsParamsLang>,
    /// Maximum items to return per page. Range: 1-20, default 20.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListAztecDaySignsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listAvasthas`.
pub type ListAvasthasResponse = Vec<ListAvasthasResponseItem>;
/// One form of \[`ListAvasthasResponse`\].
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListAvasthasResponseItem {
    /// Unique slug for the avastha state. It is the lowercased form of the state name the birth chart returns, so a chart value maps straight onto this record.
    pub id: String,
    /// What the state means for the results the graha delivers, which is the whole purpose of reading an avastha: the chart says where a graha is, the avastha says how much of its promise it can keep.
    pub interpretation: String,
    /// Short label for the state, sized for a table cell beside the graha.
    pub meaning: String,
    /// Sanskrit name of the state, exactly as it appears in the `awastha`, `jagradadi` or `deeptadi` field of a birth chart.
    pub name: String,
    /// Which avastha system the state belongs to, and therefore which birth-chart field it appears in. "baladi" is the five-fold age state set by degree within the sign and appears in `awastha`. "jagradadi" is the three-fold waking state set by sign dignity. "deeptadi" is the nine-fold dispositional state. Baladi applies to every body; the other two apply to the seven classical grahas only.
    pub system: ListAvasthasResponseItemSystem,
}
string_enum! {
    /// Which avastha system the state belongs to, and therefore which birth-chart field it appears in. "baladi" is the five-fold age state set by degree within the sign and appears in `awastha`. "jagradadi" is the three-fold waking state set by sign dignity. "deeptadi" is the nine-fold dispositional state. Baladi applies to every body; the other two apply to the seven classical grahas only.
    ListAvasthasResponseItemSystem {
        Baladi = "baladi",
        Jagradadi = "jagradadi",
        Deeptadi = "deeptadi",
    }
}
/// Path and query parameters of `listAvasthas`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListAvasthasParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListAvasthasParamsLang>,
    /// Return only the states of one system: "baladi" (5), "jagradadi" (3) or "deeptadi" (9). Omit for all 17.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub system: Option<ListAvasthasParamsSystem>,
}
string_enum! {
    /// Return only the states of one system: "baladi" (5), "jagradadi" (3) or "deeptadi" (9). Omit for all 17.
    ListAvasthasParamsSystem {
        Baladi = "baladi",
        Jagradadi = "jagradadi",
        Deeptadi = "deeptadi",
    }
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListAvasthasParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `listAngelNumbers`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListAngelNumbersResponse {
    /// Maximum items returned per page.
    pub limit: f64,
    /// Array of angel number summaries for the current page.
    pub numbers: Vec<ListAngelNumbersResponseNumbersItem>,
    /// Number of items skipped from the start of the result set.
    pub offset: f64,
    /// Total number of angel numbers matching the applied filters. The full catalog size when unfiltered, fewer when filtered by type.
    pub total: f64,
}
/// One entry of `numbers`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListAngelNumbersResponseNumbersItem {
    /// One to two sentence summary of the divine message. Ideal for push notifications, daily guidance widgets, and quick reference lookups.
    #[serde(rename = "coreMessage")]
    pub core_message: String,
    /// Numerology digit root calculated by summing all digits and reducing to a single digit. Links each angel number to foundational numerology meaning. Master numbers 11, 22, 33 are preserved without further reduction.
    #[serde(rename = "digitRoot")]
    pub digit_root: f64,
    /// Overall energy classification. "positive" indicates encouraging, uplifting energy. "neutral" indicates transitional energy (neither purely positive nor cautionary). "cautionary" indicates a gentle warning to rebalance or pay attention.
    pub energy: String,
    /// Five to eight keywords capturing the spiritual themes and energy of this angel number. Useful for search, filtering, and content generation.
    pub keywords: Vec<String>,
    /// Angel number sequence as a string. Common patterns include triple repeating (111-999), quad repeating (1111-9999), master numbers (11, 22, 33), mirror patterns (1212), and sequential numbers (1234).
    pub number: String,
    /// Short descriptive title capturing the core theme and spiritual significance of this angel number.
    pub title: String,
    /// Pattern classification of the angel number. "repeating" means all digits are the same (111, 4444). "sequential" means consecutive digits (1234). "mirror" means palindrome or alternating pattern (1212, 1221). "master" means numerology master number (11, 22, 33). "root" means single digit (0-9). "compound" means a mixed sequence with no pure pattern (911, 1122).
    pub r#type: String,
}
/// Path and query parameters of `listAngelNumbers`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListAngelNumbersParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ListAngelNumbersParamsLang>,
    /// Maximum items to return per page. Range: 1-50, default 20.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
    /// Filter results by angel number pattern type. "repeating" returns numbers like 111, 444, 7777. "sequential" returns patterns like 1234. "mirror" returns palindrome or alternating patterns like 1212, 717. "master" returns 11, 22, 33. "root" returns single digits 0-9. "compound" returns mixed sequences with no pure pattern like 911, 1122.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<ListAngelNumbersParamsType>,
}
string_enum! {
    /// Filter results by angel number pattern type. "repeating" returns numbers like 111, 444, 7777. "sequential" returns patterns like 1234. "mirror" returns palindrome or alternating patterns like 1212, 717. "master" returns 11, 22, 33. "root" returns single digits 0-9. "compound" returns mixed sequences with no pure pattern like 911, 1122.
    ListAngelNumbersParamsType {
        Repeating = "repeating",
        Sequential = "sequential",
        Mirror = "mirror",
        Master = "master",
        Root = "root",
        Compound = "compound",
    }
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ListAngelNumbersParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `generateLilith`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct LilithResponse {
    /// Echo of the birth moment and place used to compute both Lilith variants.
    #[serde(rename = "birthDetails")]
    pub birth_details: LilithResponseBirthDetails,
    /// House system applied when placing each variant in a house.
    #[serde(rename = "houseSystem")]
    pub house_system: LilithResponseHouseSystem,
    /// Both Black Moon Lilith variants, the mean lunar apogee first and the true (osculating) apogee second.
    pub lilith: Vec<LilithResponseLilithItem>,
    /// Short overview of both variants for previews and report intros.
    pub summary: String,
}
/// One entry of `lilith`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct LilithResponseLilithItem {
    /// Degree of the apogee within its zodiac sign (0 to 29.999).
    pub degree: f64,
    /// House placement (1 to 12) in the selected house system, the area of life where the Lilith theme plays out.
    pub house: i64,
    /// Plain language meaning of this Lilith variant in its sign, suitable for chart reports and AI agents. Localized to the requested language.
    pub interpretation: String,
    /// Whether the apogee is moving backward. Always false for the mean apogee; the true apogee turns retrograde when the osculating ellipse swings the apogee direction backward.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Ecliptic latitude in degrees, the projection of the apogee off the ecliptic plane. Reaches up to about 5 degrees because the lunar orbit is inclined.
    pub latitude: f64,
    /// Absolute tropical ecliptic longitude of the apogee in degrees (0 to 360).
    pub longitude: f64,
    /// Short explanation of how this variant is defined and how it differs from the other, localized to the requested language.
    pub note: String,
    /// Tropical zodiac sign the apogee falls in, naming where the suppressed instinct lives.
    pub sign: String,
    /// Daily motion in degrees per day. The mean apogee is always positive (direct); the true apogee can be negative (retrograde).
    pub speed: f64,
    /// Which lunar apogee this entry describes. The mean variant is the smoothed average apogee; the true variant is the instantaneous osculating apogee. Always one of these two English literals, whatever the lang parameter says, so it stays safe to compare against in code. Use variantLocalized for anything a reader sees.
    pub variant: LilithResponseLilithItemVariant,
    /// Apogee variant label in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "variantLocalized", skip_serializing_if = "Option::is_none")]
    pub variant_localized: Option<String>,
}
string_enum! {
    /// Which lunar apogee this entry describes. The mean variant is the smoothed average apogee; the true variant is the instantaneous osculating apogee. Always one of these two English literals, whatever the lang parameter says, so it stays safe to compare against in code. Use variantLocalized for anything a reader sees.
    LilithResponseLilithItemVariant {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// House system applied when placing each variant in a house.
    LilithResponseHouseSystem {
        Placidus = "placidus",
        WholeSign = "whole-sign",
        Equal = "equal",
        Koch = "koch",
    }
}
/// Echo of the birth moment and place used to compute both Lilith variants.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct LilithResponseBirthDetails {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone offset from UTC in decimal hours, resolved for the birth date. Examples: New York = -5 in winter and -4 in summer, London = 0, India = 5.5, Tokyo = 9.
    pub timezone: f64,
}
/// Request body of `generateLilith`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct LilithRequest {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// House system used to place each Lilith variant in a house. Placidus (default), Whole Sign, Equal, or Koch.
    #[serde(rename = "houseSystem", skip_serializing_if = "Option::is_none")]
    pub house_system: Option<LilithRequestHouseSystem>,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<LilithRequestNodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
    pub timezone: LilithRequestTimezone,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum LilithRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    LilithRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// House system used to place each Lilith variant in a house. Placidus (default), Whole Sign, Equal, or Koch.
    LilithRequestHouseSystem {
        Placidus = "placidus",
        WholeSign = "whole-sign",
        Equal = "equal",
        Koch = "koch",
    }
}
/// Response body of `checkKalsarpaDosha`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KalsarpaResponse {
    /// Human-readable Kalsarpa dosha analysis with Rahu-Ketu axis details
    pub description: String,
    /// Kalsarpa dosha effects on career, health, mindset, and relationships
    #[serde(skip_serializing_if = "Option::is_none")]
    pub effects: Option<KalsarpaResponseEffects>,
    /// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
    pub frame: KalsarpaResponseFrame,
    /// Whether Kalsarpa dosha (Kalsarpa yoga) is present, all planets hemmed between Rahu-Ketu axis
    pub present: bool,
    /// Traditional Vedic remedies for Kalsarpa dosha including puja, mantras, and spiritual practices
    #[serde(skip_serializing_if = "Option::is_none")]
    pub remedies: Option<Vec<String>>,
    /// Kalsarpa dosha intensity based on Rahu-Ketu house positions
    #[serde(skip_serializing_if = "Option::is_none")]
    pub severity: Option<KalsarpaResponseSeverity>,
    /// One of 12 Kalsarpa types based on Rahu house position (Ananta, Kulik, Vasuki, Shankhapala, Padma, Mahapadma, Takshak, Karkotak, Shankhachud, Ghatak, Vishdhar, Sheshnag)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}
string_enum! {
    /// Kalsarpa dosha intensity based on Rahu-Ketu house positions
    KalsarpaResponseSeverity {
        Mild = "Mild",
        Moderate = "Moderate",
        Severe = "Severe",
    }
}
/// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KalsarpaResponseFrame {
    /// Sidereal frame this chart was cast in, echoing the ayanamsa request field. "lahiri" when the field was omitted.
    pub ayanamsa: String,
    /// Degrees actually subtracted from every tropical longitude to produce this chart, read at the birth instant. Subtract it back to recover the tropical positions, or compare it against your reference software to confirm you are in the same frame before chasing a placement difference.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
}
/// Kalsarpa dosha effects on career, health, mindset, and relationships
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KalsarpaResponseEffects {
    /// Impact on professional growth and career progress
    pub career: String,
    /// When Kalsarpa effects are most active in Vimshottari dasha
    pub duration: String,
    /// Physical and mental health implications
    pub health: String,
    /// Psychological and emotional effects
    pub mindset: String,
    /// Potential spiritual and personal growth benefits
    pub positive: String,
    /// Impact on family bonds and personal relationships
    pub relationships: String,
}
/// Request body of `checkKalsarpaDosha`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KalsarpaRequest {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<KalsarpaRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<KalsarpaRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum KalsarpaRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    KalsarpaRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Response body of `getKpSublordChanges`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPSublordChangesResponse {
    /// Chronological list of KP sublord boundary crossings. Each entry marks when the tracked graha moves from one Krishnamurti subdivision to the next in the 249-part zodiac.
    pub changes: Vec<KPSublordChangesResponseChangesItem>,
    /// End of the sublord change search range (YYYY-MM-DD).
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Vedic graha tracked for KP sublord transitions across the 249-division zodiac.
    pub planet: String,
    /// Beginning of the sublord change search range (YYYY-MM-DD).
    #[serde(rename = "startDate")]
    pub start_date: String,
    /// Total Krishnamurti sublord transitions detected. The Moon, the fastest body, crosses about 9 sublords a day.
    #[serde(rename = "totalChanges")]
    pub total_changes: f64,
}
/// One entry of `changes`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPSublordChangesResponseChangesItem {
    /// Date of the sublord boundary crossing (YYYY-MM-DD). Adjusted to requested timezone.
    pub date: String,
    /// Full datetime of the KP sublord change. Adjusted to requested timezone for prashna kundali timing.
    pub datetime: String,
    /// Previous KP number (1-249) in the Vimshottari-based zodiac subdivision the planet occupied.
    #[serde(rename = "fromKp")]
    pub from_kp: f64,
    /// Nakshatra lord (star lord) before transition. Follows the Vimshottari dasha sequence of 9 planets.
    #[serde(rename = "fromNakshatraLord")]
    pub from_nakshatra_lord: String,
    /// KP sublord planet before transition. The sublord determines whether an event signified by the star lord will manifest.
    #[serde(rename = "fromSublord")]
    pub from_sublord: String,
    /// Sublord transition time (HH:MM, 24-hour): the instant is found to the second and shown rounded to the nearest minute. Adjusted to requested timezone.
    pub time: String,
    /// New KP number (1-249) the planet enters. Each number maps to a unique star lord and sublord combination.
    #[serde(rename = "toKp")]
    pub to_kp: f64,
    /// Nakshatra lord after transition. Changes only when the planet crosses a nakshatra boundary (every 13d20m).
    #[serde(rename = "toNakshatraLord")]
    pub to_nakshatra_lord: String,
    /// New KP sublord planet after transition. A change in sublord shifts the houses signified by the tracked planet.
    #[serde(rename = "toSublord")]
    pub to_sublord: String,
}
/// Request body of `getKpSublordChanges`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPSublordChangesRequest {
    /// Ayanamsa system for sidereal conversion. "kp-newcomb" uses the KP-Newcomb dynamic formula, the most common choice for KP astrology. "kp-old" uses the Krishnamurti original table from KP Reader-1 with constant precession rate. "lahiri" uses Lahiri/Chitrapaksha ayanamsa, matching most traditional Vedic software. "raman" uses the B.V. Raman ayanamsa from Hindu Predictive Astrology, a recognised traditional school that sits about 1.45 degrees below Lahiri. Defaults to "kp-newcomb".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<KPSublordChangesRequestAyanamsa>,
    /// Last day of the search, inclusive (YYYY-MM-DD), a calendar day in `timezone`. Not before startDate, at most 365 days after it.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the Rahu and Ketu positions. Mean is the traditional Vedic default and what printed panchangs use; the choice can move a KP sub-lord in narrow boundary cases, where a span can be as small as 0.5 degrees. Defaults to "mean".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<KPSublordChangesRequestNodeType>,
    /// Planet to track (case-insensitive). Valid values: Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn
    pub planet: KPSublordChangesRequestPlanet,
    /// First day of the search (YYYY-MM-DD), a calendar day in `timezone`.
    #[serde(rename = "startDate")]
    pub start_date: String,
    /// IANA name (e.g. "America/New_York", "Europe/London"), a fixed offset like "+05:30", OR decimal hours from UTC. One offset is taken from startDate (DST-correct for that date) and used for the whole range, so a window crossing a daylight-saving change is read on the earlier offset throughout; send a fixed offset if you need that explicit. The two dates are read as calendar days in this timezone and output times are converted to it, so one date with 5.5 is that whole Indian day. Defaults to 0 (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<KPSublordChangesRequestTimezone>,
}
/// IANA name (e.g. "America/New_York", "Europe/London"), a fixed offset like "+05:30", OR decimal hours from UTC. One offset is taken from startDate (DST-correct for that date) and used for the whole range, so a window crossing a daylight-saving change is read on the earlier offset throughout; send a fixed offset if you need that explicit. The two dates are read as calendar days in this timezone and output times are converted to it, so one date with 5.5 is that whole Indian day. Defaults to 0 (UTC).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum KPSublordChangesRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Planet to track (case-insensitive). Valid values: Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn
    KPSublordChangesRequestPlanet {
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Mercury = "Mercury",
        Jupiter = "Jupiter",
        Venus = "Venus",
        Saturn = "Saturn",
    }
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the Rahu and Ketu positions. Mean is the traditional Vedic default and what printed panchangs use; the choice can move a KP sub-lord in narrow boundary cases, where a span can be as small as 0.5 degrees. Defaults to "mean".
    KPSublordChangesRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// Ayanamsa system for sidereal conversion. "kp-newcomb" uses the KP-Newcomb dynamic formula, the most common choice for KP astrology. "kp-old" uses the Krishnamurti original table from KP Reader-1 with constant precession rate. "lahiri" uses Lahiri/Chitrapaksha ayanamsa, matching most traditional Vedic software. "raman" uses the B.V. Raman ayanamsa from Hindu Predictive Astrology, a recognised traditional school that sits about 1.45 degrees below Lahiri. Defaults to "kp-newcomb".
    KPSublordChangesRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
    }
}
/// Response body of `getKpRulingPlanets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPRulingPlanetsResponse {
    /// Calculation datetime (ISO 8601)
    pub datetime: String,
    /// Lord of the weekday (Sun=Sunday through Saturn=Saturday)
    #[serde(rename = "dayLord")]
    pub day_lord: String,
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<KPRulingPlanetsResponseFocus>,
    /// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
    #[serde(rename = "houseThemes", skip_serializing_if = "Option::is_none")]
    pub house_themes: Option<KPRulingPlanetsResponseHouseThemes>,
    /// Lord of the rising zodiac sign (Ascendant)
    #[serde(rename = "lagnaSignLord")]
    pub lagna_sign_lord: String,
    /// Lord of the nakshatra where Ascendant falls
    #[serde(rename = "lagnaStarLord")]
    pub lagna_star_lord: String,
    /// Sub-sub lord (SSL) of the KP division where Ascendant falls
    #[serde(rename = "lagnaSubSublord")]
    pub lagna_sub_sublord: String,
    /// Sub-lord of the KP division where Ascendant falls
    #[serde(rename = "lagnaSublord")]
    pub lagna_sublord: String,
    /// Observer location coordinates
    pub location: KPRulingPlanetsResponseLocation,
    /// Lord of the zodiac sign where Moon is placed
    #[serde(rename = "moonSignLord")]
    pub moon_sign_lord: String,
    /// Lord of the nakshatra where Moon is placed
    #[serde(rename = "moonStarLord")]
    pub moon_star_lord: String,
    /// Sub-sub lord (SSL) of the KP division where Moon is placed
    #[serde(rename = "moonSubSublord")]
    pub moon_sub_sublord: String,
    /// Sub-lord of the KP division where Moon is placed
    #[serde(rename = "moonSublord")]
    pub moon_sublord: String,
    /// Unique ruling planets in order of strength. Strongest planet appears first.
    #[serde(rename = "rulingPlanets")]
    pub ruling_planets: Vec<String>,
    /// Houses signified by each ruling planet (only when birthDate and birthTime provided). Based on 4-level KP significator hierarchy from birth chart.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub significators: Option<Vec<KPRulingPlanetsResponseSignificatorsItem>>,
}
/// One entry of `significators`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPRulingPlanetsResponseSignificatorsItem {
    /// Planet abbreviation.
    pub planet: String,
    /// Houses this planet signifies, ordered by KP 4-level strength: L1 (planet in star of occupant, strongest), L2 (planet occupies), L3 (planet in star of owner), L4 (planet owns). First element is the strongest signification, not the occupied house.
    pub signifies: Vec<f64>,
}
/// Observer location coordinates
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPRulingPlanetsResponseLocation {
    /// Observer latitude in decimal degrees, echoed back from the request. Sets the local sidereal time behind the KP ascendant and therefore the Lagna sublord.
    pub latitude: f64,
    /// Observer longitude in decimal degrees, echoed back from the request. East is positive, west is negative.
    pub longitude: f64,
    /// Numeric UTC offset in decimal hours the calculation consumed. An IANA name sent on the request is resolved to its DST-correct offset upstream, so this is always a number.
    pub timezone: f64,
}
/// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPRulingPlanetsResponseHouseThemes {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, Vec<String>>,
}
string_enum! {
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    KPRulingPlanetsResponseFocus {
        General = "general",
        Finance = "finance",
    }
}
/// Response body of `getKpRulingInterval`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPRulingPlanetsIntervalResponse {
    /// End of the KP ruling planets interval range (ISO 8601).
    #[serde(rename = "endDatetime")]
    pub end_datetime: String,
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    pub focus: KPRulingPlanetsIntervalResponseFocus,
    /// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
    #[serde(rename = "houseThemes")]
    pub house_themes: KPRulingPlanetsIntervalResponseHouseThemes,
    /// Time gap between consecutive ruling planet calculations in minutes.
    #[serde(rename = "intervalMinutes")]
    pub interval_minutes: f64,
    /// Ruling planets with significators at each interval
    pub intervals: Vec<KPRulingPlanetsIntervalResponseIntervalsItem>,
    /// Observer location coordinates used for erecting the Placidus prashna chart at each interval.
    pub location: KPRulingPlanetsIntervalResponseLocation,
    /// Start of the KP ruling planets interval range (ISO 8601).
    #[serde(rename = "startDatetime")]
    pub start_datetime: String,
    /// Total number of intervals returned
    #[serde(rename = "totalIntervals")]
    pub total_intervals: f64,
}
/// Observer location coordinates used for erecting the Placidus prashna chart at each interval.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPRulingPlanetsIntervalResponseLocation {
    /// Observer latitude used for Placidus house and Lagna (Ascendant) calculation.
    pub latitude: f64,
    /// Observer longitude used for local sidereal time and Ascendant degree.
    pub longitude: f64,
    /// Timezone offset applied to output times and sunrise-based Day Lord calculation.
    pub timezone: f64,
}
/// One entry of `intervals`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPRulingPlanetsIntervalResponseIntervalsItem {
    /// UTC date for this interval (YYYY-MM-DD).
    pub date: String,
    /// Full ISO 8601 timestamp for this interval.
    pub datetime: String,
    /// Ruling planet of the weekday based on Hindu sunrise Vara. Changes at local sunrise, not midnight.
    #[serde(rename = "dayLord")]
    pub day_lord: String,
    /// Lord of the Ascendant (Lagna) zodiac sign. Changes roughly every 2 hours as houses rotate.
    #[serde(rename = "lagnaSignLord")]
    pub lagna_sign_lord: String,
    /// Lord of the nakshatra where the Ascendant degree falls.
    #[serde(rename = "lagnaStarLord")]
    pub lagna_star_lord: String,
    /// KP sub-sublord of the Ascendant. Most granular level for pinpointing exact moments.
    #[serde(rename = "lagnaSubSublord")]
    pub lagna_sub_sublord: String,
    /// KP sublord of the Ascendant degree. Changes every few minutes. key for birth time rectification.
    #[serde(rename = "lagnaSublord")]
    pub lagna_sublord: String,
    /// Lord of the zodiac sign (rashi) where Moon is placed at this moment.
    #[serde(rename = "moonSignLord")]
    pub moon_sign_lord: String,
    /// KP 4-level significator breakdown for the Moon Sign Lord planet. Shows which houses the Moon rashi lord activates at this moment, broken down by strength tier.
    #[serde(rename = "moonSignLordSignifies")]
    pub moon_sign_lord_signifies: KPRulingPlanetsIntervalResponseIntervalsItemMoonSignLordSignifies,
    /// KP 4-level significator breakdown for Moon itself. Shows which bhavas Moon directly activates based on its position and star lord in the current moment chart.
    #[serde(rename = "moonSignifies")]
    pub moon_signifies: KPRulingPlanetsIntervalResponseIntervalsItemMoonSignifies,
    /// Lord of the nakshatra (star, 1 of 27) where Moon is placed. Follows Vimshottari dasha sequence.
    #[serde(rename = "moonStarLord")]
    pub moon_star_lord: String,
    /// KP 4-level significator breakdown for the Moon Star Lord (nakshatra lord) planet. The star lord determines the nature of results Moon delivers.
    #[serde(rename = "moonStarLordSignifies")]
    pub moon_star_lord_signifies: KPRulingPlanetsIntervalResponseIntervalsItemMoonStarLordSignifies,
    /// KP sub-sublord (SSL) of Moons position. Finest subdivision for precise timing.
    #[serde(rename = "moonSubSublord")]
    pub moon_sub_sublord: String,
    /// KP sublord of Moons exact position within the nakshatra subdivision (1 of 249).
    #[serde(rename = "moonSublord")]
    pub moon_sublord: String,
    /// KP 4-level significator breakdown for the Moon Sub Lord planet. The sub lord determines whether Moon-related events will manifest.
    #[serde(rename = "moonSublordSignifies")]
    pub moon_sublord_signifies: KPRulingPlanetsIntervalResponseIntervalsItemMoonSublordSignifies,
    /// Unique set of ruling planets derived from Day Lord, Moon Sign/Star Lords, and Lagna Sign/Star Lords. In KP astrology, events manifest when dasha/transit planets match these ruling planets.
    #[serde(rename = "rulingPlanets")]
    pub ruling_planets: Vec<String>,
    /// KP significators for each ruling planet calculated from this moments Placidus chart. Shows which houses (1-12) each ruling planet signifies right now. Significators change as the Ascendant rotates through signs.
    pub significators: Vec<
        KPRulingPlanetsIntervalResponseIntervalsItemSignificatorsItem,
    >,
    /// UTC time for this interval (HH:MM, 24-hour).
    pub time: String,
}
/// One entry of `significators`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPRulingPlanetsIntervalResponseIntervalsItemSignificatorsItem {
    /// Ruling planet name.
    pub planet: String,
    /// Unique house numbers this planet signifies, ordered by strength. Uses 4-level KP hierarchy: Level 1 (strongest) planets in star of occupant, Level 2 occupants, Level 3 planets in star of owner, Level 4 owner.
    pub signifies: Vec<f64>,
}
/// KP 4-level significator breakdown for the Moon Sub Lord planet. The sub lord determines whether Moon-related events will manifest.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPRulingPlanetsIntervalResponseIntervalsItemMoonSublordSignifies {
    /// Level 1, the strongest signification (grade A). Houses influenced because this planet sits in the nakshatra (star) of a planet occupying those houses. For Rahu and Ketu, also includes the L1 houses of their agent planets (conjoined, aspecting, sign lord).
    #[serde(rename = "L1")]
    pub l1: Vec<i64>,
    /// Level 2 (grade B). The house this planet physically occupies. For Rahu and Ketu, also includes houses occupied by their agent planets.
    #[serde(rename = "L2")]
    pub l2: Vec<i64>,
    /// Level 3 (grade C). Houses influenced because this planet sits in the nakshatra of the sign lord (owner) of those houses. For Rahu and Ketu, also includes the L3 houses of their agent planets.
    #[serde(rename = "L3")]
    pub l3: Vec<i64>,
    /// Level 4, the weakest signification (grade D). Houses this planet rules by zodiac sign ownership, up to 2 for Sun through Saturn and 3 where a sign is intercepted. Rahu and Ketu own no sign, so their L4 comes entirely from their agent planets.
    #[serde(rename = "L4")]
    pub l4: Vec<i64>,
}
/// KP 4-level significator breakdown for the Moon Star Lord (nakshatra lord) planet. The star lord determines the nature of results Moon delivers.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPRulingPlanetsIntervalResponseIntervalsItemMoonStarLordSignifies {
    /// Level 1, the strongest signification (grade A). Houses influenced because this planet sits in the nakshatra (star) of a planet occupying those houses. For Rahu and Ketu, also includes the L1 houses of their agent planets (conjoined, aspecting, sign lord).
    #[serde(rename = "L1")]
    pub l1: Vec<i64>,
    /// Level 2 (grade B). The house this planet physically occupies. For Rahu and Ketu, also includes houses occupied by their agent planets.
    #[serde(rename = "L2")]
    pub l2: Vec<i64>,
    /// Level 3 (grade C). Houses influenced because this planet sits in the nakshatra of the sign lord (owner) of those houses. For Rahu and Ketu, also includes the L3 houses of their agent planets.
    #[serde(rename = "L3")]
    pub l3: Vec<i64>,
    /// Level 4, the weakest signification (grade D). Houses this planet rules by zodiac sign ownership, up to 2 for Sun through Saturn and 3 where a sign is intercepted. Rahu and Ketu own no sign, so their L4 comes entirely from their agent planets.
    #[serde(rename = "L4")]
    pub l4: Vec<i64>,
}
/// KP 4-level significator breakdown for Moon itself. Shows which bhavas Moon directly activates based on its position and star lord in the current moment chart.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPRulingPlanetsIntervalResponseIntervalsItemMoonSignifies {
    /// Level 1, the strongest signification (grade A). Houses influenced because this planet sits in the nakshatra (star) of a planet occupying those houses. For Rahu and Ketu, also includes the L1 houses of their agent planets (conjoined, aspecting, sign lord).
    #[serde(rename = "L1")]
    pub l1: Vec<i64>,
    /// Level 2 (grade B). The house this planet physically occupies. For Rahu and Ketu, also includes houses occupied by their agent planets.
    #[serde(rename = "L2")]
    pub l2: Vec<i64>,
    /// Level 3 (grade C). Houses influenced because this planet sits in the nakshatra of the sign lord (owner) of those houses. For Rahu and Ketu, also includes the L3 houses of their agent planets.
    #[serde(rename = "L3")]
    pub l3: Vec<i64>,
    /// Level 4, the weakest signification (grade D). Houses this planet rules by zodiac sign ownership, up to 2 for Sun through Saturn and 3 where a sign is intercepted. Rahu and Ketu own no sign, so their L4 comes entirely from their agent planets.
    #[serde(rename = "L4")]
    pub l4: Vec<i64>,
}
/// KP 4-level significator breakdown for the Moon Sign Lord planet. Shows which houses the Moon rashi lord activates at this moment, broken down by strength tier.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPRulingPlanetsIntervalResponseIntervalsItemMoonSignLordSignifies {
    /// Level 1, the strongest signification (grade A). Houses influenced because this planet sits in the nakshatra (star) of a planet occupying those houses. For Rahu and Ketu, also includes the L1 houses of their agent planets (conjoined, aspecting, sign lord).
    #[serde(rename = "L1")]
    pub l1: Vec<i64>,
    /// Level 2 (grade B). The house this planet physically occupies. For Rahu and Ketu, also includes houses occupied by their agent planets.
    #[serde(rename = "L2")]
    pub l2: Vec<i64>,
    /// Level 3 (grade C). Houses influenced because this planet sits in the nakshatra of the sign lord (owner) of those houses. For Rahu and Ketu, also includes the L3 houses of their agent planets.
    #[serde(rename = "L3")]
    pub l3: Vec<i64>,
    /// Level 4, the weakest signification (grade D). Houses this planet rules by zodiac sign ownership, up to 2 for Sun through Saturn and 3 where a sign is intercepted. Rahu and Ketu own no sign, so their L4 comes entirely from their agent planets.
    #[serde(rename = "L4")]
    pub l4: Vec<i64>,
}
/// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPRulingPlanetsIntervalResponseHouseThemes {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, Vec<String>>,
}
string_enum! {
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    KPRulingPlanetsIntervalResponseFocus {
        General = "general",
        Finance = "finance",
    }
}
/// Response body of `getKpRasiChanges`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPRasiChangesResponse {
    /// Chronological list of rasi parivartan (zodiac sign change) events with precise ingress timestamps. Each entry marks when the tracked graha crosses a 30-degree sign boundary.
    pub changes: Vec<KPRasiChangesResponseChangesItem>,
    /// End of the rasi change search range (YYYY-MM-DD).
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Vedic graha being tracked for rasi parivartan (sign ingress) events.
    pub planet: String,
    /// Beginning of the rasi change search range (YYYY-MM-DD).
    #[serde(rename = "startDate")]
    pub start_date: String,
    /// Total rasi parivartan events detected in the date range. Moon averages 12-13 per month, Sun once per month.
    #[serde(rename = "totalChanges")]
    pub total_changes: f64,
}
/// One entry of `changes`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPRasiChangesResponseChangesItem {
    /// Date of the rasi ingress event (YYYY-MM-DD). Adjusted to requested timezone for local panchang use.
    pub date: String,
    /// Full rasi parivartan datetime. Adjusted to requested timezone for transit calendar integration.
    pub datetime: String,
    /// Zodiac sign (rashi) the planet is leaving. One of 12 sidereal signs using KP ayanamsa.
    #[serde(rename = "fromSign")]
    pub from_sign: String,
    /// Rashi lord (planetary ruler) of the departing sign. Determines the Vimshottari dasha connection.
    #[serde(rename = "fromSignLord")]
    pub from_sign_lord: String,
    /// Ingress time (HH:MM, 24-hour): the instant is found to the second and shown rounded to the nearest minute. Adjusted to requested timezone.
    pub time: String,
    /// New zodiac sign entered by the planet. Marks the beginning of a new transit phase in Vedic gochar analysis.
    #[serde(rename = "toSign")]
    pub to_sign: String,
    /// Rashi lord of the newly entered sign. Key for KP significator analysis and dasha-transit matching.
    #[serde(rename = "toSignLord")]
    pub to_sign_lord: String,
}
/// Request body of `getKpRasiChanges`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPRasiChangesRequest {
    /// Ayanamsa system for sidereal conversion. "kp-newcomb" uses the KP-Newcomb dynamic formula, the most common choice for KP astrology. "kp-old" uses the Krishnamurti original table from KP Reader-1 with constant precession rate. "lahiri" uses Lahiri/Chitrapaksha ayanamsa, matching most traditional Vedic software. "raman" uses the B.V. Raman ayanamsa from Hindu Predictive Astrology, a recognised traditional school that sits about 1.45 degrees below Lahiri. Defaults to "kp-newcomb".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<KPRasiChangesRequestAyanamsa>,
    /// Last day of the search, inclusive (YYYY-MM-DD), a calendar day in `timezone`. Not before startDate, at most 365 days after it.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the Rahu and Ketu positions. Mean is the traditional Vedic default and what printed panchangs use; the choice can move a KP sub-lord in narrow boundary cases, where a span can be as small as 0.5 degrees. Defaults to "mean".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<KPRasiChangesRequestNodeType>,
    /// Planet to track (case-insensitive). Valid values: Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn
    pub planet: KPRasiChangesRequestPlanet,
    /// First day of the search (YYYY-MM-DD), a calendar day in `timezone`.
    #[serde(rename = "startDate")]
    pub start_date: String,
    /// IANA name (e.g. "America/New_York", "Europe/London"), a fixed offset like "+05:30", OR decimal hours from UTC. One offset is taken from startDate (DST-correct for that date) and used for the whole range, so a window crossing a daylight-saving change is read on the earlier offset throughout; send a fixed offset if you need that explicit. The two dates are read as calendar days in this timezone and output times are converted to it, so one date with 5.5 is that whole Indian day. Defaults to 0 (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<KPRasiChangesRequestTimezone>,
}
/// IANA name (e.g. "America/New_York", "Europe/London"), a fixed offset like "+05:30", OR decimal hours from UTC. One offset is taken from startDate (DST-correct for that date) and used for the whole range, so a window crossing a daylight-saving change is read on the earlier offset throughout; send a fixed offset if you need that explicit. The two dates are read as calendar days in this timezone and output times are converted to it, so one date with 5.5 is that whole Indian day. Defaults to 0 (UTC).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum KPRasiChangesRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Planet to track (case-insensitive). Valid values: Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn
    KPRasiChangesRequestPlanet {
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Mercury = "Mercury",
        Jupiter = "Jupiter",
        Venus = "Venus",
        Saturn = "Saturn",
    }
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the Rahu and Ketu positions. Mean is the traditional Vedic default and what printed panchangs use; the choice can move a KP sub-lord in narrow boundary cases, where a span can be as small as 0.5 degrees. Defaults to "mean".
    KPRasiChangesRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// Ayanamsa system for sidereal conversion. "kp-newcomb" uses the KP-Newcomb dynamic formula, the most common choice for KP astrology. "kp-old" uses the Krishnamurti original table from KP Reader-1 with constant precession rate. "lahiri" uses Lahiri/Chitrapaksha ayanamsa, matching most traditional Vedic software. "raman" uses the B.V. Raman ayanamsa from Hindu Predictive Astrology, a recognised traditional school that sits about 1.45 degrees below Lahiri. Defaults to "kp-newcomb".
    KPRasiChangesRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
    }
}
/// Response body of `getKpPlanets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPPlanetsResponse {
    /// Applied ayanamsa value in degrees
    pub ayanamsa: f64,
    /// The `planets` field.
    pub planets: Vec<KPPlanetsResponsePlanetsItem>,
}
/// One entry of `planets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPPlanetsResponsePlanetsItem {
    /// KP horary number (1-249)
    #[serde(rename = "kpNumber")]
    pub kp_number: f64,
    /// KP sidereal longitude in degrees (0-360). Used to determine Placidus house placement and KP subdivision (sign, star, sub).
    pub longitude: f64,
    /// Nakshatra (lunar mansion) this planet occupies. One of 27 nakshatras, each spanning 13 degrees 20 minutes.
    pub nakshatra: String,
    /// Nakshatra lord (star ruler) from the Vimshottari dasha sequence. Determines the nature of results this planet delivers in KP.
    #[serde(rename = "nakshatraLord")]
    pub nakshatra_lord: String,
    /// Nakshatra sequence number (1-27). Ashwini=1 through Revati=27.
    #[serde(rename = "nakshatraNumber")]
    pub nakshatra_number: f64,
    /// Nakshatra pada/quarter (1-4)
    pub pada: f64,
    /// Vedic graha name (Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn, Rahu, Ketu).
    pub planet: String,
    /// Whether planet is in retrograde motion
    pub retrograde: bool,
    /// Zodiac sign (rashi) this planet occupies in the sidereal zodiac.
    pub sign: String,
    /// Rashi lord (sign ruler). First level of the KP significator hierarchy. Its house ownership determines L4 significations.
    #[serde(rename = "signLord")]
    pub sign_lord: String,
    /// Star-lord (same as nakshatra lord in KP system)
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// Sub-lord based on 249-level KP subdivision
    #[serde(rename = "subLord")]
    pub sub_lord: String,
    /// Sub-sub lord (SSL) based on 2241-level KP subdivision. Third level of Vimshottari dasha proportions.
    #[serde(rename = "subSubLord")]
    pub sub_sub_lord: String,
}
/// Request body of `getKpPlanets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPPlanetsRequest {
    /// Ayanamsa system for sidereal conversion. "kp-newcomb" uses the KP-Newcomb dynamic formula (most common for KP). "kp-old" uses the Krishnamurti original table. "lahiri" uses Lahiri/Chitrapaksha ayanamsa matching most traditional Vedic software. "raman" uses the B.V. Raman ayanamsa, about 1.45 degrees below Lahiri. "custom" allows providing your own value via ayanamsaValue. Defaults to "kp-newcomb".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<KPPlanetsRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format
    pub date: String,
    /// Birth location latitude in decimal degrees
    pub latitude: f64,
    /// Birth location longitude in decimal degrees
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the Rahu and Ketu positions. Mean is the traditional Vedic default and what printed panchangs use; the choice can move a KP sub-lord in narrow boundary cases, where a span can be as small as 0.5 degrees. Defaults to "mean".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<KPPlanetsRequestNodeType>,
    /// Birth time in 24-hour HH:MM:SS format
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5 (IST) for Vedic astrology.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<KPPlanetsRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5 (IST) for Vedic astrology.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum KPPlanetsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the Rahu and Ketu positions. Mean is the traditional Vedic default and what printed panchangs use; the choice can move a KP sub-lord in narrow boundary cases, where a span can be as small as 0.5 degrees. Defaults to "mean".
    KPPlanetsRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// Ayanamsa system for sidereal conversion. "kp-newcomb" uses the KP-Newcomb dynamic formula (most common for KP). "kp-old" uses the Krishnamurti original table. "lahiri" uses Lahiri/Chitrapaksha ayanamsa matching most traditional Vedic software. "raman" uses the B.V. Raman ayanamsa, about 1.45 degrees below Lahiri. "custom" allows providing your own value via ayanamsaValue. Defaults to "kp-newcomb".
    KPPlanetsRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Response body of `getKpPlanetsInterval`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPPlanetsIntervalResponse {
    /// Ayanamsa system used for this calculation. "kp-newcomb" = KP-Newcomb (dynamic), "kp-old" = Krishnamurti original (constant rate), "lahiri" = Lahiri/Chitrapaksha.
    pub ayanamsa: String,
    /// Ayanamsa value in degrees used for sidereal conversion. Verify this against your reference source to confirm correct ayanamsa is applied.
    #[serde(rename = "ayanamsaValue")]
    pub ayanamsa_value: f64,
    /// End of the KP ephemeris interval range (ISO 8601).
    #[serde(rename = "endDatetime")]
    pub end_datetime: String,
    /// Time gap between consecutive planetary snapshots in minutes. Determines the granularity of the KP transit table.
    #[serde(rename = "intervalMinutes")]
    pub interval_minutes: f64,
    /// Array of planetary snapshots at each time interval
    pub intervals: Vec<KPPlanetsIntervalResponseIntervalsItem>,
    /// Start of the KP ephemeris interval range (ISO 8601).
    #[serde(rename = "startDatetime")]
    pub start_datetime: String,
    /// Total number of time points calculated (inclusive of both start and end).
    #[serde(rename = "totalIntervals")]
    pub total_intervals: f64,
}
/// One entry of `intervals`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPPlanetsIntervalResponseIntervalsItem {
    /// Date for this data point (YYYY-MM-DD). Adjusted to requested timezone.
    pub date: String,
    /// Full datetime for this data point. Adjusted to requested timezone.
    pub datetime: String,
    /// Planet positions keyed by planet name (Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn, Rahu, Ketu)
    pub planets: KPPlanetsIntervalResponseIntervalsItemPlanets,
    /// Time for this data point (HH:MM). Adjusted to requested timezone.
    pub time: String,
}
/// Planet positions keyed by planet name (Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn, Rahu, Ketu)
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPPlanetsIntervalResponseIntervalsItemPlanets {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<
        String,
        KPPlanetsIntervalResponseIntervalsItemPlanetsAdditionalProperty,
    >,
}
/// The full KP hierarchy for one planet at this timestamp: sidereal longitude and rashi, sign lord, star lord, sublord and sub-sublord, and the 1 to 249 KP number that names the subdivision.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPPlanetsIntervalResponseIntervalsItemPlanetsAdditionalProperty {
    /// Degree within the current rashi (0-30). Useful for gauging how far into a sign the planet has progressed.
    #[serde(rename = "degreeInSign")]
    pub degree_in_sign: f64,
    /// True if the planet is in retrograde (vakri) motion. Rahu and Ketu are always retrograde. Retrograde planets deliver results differently in KP analysis.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// KP number (1-249) identifying the exact Vimshottari subdivision. Each number maps to a unique star lord and sublord combination.
    #[serde(rename = "kpNumber")]
    pub kp_number: f64,
    /// Sidereal longitude in degrees (0-360) using KP ayanamsa. The primary coordinate for all KP sublord lookups.
    pub longitude: f64,
    /// Nakshatra (lunar mansion) the planet occupies. One of 27 Vedic nakshatras spanning 13 degrees 20 minutes each.
    pub nakshatra: String,
    /// Star lord (nakshatra ruler) from Vimshottari dasha sequence. Determines the nature of results this planet delivers. Its occupied and owned houses become L1 and L3 significations.
    #[serde(rename = "nakshatraLord")]
    pub nakshatra_lord: String,
    /// Sidereal zodiac sign (rashi) the planet occupies at this interval.
    pub sign: String,
    /// Rashi lord (sign ruler). First level of the KP significator hierarchy. Its house ownership determines L4 significations for this planet.
    #[serde(rename = "signLord")]
    pub sign_lord: String,
    /// KP sub-sublord (SSL). Third level of Vimshottari subdivision (2,241 divisions). Refines timing within the sublord period for precise event prediction.
    #[serde(rename = "subSublord")]
    pub sub_sublord: String,
    /// KP sublord within the 249-part zodiac division. The deciding factor in KP predictions. An event manifests only if the sublord signifies the relevant house.
    pub sublord: String,
}
/// Request body of `getKpPlanetsInterval`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPPlanetsIntervalRequest {
    /// Ayanamsa system for sidereal conversion. "kp-newcomb" uses the KP-Newcomb dynamic formula, the most common choice for KP astrology. "kp-old" uses the Krishnamurti original table from KP Reader-1 with constant precession rate. "lahiri" uses Lahiri/Chitrapaksha ayanamsa, matching most traditional Vedic software. "raman" uses the B.V. Raman ayanamsa from Hindu Predictive Astrology, a recognised traditional school that sits about 1.45 degrees below Lahiri. Defaults to "kp-newcomb".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<KPPlanetsIntervalRequestAyanamsa>,
    /// End datetime in ISO 8601 (YYYY-MM-DDTHH:MM:SS). Maximum 7 days from start. Interpreted as local time when a non-zero timezone is provided (a trailing Z is accepted but ignored); with timezone 0 it is UTC.
    #[serde(rename = "endDatetime")]
    pub end_datetime: String,
    /// Time between calculations in minutes. Range: 15 (quarter-hourly) to 1440 (daily).
    #[serde(rename = "intervalMinutes")]
    pub interval_minutes: f64,
    /// Observer latitude in decimal degrees (for future Lagna calculations)
    pub latitude: f64,
    /// Observer longitude in decimal degrees (for future Lagna calculations)
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the Rahu and Ketu positions. Mean is the traditional Vedic default and what printed panchangs use; the choice can move a KP sub-lord in narrow boundary cases, where a span can be as small as 0.5 degrees. Defaults to "mean".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<KPPlanetsIntervalRequestNodeType>,
    /// Start datetime in ISO 8601 (YYYY-MM-DDTHH:MM:SS). Interpreted as local time when a non-zero timezone is provided (a trailing Z is accepted but ignored); with timezone 0 it is UTC.
    #[serde(rename = "startDatetime")]
    pub start_datetime: String,
    /// IANA name (e.g. "America/New_York", "Europe/London") OR decimal hours from UTC. IANA resolved to the DST-correct offset for the startDatetime date. When non-zero, all datetimes are treated as local time in this timezone (Z suffix is ignored). Defaults to 0 (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<KPPlanetsIntervalRequestTimezone>,
}
/// IANA name (e.g. "America/New_York", "Europe/London") OR decimal hours from UTC. IANA resolved to the DST-correct offset for the startDatetime date. When non-zero, all datetimes are treated as local time in this timezone (Z suffix is ignored). Defaults to 0 (UTC).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum KPPlanetsIntervalRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the Rahu and Ketu positions. Mean is the traditional Vedic default and what printed panchangs use; the choice can move a KP sub-lord in narrow boundary cases, where a span can be as small as 0.5 degrees. Defaults to "mean".
    KPPlanetsIntervalRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// Ayanamsa system for sidereal conversion. "kp-newcomb" uses the KP-Newcomb dynamic formula, the most common choice for KP astrology. "kp-old" uses the Krishnamurti original table from KP Reader-1 with constant precession rate. "lahiri" uses Lahiri/Chitrapaksha ayanamsa, matching most traditional Vedic software. "raman" uses the B.V. Raman ayanamsa from Hindu Predictive Astrology, a recognised traditional school that sits about 1.45 degrees below Lahiri. Defaults to "kp-newcomb".
    KPPlanetsIntervalRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
    }
}
/// A complete KP horary (Prashna) chart: the Ascendant from the number, the cusps and planets from the moment of the question, plus ruling planets and four-level significators.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPHoraryResponse {
    /// The Ascendant the horary number produced. This is the ONLY part of the chart that comes from the number; everything else comes from the sky at the moment of the question.
    pub ascendant: KPHoraryResponseAscendant,
    /// Degrees subtracted from every tropical longitude to produce this chart. Compare it against your reference software before treating a placement difference as a disagreement.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
    /// Sidereal frame used, echoed back.
    #[serde(rename = "ayanamsaType")]
    pub ayanamsa_type: String,
    /// Twelve Placidus cusps, house 1 first. House 1 is the horary Ascendant; the other eleven follow from the house frame that Ascendant implies at this latitude.
    pub cusps: Vec<KPHoraryResponseCuspsItem>,
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    pub focus: KPHoraryResponseFocus,
    /// The number that was asked for, echoed so a stored chart is self describing.
    #[serde(rename = "horaryNumber")]
    pub horary_number: i64,
    /// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
    #[serde(rename = "houseThemes")]
    pub house_themes: KPHoraryResponseHouseThemes,
    /// The nine grahas at the moment of the question, placed against the horary cusps. These come from the real sky, not from the number.
    pub planets: Vec<KPHoraryResponsePlanetsItem>,
    /// UTC instant the chart was cast for, resolved from the date, time and timezone.
    #[serde(rename = "questionTime")]
    pub question_time: String,
    /// Ruling planets at the moment of the question. NOTE the lagna values here are from the TIME-based ascendant, which is the classical ruling-planet definition, not from the horary number.
    #[serde(rename = "rulingPlanets")]
    pub ruling_planets: KPHoraryResponseRulingPlanets,
    /// KP significators for event prediction and timing. Shows which planets signify each house (house-wise) and which houses each planet signifies (planet-wise). Strength order: Level 1 (planets in star of occupant) &gt; Level 2 (occupants) &gt; Level 3 (planets in star of owner) &gt; Level 4 (house owner).
    pub significators: KPHoraryResponseSignificators,
}
/// KP significators for event prediction and timing. Shows which planets signify each house (house-wise) and which houses each planet signifies (planet-wise). Strength order: Level 1 (planets in star of occupant) &gt; Level 2 (occupants) &gt; Level 3 (planets in star of owner) &gt; Level 4 (house owner).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPHoraryResponseSignificators {
    /// The `houseWise` field.
    #[serde(rename = "houseWise")]
    pub house_wise: Vec<KPHoraryResponseSignificatorsHouseWiseItem>,
    /// The `planetWise` field.
    #[serde(rename = "planetWise")]
    pub planet_wise: Vec<KPHoraryResponseSignificatorsPlanetWiseItem>,
}
/// One entry of `planetWise`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPHoraryResponseSignificatorsPlanetWiseItem {
    /// The four levels flattened, strongest first, repeats included: a house appears once per level the planet reaches it at, so the length counts level hits. The levels beside it are the per-level view.
    #[serde(rename = "allHouses")]
    pub all_houses: Vec<f64>,
    /// Vedic graha (planet) being analyzed for its house significations.
    pub planet: String,
    /// The `signifies` field.
    pub signifies: Vec<KPHoraryResponseSignificatorsPlanetWiseItemSignifiesItem>,
}
/// One entry of `signifies`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPHoraryResponseSignificatorsPlanetWiseItemSignifiesItem {
    /// House numbers this planet signifies at this strength level.
    pub houses: Vec<f64>,
    /// KP significator strength level (1-4). L1 strongest, L4 weakest.
    pub level: f64,
}
/// One entry of `houseWise`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPHoraryResponseSignificatorsHouseWiseItem {
    /// The four levels flattened, strongest first, repeats included: a planet that reaches the house at two levels appears once per level, so the length counts level hits. The levels beside it are the per-level view.
    pub all: Vec<String>,
    /// House number 1-12
    pub house: f64,
    /// The `significators` field.
    pub significators: Vec<KPHoraryResponseSignificatorsHouseWiseItemSignificatorsItem>,
}
/// One entry of `significators`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPHoraryResponseSignificatorsHouseWiseItemSignificatorsItem {
    /// Human-readable label for this KP significator level.
    pub description: String,
    /// KP significator strength level (1-4). L1: planets in star of occupant (strongest). L2: occupant itself. L3: planets in star of owner. L4: sign owner. Lower number = stronger signification for this house.
    pub level: f64,
    /// Planets signifying this house at this strength level.
    pub planets: Vec<String>,
}
/// Ruling planets at the moment of the question. NOTE the lagna values here are from the TIME-based ascendant, which is the classical ruling-planet definition, not from the horary number.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPHoraryResponseRulingPlanets {
    /// Lord of the Hindu weekday, counted from sunrise.
    #[serde(rename = "dayLord")]
    pub day_lord: String,
    /// Sign lord of the ascendant at the question moment.
    #[serde(rename = "lagnaSignLord")]
    pub lagna_sign_lord: String,
    /// Star lord of that ascendant.
    #[serde(rename = "lagnaStarLord")]
    pub lagna_star_lord: String,
    /// Sub-sub lord of that ascendant.
    #[serde(rename = "lagnaSubSublord")]
    pub lagna_sub_sublord: String,
    /// Sub lord of that ascendant.
    #[serde(rename = "lagnaSublord")]
    pub lagna_sublord: String,
    /// Sign lord of the Moon.
    #[serde(rename = "moonSignLord")]
    pub moon_sign_lord: String,
    /// Star lord of the Moon.
    #[serde(rename = "moonStarLord")]
    pub moon_star_lord: String,
    /// Sub-sub lord of the Moon.
    #[serde(rename = "moonSubSublord")]
    pub moon_sub_sublord: String,
    /// Sub lord of the Moon.
    #[serde(rename = "moonSublord")]
    pub moon_sublord: String,
    /// The distinct ruling planets in KP order of strength. They validate the chart: when they repeat the significators of the houses the question needs, the judgment is considered reliable.
    #[serde(rename = "rulingPlanets")]
    pub ruling_planets: Vec<String>,
}
/// One graha at the moment of the question, with its full KP hierarchy.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPHoraryResponsePlanetsItem {
    /// Placidus house the graha occupies in this horary chart, counted against the cusps above rather than by whole sign.
    pub house: i64,
    /// Retrograde motion flag.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// KP horary number 1 to 249 of the sub division holding this point. Matches the standard published KP table.
    #[serde(rename = "kpNumber")]
    pub kp_number: i64,
    /// Sidereal longitude at the moment of the question.
    pub longitude: f64,
    /// Graha name.
    pub planet: String,
    /// Zodiac sign (rashi) of this point.
    pub sign: String,
    /// Nakshatra (star) this point falls in.
    pub star: String,
    /// Nakshatra lord (star lord), the second level of the KP hierarchy.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// Sub lord, the decisive level in KP. A cusp sub lord is what answers the question: it is read for whether the matter is promised, before any timing is attempted.
    #[serde(rename = "subLord")]
    pub sub_lord: String,
    /// Sub-sub lord, the fourth KP level, used to refine timing.
    #[serde(rename = "subSubLord")]
    pub sub_sub_lord: String,
}
/// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPHoraryResponseHouseThemes {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, Vec<String>>,
}
string_enum! {
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    KPHoraryResponseFocus {
        General = "general",
        Finance = "finance",
    }
}
/// One Placidus cusp with its KP lords. The sub lord of the cusp relevant to the question is the value a KP practitioner reads first.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPHoraryResponseCuspsItem {
    /// House (bhava) number 1 to 12.
    pub house: i64,
    /// KP horary number 1 to 249 of the sub division holding this point. Matches the standard published KP table.
    #[serde(rename = "kpNumber")]
    pub kp_number: i64,
    /// Sidereal longitude of the cusp.
    pub longitude: f64,
    /// Zodiac sign (rashi) of this point.
    pub sign: String,
    /// Nakshatra (star) this point falls in.
    pub star: String,
    /// Nakshatra lord (star lord), the second level of the KP hierarchy.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// Sub lord, the decisive level in KP. A cusp sub lord is what answers the question: it is read for whether the matter is promised, before any timing is attempted.
    #[serde(rename = "subLord")]
    pub sub_lord: String,
}
/// The Ascendant the horary number produced. This is the ONLY part of the chart that comes from the number; everything else comes from the sky at the moment of the question.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPHoraryResponseAscendant {
    /// Degrees into the sign, 0 to 30, which is what a chart displays.
    #[serde(rename = "degreeInSign")]
    pub degree_in_sign: f64,
    /// KP horary number 1 to 249 of the sub division holding this point. Matches the standard published KP table.
    #[serde(rename = "kpNumber")]
    pub kp_number: i64,
    /// Sidereal longitude of the horary Ascendant, taken as the MIDPOINT of the sub division the number names.
    pub longitude: f64,
    /// Zodiac sign (rashi) of this point.
    pub sign: String,
    /// Sidereal longitude where this numbered sub division begins.
    #[serde(rename = "spanFrom")]
    pub span_from: f64,
    /// Sidereal longitude where it ends. The Ascendant sits midway between this and spanFrom.
    #[serde(rename = "spanTo")]
    pub span_to: f64,
    /// Nakshatra (star) this point falls in.
    pub star: String,
    /// Nakshatra lord (star lord), the second level of the KP hierarchy.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// Sub lord, the decisive level in KP. A cusp sub lord is what answers the question: it is read for whether the matter is promised, before any timing is attempted.
    #[serde(rename = "subLord")]
    pub sub_lord: String,
}
/// Request body of `castKpHoraryChart`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPHoraryRequest {
    /// Ayanamsa system for sidereal conversion. "kp-newcomb" uses the KP-Newcomb dynamic formula (most common for KP). "kp-old" uses the Krishnamurti original table. "lahiri" uses Lahiri/Chitrapaksha ayanamsa matching most traditional Vedic software. "raman" uses the B.V. Raman ayanamsa, about 1.45 degrees below Lahiri. "custom" allows providing your own value via ayanamsaValue. Defaults to "kp-newcomb".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<KPHoraryRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Date the question was taken up for judgment, YYYY-MM-DD. Not a birth date: a horary chart needs no birth details at all, which is the point of the method.
    pub date: String,
    /// Horary number from 1 to 249, given by the querent while focused on their question. It maps to one of the 249 KP sub divisions of the zodiac, and that division sets the Ascendant of the chart. The querent should give the first number that comes to mind and use it once for that question; the astrologer never chooses it. Numbers outside 1 to 249 are rejected rather than wrapped, because a wrapped number would silently answer a different question.
    #[serde(rename = "horaryNumber")]
    pub horary_number: i64,
    /// Latitude where the question is judged, decimal degrees. The house cusps are Placidus and therefore latitude dependent, so this is the place of judgment, not the querent birthplace.
    pub latitude: f64,
    /// Longitude where the question is judged, decimal degrees.
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the Rahu and Ketu positions. Mean is the traditional Vedic default and what printed panchangs use; the choice can move a KP sub-lord in narrow boundary cases, where a span can be as small as 0.5 degrees. Defaults to "mean".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<KPHoraryRequestNodeType>,
    /// Time the question was taken up for judgment, 24-hour HH:MM:SS. In KP practice this is the moment the astrologer receives and understands the question, not the moment the querent first thought of it. It sets every planetary position and all twelve cusps except the Ascendant.
    pub time: String,
    /// Timezone: IANA name (e.g. "Asia/Kolkata") OR decimal hours from UTC. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<KPHoraryRequestTimezone>,
}
/// Timezone: IANA name (e.g. "Asia/Kolkata") OR decimal hours from UTC. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum KPHoraryRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the Rahu and Ketu positions. Mean is the traditional Vedic default and what printed panchangs use; the choice can move a KP sub-lord in narrow boundary cases, where a span can be as small as 0.5 degrees. Defaults to "mean".
    KPHoraryRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// Ayanamsa system for sidereal conversion. "kp-newcomb" uses the KP-Newcomb dynamic formula (most common for KP). "kp-old" uses the Krishnamurti original table. "lahiri" uses Lahiri/Chitrapaksha ayanamsa matching most traditional Vedic software. "raman" uses the B.V. Raman ayanamsa, about 1.45 degrees below Lahiri. "custom" allows providing your own value via ayanamsaValue. Defaults to "kp-newcomb".
    KPHoraryRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Response body of `getKpDailyFinance`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPDailyFinanceResponse {
    /// Ayanamsa system for sidereal conversion. "kp-newcomb" uses the KP-Newcomb dynamic formula, the most common choice for KP astrology. "kp-old" uses the Krishnamurti original table from KP Reader-1 with constant precession rate. "lahiri" uses Lahiri/Chitrapaksha ayanamsa, matching most traditional Vedic software. "raman" uses the B.V. Raman ayanamsa from Hindu Predictive Astrology, a recognised traditional school that sits about 1.45 degrees below Lahiri. Defaults to "kp-newcomb".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<KPDailyFinanceResponseAyanamsa>,
    /// Degrees subtracted from the tropical longitudes, resolved at the birth date. One frame for the whole reading: cusps, significators, Vimshottari balance, ruling planets and Moon windows alike.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
    /// The score as one of five bands, each entered at its edge: "strong" from 70, "favourable" from 55, "mixed" from 45, "caution" from 30, "unfavourable" below 30. "mixed" is the ordinary day. Canonical English machine values.
    pub band: KPDailyFinanceResponseBand,
    /// The favourable Moon window of the day, the longest when several qualify, or null when the day has none. The one stretch the method backs outright.
    #[serde(rename = "bestWindow")]
    pub best_window: Option<KPDailyFinanceResponseBestWindow>,
    /// The civil date read.
    pub date: String,
    /// The `houses` field.
    pub houses: KPDailyFinanceResponseHouses,
    /// The `layers` field.
    pub layers: KPDailyFinanceResponseLayers,
    /// The reading moment, local datetime in the request timezone. The ruling planets and the dasha lords are read here.
    #[serde(rename = "readingAt")]
    pub reading_at: String,
    /// The weight-sum of the four layer scores, 0 to 100, one decimal: cusps 30, dasha 40, rulingPlanets 15, moonWindows 15, each divided by 100. Recomputable from the layers printed above. The house groups, the classification, the inversion on the loss cusps, the retrograde penalty, the level weights and the layer weights are a KP practitioner convention adopted as the published convention of this route: no classical KP text weighs these four layers against each other, and every table behind the number is printed so the result can be checked line by line rather than trusted. The score measures what the method outputs for the day, never the probability of a gain or a loss.
    pub score: f64,
    /// The `significators` field.
    pub significators: KPDailyFinanceResponseSignificators,
    /// Every unfavourable Moon window of the day, in clock order.
    #[serde(rename = "worstWindows")]
    pub worst_windows: Vec<KPDailyFinanceResponseWorstWindowsItem>,
}
/// One entry of `worstWindows`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPDailyFinanceResponseWorstWindowsItem {
    /// Local datetime the window opens, in the request timezone.
    pub from: String,
    /// Whether the planet signifies at least one gain house at any of the four tiers.
    #[serde(rename = "inGain")]
    pub in_gain: bool,
    /// Whether the planet signifies at least one loss house at any of the four tiers.
    #[serde(rename = "inLoss")]
    pub in_loss: bool,
    /// The verdict score of the window.
    pub score: f64,
    /// The KP sub lord the Moon holds through this window, the planet the row classifies.
    #[serde(rename = "subLord")]
    pub sub_lord: String,
    /// Local datetime the window closes. The last window of the day closes at the next midnight.
    pub to: String,
    /// The one classification every layer uses: "favourable" when the planet signifies a gain house and no loss house (100), "mixed" when it signifies both (50), "unfavourable" when it signifies a loss house and no gain house (0), "neutral" when it signifies neither (50). Canonical English machine value.
    pub verdict: KPDailyFinanceResponseWorstWindowsItemVerdict,
}
string_enum! {
    /// The one classification every layer uses: "favourable" when the planet signifies a gain house and no loss house (100), "mixed" when it signifies both (50), "unfavourable" when it signifies a loss house and no gain house (0), "neutral" when it signifies neither (50). Canonical English machine value.
    KPDailyFinanceResponseWorstWindowsItemVerdict {
        Favourable = "favourable",
        Mixed = "mixed",
        Unfavourable = "unfavourable",
        Neutral = "neutral",
    }
}
/// The `significators` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPDailyFinanceResponseSignificators {
    /// The per-house evidence the two sets are built from, so any row can be traced to the tier that put its planet in a set.
    #[serde(rename = "byHouse")]
    pub by_house: Vec<KPDailyFinanceResponseSignificatorsByHouseItem>,
    /// Every planet that signifies at least one gain house at any tier. The set every row is judged against.
    pub gain: Vec<String>,
    /// Every planet that signifies at least one loss house at any tier. A planet in both sets reads "mixed" everywhere.
    pub loss: Vec<String>,
}
/// One entry of `byHouse`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPDailyFinanceResponseSignificatorsByHouseItem {
    /// Which set this house feeds. Canonical English machine value.
    pub group: KPDailyFinanceResponseSignificatorsByHouseItemGroup,
    /// The house, 1 to 12.
    pub house: f64,
    /// The four tier significators of the house, strongest tier first: planets in the star of an occupant, occupants, planets in the star of the sign lord, the sign lord. A planet appears once per tier it reaches the house at, exactly as the KP chart route lists them.
    pub significators: Vec<String>,
}
string_enum! {
    /// Which set this house feeds. Canonical English machine value.
    KPDailyFinanceResponseSignificatorsByHouseItemGroup {
        Gain = "gain",
        Loss = "loss",
    }
}
/// The `layers` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPDailyFinanceResponseLayers {
    /// Structural promise: each cusp of the two groups judged by its sub lord, the loss cusps inverted, the mean over the rows.
    pub cusps: KPDailyFinanceResponseLayersCusps,
    /// Timing: the four running Vimshottari lords at the reading moment, in the same sidereal frame as the chart, each judged and penalised if retrograde, then weighed by level.
    pub dasha: KPDailyFinanceResponseLayersDasha,
    /// The hour hand: every stretch of the civil day over which the Moon holds one sub lord, each judged, the mean over the windows. Window boundaries are found by bisection and printed to the second.
    #[serde(rename = "moonWindows")]
    pub moon_windows: KPDailyFinanceResponseLayersMoonWindows,
    /// The pulse of the moment: the KP ruling planets at the reading moment, each once, judged and penalised if retrograde, the mean over the rows.
    #[serde(rename = "rulingPlanets")]
    pub ruling_planets: KPDailyFinanceResponseLayersRulingPlanets,
}
/// The pulse of the moment: the KP ruling planets at the reading moment, each once, judged and penalised if retrograde, the mean over the rows.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPDailyFinanceResponseLayersRulingPlanets {
    /// Which layer this is. Canonical English machine value, the same as its key.
    pub layer: KPDailyFinanceResponseLayersRulingPlanetsLayer,
    /// The `rows` field.
    pub rows: Vec<KPDailyFinanceResponseLayersRulingPlanetsRowsItem>,
    /// The layer on its own, 0 to 100, one decimal: the mean of its rows, or for the dasha layer the level-weighted sum. The final score is the weight-sum of the four layer scores.
    pub score: f64,
    /// Percent of the final score this layer carries. The four weights are cusps 30, dasha 40, rulingPlanets 15, moonWindows 15.
    pub weight: f64,
}
/// One entry of `rows`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPDailyFinanceResponseLayersRulingPlanetsRowsItem {
    /// Whether the planet signifies at least one gain house at any of the four tiers.
    #[serde(rename = "inGain")]
    pub in_gain: bool,
    /// Whether the planet signifies at least one loss house at any of the four tiers.
    #[serde(rename = "inLoss")]
    pub in_loss: bool,
    /// One ruling planet of the reading moment, listed once: the day lord, the sign and star lords of the Moon, and the sign and star lords of the ascendant.
    pub planet: String,
    /// Whether the planet is retrograde in transit at the reading moment. Costs 10 points, floored at 0.
    pub retrograde: bool,
    /// The verdict score after the penalty.
    pub score: f64,
    /// The one classification every layer uses: "favourable" when the planet signifies a gain house and no loss house (100), "mixed" when it signifies both (50), "unfavourable" when it signifies a loss house and no gain house (0), "neutral" when it signifies neither (50). Canonical English machine value.
    pub verdict: KPDailyFinanceResponseLayersRulingPlanetsRowsItemVerdict,
}
string_enum! {
    /// The one classification every layer uses: "favourable" when the planet signifies a gain house and no loss house (100), "mixed" when it signifies both (50), "unfavourable" when it signifies a loss house and no gain house (0), "neutral" when it signifies neither (50). Canonical English machine value.
    KPDailyFinanceResponseLayersRulingPlanetsRowsItemVerdict {
        Favourable = "favourable",
        Mixed = "mixed",
        Unfavourable = "unfavourable",
        Neutral = "neutral",
    }
}
string_enum! {
    /// Which layer this is. Canonical English machine value, the same as its key.
    KPDailyFinanceResponseLayersRulingPlanetsLayer {
        RulingPlanets = "rulingPlanets",
    }
}
/// The hour hand: every stretch of the civil day over which the Moon holds one sub lord, each judged, the mean over the windows. Window boundaries are found by bisection and printed to the second.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPDailyFinanceResponseLayersMoonWindows {
    /// Which layer this is. Canonical English machine value, the same as its key.
    pub layer: KPDailyFinanceResponseLayersMoonWindowsLayer,
    /// The `rows` field.
    pub rows: Vec<KPDailyFinanceResponseLayersMoonWindowsRowsItem>,
    /// The layer on its own, 0 to 100, one decimal: the mean of its rows, or for the dasha layer the level-weighted sum. The final score is the weight-sum of the four layer scores.
    pub score: f64,
    /// Percent of the final score this layer carries. The four weights are cusps 30, dasha 40, rulingPlanets 15, moonWindows 15.
    pub weight: f64,
}
/// One entry of `rows`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPDailyFinanceResponseLayersMoonWindowsRowsItem {
    /// Local datetime the window opens, in the request timezone.
    pub from: String,
    /// Whether the planet signifies at least one gain house at any of the four tiers.
    #[serde(rename = "inGain")]
    pub in_gain: bool,
    /// Whether the planet signifies at least one loss house at any of the four tiers.
    #[serde(rename = "inLoss")]
    pub in_loss: bool,
    /// The verdict score of the window.
    pub score: f64,
    /// The KP sub lord the Moon holds through this window, the planet the row classifies.
    #[serde(rename = "subLord")]
    pub sub_lord: String,
    /// Local datetime the window closes. The last window of the day closes at the next midnight.
    pub to: String,
    /// The one classification every layer uses: "favourable" when the planet signifies a gain house and no loss house (100), "mixed" when it signifies both (50), "unfavourable" when it signifies a loss house and no gain house (0), "neutral" when it signifies neither (50). Canonical English machine value.
    pub verdict: KPDailyFinanceResponseLayersMoonWindowsRowsItemVerdict,
}
string_enum! {
    /// The one classification every layer uses: "favourable" when the planet signifies a gain house and no loss house (100), "mixed" when it signifies both (50), "unfavourable" when it signifies a loss house and no gain house (0), "neutral" when it signifies neither (50). Canonical English machine value.
    KPDailyFinanceResponseLayersMoonWindowsRowsItemVerdict {
        Favourable = "favourable",
        Mixed = "mixed",
        Unfavourable = "unfavourable",
        Neutral = "neutral",
    }
}
string_enum! {
    /// Which layer this is. Canonical English machine value, the same as its key.
    KPDailyFinanceResponseLayersMoonWindowsLayer {
        MoonWindows = "moonWindows",
    }
}
/// Timing: the four running Vimshottari lords at the reading moment, in the same sidereal frame as the chart, each judged and penalised if retrograde, then weighed by level.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPDailyFinanceResponseLayersDasha {
    /// Which layer this is. Canonical English machine value, the same as its key.
    pub layer: KPDailyFinanceResponseLayersDashaLayer,
    /// The `rows` field.
    pub rows: Vec<KPDailyFinanceResponseLayersDashaRowsItem>,
    /// The layer on its own, 0 to 100, one decimal: the mean of its rows, or for the dasha layer the level-weighted sum. The final score is the weight-sum of the four layer scores.
    pub score: f64,
    /// Percent of the final score this layer carries. The four weights are cusps 30, dasha 40, rulingPlanets 15, moonWindows 15.
    pub weight: f64,
}
/// One entry of `rows`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPDailyFinanceResponseLayersDashaRowsItem {
    /// ISO instant the period ends.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Whether the planet signifies at least one gain house at any of the four tiers.
    #[serde(rename = "inGain")]
    pub in_gain: bool,
    /// Whether the planet signifies at least one loss house at any of the four tiers.
    #[serde(rename = "inLoss")]
    pub in_loss: bool,
    /// Which Vimshottari level this lord runs, outermost first.
    pub level: KPDailyFinanceResponseLayersDashaRowsItemLevel,
    /// The running lord at this level.
    pub lord: String,
    /// Whether the lord is retrograde in transit at the reading moment. Rahu and Ketu always are. Costs 10 points, floored at 0.
    pub retrograde: bool,
    /// The verdict score after the retrograde penalty.
    pub score: f64,
    /// ISO instant the period began.
    #[serde(rename = "startDate")]
    pub start_date: String,
    /// The one classification every layer uses: "favourable" when the planet signifies a gain house and no loss house (100), "mixed" when it signifies both (50), "unfavourable" when it signifies a loss house and no gain house (0), "neutral" when it signifies neither (50). Canonical English machine value.
    pub verdict: KPDailyFinanceResponseLayersDashaRowsItemVerdict,
    /// Percent of the dasha layer this level carries, the finer levels weighed more: mahadasha 10, antardasha 20, pratyantardasha 30, sookshmaDasha 40.
    pub weight: f64,
}
string_enum! {
    /// The one classification every layer uses: "favourable" when the planet signifies a gain house and no loss house (100), "mixed" when it signifies both (50), "unfavourable" when it signifies a loss house and no gain house (0), "neutral" when it signifies neither (50). Canonical English machine value.
    KPDailyFinanceResponseLayersDashaRowsItemVerdict {
        Favourable = "favourable",
        Mixed = "mixed",
        Unfavourable = "unfavourable",
        Neutral = "neutral",
    }
}
string_enum! {
    /// Which Vimshottari level this lord runs, outermost first.
    KPDailyFinanceResponseLayersDashaRowsItemLevel {
        Mahadasha = "mahadasha",
        Antardasha = "antardasha",
        Pratyantardasha = "pratyantardasha",
        SookshmaDasha = "sookshmaDasha",
    }
}
string_enum! {
    /// Which layer this is. Canonical English machine value, the same as its key.
    KPDailyFinanceResponseLayersDashaLayer {
        Dasha = "dasha",
    }
}
/// Structural promise: each cusp of the two groups judged by its sub lord, the loss cusps inverted, the mean over the rows.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPDailyFinanceResponseLayersCusps {
    /// Which layer this is. Canonical English machine value, the same as its key.
    pub layer: KPDailyFinanceResponseLayersCuspsLayer,
    /// The `rows` field.
    pub rows: Vec<KPDailyFinanceResponseLayersCuspsRowsItem>,
    /// The layer on its own, 0 to 100, one decimal: the mean of its rows, or for the dasha layer the level-weighted sum. The final score is the weight-sum of the four layer scores.
    pub score: f64,
    /// Percent of the final score this layer carries. The four weights are cusps 30, dasha 40, rulingPlanets 15, moonWindows 15.
    pub weight: f64,
}
/// One entry of `rows`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPDailyFinanceResponseLayersCuspsRowsItem {
    /// The cusp judged, 1 to 12.
    pub house: f64,
    /// Whether the planet signifies at least one gain house at any of the four tiers.
    #[serde(rename = "inGain")]
    pub in_gain: bool,
    /// Whether the planet signifies at least one loss house at any of the four tiers.
    #[serde(rename = "inLoss")]
    pub in_loss: bool,
    /// True on a loss house, where the verdict score is inverted: a loss cusp whose sub lord signifies only loss scores 100, because a denied loss is good news for the native.
    pub inverted: bool,
    /// Sidereal longitude of the cusp in the requested ayanamsa, degrees.
    pub longitude: f64,
    /// The verdict score, 100 / 50 / 0 / 50, after the inversion on a loss house.
    pub score: f64,
    /// Lord of the sign the cusp falls in.
    #[serde(rename = "signLord")]
    pub sign_lord: String,
    /// Lord of the nakshatra the cusp falls in.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// The KP sub lord of the cusp, the one lord that decides whether the house delivers. It is the planet the row classifies.
    #[serde(rename = "subLord")]
    pub sub_lord: String,
    /// The one classification every layer uses: "favourable" when the planet signifies a gain house and no loss house (100), "mixed" when it signifies both (50), "unfavourable" when it signifies a loss house and no gain house (0), "neutral" when it signifies neither (50). Canonical English machine value.
    pub verdict: KPDailyFinanceResponseLayersCuspsRowsItemVerdict,
}
string_enum! {
    /// The one classification every layer uses: "favourable" when the planet signifies a gain house and no loss house (100), "mixed" when it signifies both (50), "unfavourable" when it signifies a loss house and no gain house (0), "neutral" when it signifies neither (50). Canonical English machine value.
    KPDailyFinanceResponseLayersCuspsRowsItemVerdict {
        Favourable = "favourable",
        Mixed = "mixed",
        Unfavourable = "unfavourable",
        Neutral = "neutral",
    }
}
string_enum! {
    /// Which layer this is. Canonical English machine value, the same as its key.
    KPDailyFinanceResponseLayersCuspsLayer {
        Cusps = "cusps",
    }
}
/// The `houses` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPDailyFinanceResponseHouses {
    /// The gain houses this reading used, the request override or the convention.
    pub gain: Vec<f64>,
    /// The loss houses this reading used, the request override or the convention.
    pub loss: Vec<f64>,
}
/// The favourable Moon window of the day, the longest when several qualify, or null when the day has none. The one stretch the method backs outright.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPDailyFinanceResponseBestWindow {
    /// Local datetime the window opens, in the request timezone.
    pub from: String,
    /// Whether the planet signifies at least one gain house at any of the four tiers.
    #[serde(rename = "inGain")]
    pub in_gain: bool,
    /// Whether the planet signifies at least one loss house at any of the four tiers.
    #[serde(rename = "inLoss")]
    pub in_loss: bool,
    /// The verdict score of the window.
    pub score: f64,
    /// The KP sub lord the Moon holds through this window, the planet the row classifies.
    #[serde(rename = "subLord")]
    pub sub_lord: String,
    /// Local datetime the window closes. The last window of the day closes at the next midnight.
    pub to: String,
    /// The one classification every layer uses: "favourable" when the planet signifies a gain house and no loss house (100), "mixed" when it signifies both (50), "unfavourable" when it signifies a loss house and no gain house (0), "neutral" when it signifies neither (50). Canonical English machine value.
    pub verdict: KPDailyFinanceResponseBestWindowVerdict,
}
string_enum! {
    /// The one classification every layer uses: "favourable" when the planet signifies a gain house and no loss house (100), "mixed" when it signifies both (50), "unfavourable" when it signifies a loss house and no gain house (0), "neutral" when it signifies neither (50). Canonical English machine value.
    KPDailyFinanceResponseBestWindowVerdict {
        Favourable = "favourable",
        Mixed = "mixed",
        Unfavourable = "unfavourable",
        Neutral = "neutral",
    }
}
string_enum! {
    /// The score as one of five bands, each entered at its edge: "strong" from 70, "favourable" from 55, "mixed" from 45, "caution" from 30, "unfavourable" below 30. "mixed" is the ordinary day. Canonical English machine values.
    KPDailyFinanceResponseBand {
        Strong = "strong",
        Favourable = "favourable",
        Mixed = "mixed",
        Caution = "caution",
        Unfavourable = "unfavourable",
    }
}
string_enum! {
    /// Ayanamsa system for sidereal conversion. "kp-newcomb" uses the KP-Newcomb dynamic formula, the most common choice for KP astrology. "kp-old" uses the Krishnamurti original table from KP Reader-1 with constant precession rate. "lahiri" uses Lahiri/Chitrapaksha ayanamsa, matching most traditional Vedic software. "raman" uses the B.V. Raman ayanamsa from Hindu Predictive Astrology, a recognised traditional school that sits about 1.45 degrees below Lahiri. Defaults to "kp-newcomb".
    KPDailyFinanceResponseAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
    }
}
/// Request body of `getKpDailyFinance`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPDailyFinanceRequest {
    /// Ayanamsa system for sidereal conversion. "kp-newcomb" uses the KP-Newcomb dynamic formula, the most common choice for KP astrology. "kp-old" uses the Krishnamurti original table from KP Reader-1 with constant precession rate. "lahiri" uses Lahiri/Chitrapaksha ayanamsa, matching most traditional Vedic software. "raman" uses the B.V. Raman ayanamsa from Hindu Predictive Astrology, a recognised traditional school that sits about 1.45 degrees below Lahiri. Defaults to "kp-newcomb".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<KPDailyFinanceRequestAyanamsa>,
    /// Birth date, YYYY-MM-DD. Fixes the Placidus cusps, the four tier significators and the Vimshottari balance every layer reads.
    #[serde(rename = "birthDate")]
    pub birth_date: String,
    /// Birth time, HH:MM:SS, 24 hour, local to the birth place. The cusp sub lords move about one sub every four minutes of clock time, so this is the input the whole reading is most sensitive to.
    #[serde(rename = "birthTime")]
    pub birth_time: String,
    /// Civil date to read, YYYY-MM-DD in the request timezone. Defaults to today (UTC). The Moon windows cover this date from midnight to midnight.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Houses whose significators count as gain, 1 to 12. Defaults to the convention, 2 and 11. Override it to run your own school: the two lists may not share a house.
    #[serde(rename = "gainHouses", skip_serializing_if = "Option::is_none")]
    pub gain_houses: Option<Vec<i64>>,
    /// Birth latitude in decimal degrees. Sets the Placidus cusps; also the place the ruling planets and the Moon windows are read at.
    pub latitude: f64,
    /// Birth longitude in decimal degrees, east positive.
    pub longitude: f64,
    /// Houses whose significators count as loss, 1 to 12. Defaults to the convention, 6 and 8 and 12. Override it to run your own school: the two lists may not share a house.
    #[serde(rename = "lossHouses", skip_serializing_if = "Option::is_none")]
    pub loss_houses: Option<Vec<i64>>,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the Rahu and Ketu positions. Mean is the traditional Vedic default and what printed panchangs use; the choice can move a KP sub-lord in narrow boundary cases, where a span can be as small as 0.5 degrees. Defaults to "mean".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<KPDailyFinanceRequestNodeType>,
    /// Reading moment on that date, HH:MM:SS local. The ruling planets and the running sookshma lord are read at this instant. Defaults to 12:00:00; pass a market open or any hour for an intraday read.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub time: Option<String>,
    /// Timezone as an IANA name (Asia/Kolkata) or decimal hours from UTC. Applies to the birth time, to the reading date and time, and to every local timestamp in the response. IANA names resolve to the offset in force on the date being read.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<KPDailyFinanceRequestTimezone>,
    /// Layer weights in percent, all four required, summing to 100. Defaults to the convention, cusps 30, dasha 40, rulingPlanets 15, moonWindows 15. Seventy percent of the default sits on the cusps and the outer dasha levels, which hold for months, so a chart reads inside a narrow band all month and the bands separate charts more than days. Move weight onto rulingPlanets and moonWindows for a reading that turns with the day.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub weights: Option<KPDailyFinanceRequestWeights>,
}
/// Layer weights in percent, all four required, summing to 100. Defaults to the convention, cusps 30, dasha 40, rulingPlanets 15, moonWindows 15. Seventy percent of the default sits on the cusps and the outer dasha levels, which hold for months, so a chart reads inside a narrow band all month and the bands separate charts more than days. Move weight onto rulingPlanets and moonWindows for a reading that turns with the day.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPDailyFinanceRequestWeights {
    /// Percent of the final score the cusps layer carries.
    pub cusps: f64,
    /// Percent of the final score the dasha layer carries.
    pub dasha: f64,
    /// Percent of the final score the moonWindows layer carries.
    #[serde(rename = "moonWindows")]
    pub moon_windows: f64,
    /// Percent of the final score the rulingPlanets layer carries.
    #[serde(rename = "rulingPlanets")]
    pub ruling_planets: f64,
}
/// Timezone as an IANA name (Asia/Kolkata) or decimal hours from UTC. Applies to the birth time, to the reading date and time, and to every local timestamp in the response. IANA names resolve to the offset in force on the date being read.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum KPDailyFinanceRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the Rahu and Ketu positions. Mean is the traditional Vedic default and what printed panchangs use; the choice can move a KP sub-lord in narrow boundary cases, where a span can be as small as 0.5 degrees. Defaults to "mean".
    KPDailyFinanceRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// Ayanamsa system for sidereal conversion. "kp-newcomb" uses the KP-Newcomb dynamic formula, the most common choice for KP astrology. "kp-old" uses the Krishnamurti original table from KP Reader-1 with constant precession rate. "lahiri" uses Lahiri/Chitrapaksha ayanamsa, matching most traditional Vedic software. "raman" uses the B.V. Raman ayanamsa from Hindu Predictive Astrology, a recognised traditional school that sits about 1.45 degrees below Lahiri. Defaults to "kp-newcomb".
    KPDailyFinanceRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
    }
}
/// Response body of `getKpCusps`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPCuspsResponse {
    /// Applied ayanamsa value in degrees
    pub ayanamsa: f64,
    /// The `cusps` field.
    pub cusps: Vec<KPCuspsResponseCuspsItem>,
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    pub focus: KPCuspsResponseFocus,
    /// House system used for calculations
    #[serde(rename = "houseSystem")]
    pub house_system: String,
    /// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
    #[serde(rename = "houseThemes")]
    pub house_themes: KPCuspsResponseHouseThemes,
}
/// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPCuspsResponseHouseThemes {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, Vec<String>>,
}
string_enum! {
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    KPCuspsResponseFocus {
        General = "general",
        Finance = "finance",
    }
}
/// One entry of `cusps`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPCuspsResponseCuspsItem {
    /// House number (1-12)
    pub house: f64,
    /// KP horary number (1-249)
    #[serde(rename = "kpNumber")]
    pub kp_number: f64,
    /// Cusp longitude in degrees (0-360)
    pub longitude: f64,
    /// Nakshatra (lunar mansion) at this cusp degree. The cusp nakshatra lord and sublord together determine the houses complete significator chain.
    pub nakshatra: String,
    /// Nakshatra lord (star ruler) of the cusp. One of 9 Vimshottari dasha lords. Determines which planet activates this cusp in KP predictions.
    #[serde(rename = "nakshatraLord")]
    pub nakshatra_lord: String,
    /// Nakshatra pada/quarter (1-4)
    pub pada: f64,
    /// Zodiac sign of the cusp
    pub sign: String,
    /// Rashi lord (sign ruler) of this cusp. In KP, the cusp sign lord is a significator for this house.
    #[serde(rename = "signLord")]
    pub sign_lord: String,
    /// Star-lord (nakshatra lord)
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// Sub-lord based on KP 249-level subdivision
    #[serde(rename = "subLord")]
    pub sub_lord: String,
    /// Sub-sub lord (SSL) based on 2241-level KP subdivision. Third level of Vimshottari dasha proportions.
    #[serde(rename = "subSubLord")]
    pub sub_sub_lord: String,
}
/// Request body of `getKpCusps`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPCuspsRequest {
    /// Ayanamsa system for sidereal conversion. "kp-newcomb" uses the KP-Newcomb dynamic formula (most common for KP). "kp-old" uses the Krishnamurti original table. "lahiri" uses Lahiri/Chitrapaksha ayanamsa matching most traditional Vedic software. "raman" uses the B.V. Raman ayanamsa, about 1.45 degrees below Lahiri. "custom" allows providing your own value via ayanamsaValue. Defaults to "kp-newcomb".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<KPCuspsRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format
    pub date: String,
    /// Birth location latitude in decimal degrees
    pub latitude: f64,
    /// Birth location longitude in decimal degrees
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5 (IST) for Vedic astrology.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<KPCuspsRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5 (IST) for Vedic astrology.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum KPCuspsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Ayanamsa system for sidereal conversion. "kp-newcomb" uses the KP-Newcomb dynamic formula (most common for KP). "kp-old" uses the Krishnamurti original table. "lahiri" uses Lahiri/Chitrapaksha ayanamsa matching most traditional Vedic software. "raman" uses the B.V. Raman ayanamsa, about 1.45 degrees below Lahiri. "custom" allows providing your own value via ayanamsaValue. Defaults to "kp-newcomb".
    KPCuspsRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Response body of `generateKpChart`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPChartResponse {
    /// Ascendant (Lagna) details with full KP stellar hierarchy.
    pub ascendant: KPChartResponseAscendant,
    /// All 12 Placidus house cusps with KP stellar hierarchy. Cusp sub lords are the primary predictive tool in KP astrology.
    pub cusps: Vec<KPChartResponseCuspsItem>,
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    pub focus: KPChartResponseFocus,
    /// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
    #[serde(rename = "houseThemes")]
    pub house_themes: KPChartResponseHouseThemes,
    /// Chart metadata including birth data, ayanamsa, and house system.
    pub meta: KPChartResponseMeta,
    /// Lunar nodes (Rahu and Ketu) with KP stellar hierarchy. Nodes are powerful agents that amplify the significations of their dispositors.
    pub nodes: KPChartResponseNodes,
    /// Positions of all 7 visible planets with complete KP stellar breakdown.
    pub planets: Vec<KPChartResponsePlanetsItem>,
    /// KP significators for event prediction and timing. Shows which planets signify each house (house-wise) and which houses each planet signifies (planet-wise). Strength order: Level 1 (planets in star of occupant) &gt; Level 2 (occupants) &gt; Level 3 (planets in star of owner) &gt; Level 4 (house owner).
    pub significators: KPChartResponseSignificators,
}
/// KP significators for event prediction and timing. Shows which planets signify each house (house-wise) and which houses each planet signifies (planet-wise). Strength order: Level 1 (planets in star of occupant) &gt; Level 2 (occupants) &gt; Level 3 (planets in star of owner) &gt; Level 4 (house owner).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPChartResponseSignificators {
    /// The `houseWise` field.
    #[serde(rename = "houseWise")]
    pub house_wise: Vec<KPChartResponseSignificatorsHouseWiseItem>,
    /// The `planetWise` field.
    #[serde(rename = "planetWise")]
    pub planet_wise: Vec<KPChartResponseSignificatorsPlanetWiseItem>,
}
/// One entry of `planetWise`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPChartResponseSignificatorsPlanetWiseItem {
    /// The four levels flattened, strongest first, repeats included: a house appears once per level the planet reaches it at, so the length counts level hits. The levels beside it are the per-level view.
    #[serde(rename = "allHouses")]
    pub all_houses: Vec<f64>,
    /// Vedic graha (planet) being analyzed for its house significations.
    pub planet: String,
    /// The `signifies` field.
    pub signifies: Vec<KPChartResponseSignificatorsPlanetWiseItemSignifiesItem>,
}
/// One entry of `signifies`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPChartResponseSignificatorsPlanetWiseItemSignifiesItem {
    /// House numbers this planet signifies at this strength level.
    pub houses: Vec<f64>,
    /// KP significator strength level (1-4). L1 strongest, L4 weakest.
    pub level: f64,
}
/// One entry of `houseWise`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPChartResponseSignificatorsHouseWiseItem {
    /// The four levels flattened, strongest first, repeats included: a planet that reaches the house at two levels appears once per level, so the length counts level hits. The levels beside it are the per-level view.
    pub all: Vec<String>,
    /// House number 1-12
    pub house: f64,
    /// The `significators` field.
    pub significators: Vec<KPChartResponseSignificatorsHouseWiseItemSignificatorsItem>,
}
/// One entry of `significators`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPChartResponseSignificatorsHouseWiseItemSignificatorsItem {
    /// Human-readable label for this KP significator level.
    pub description: String,
    /// KP significator strength level (1-4). L1: planets in star of occupant (strongest). L2: occupant itself. L3: planets in star of owner. L4: sign owner. Lower number = stronger signification for this house.
    pub level: f64,
    /// Planets signifying this house at this strength level.
    pub planets: Vec<String>,
}
/// One entry of `planets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPChartResponsePlanetsItem {
    /// House number (1-12) based on Placidus cusps.
    pub house: f64,
    /// KP number (1-249).
    #[serde(rename = "kpNumber")]
    pub kp_number: f64,
    /// Sidereal longitude in degrees (KP ayanamsa corrected).
    pub longitude: f64,
    /// Nakshatra the planet occupies.
    pub nakshatra: String,
    /// Nakshatra lord (same as star lord).
    #[serde(rename = "nakshatraLord")]
    pub nakshatra_lord: String,
    /// Nakshatra pada (1-4).
    pub pada: f64,
    /// Planet name (Sun through Saturn, 7 visible planets).
    pub planet: String,
    /// True if planet is retrograde. Retrograde planets may delay or deny results in KP system.
    pub retrograde: bool,
    /// Zodiac sign the planet occupies.
    pub sign: String,
    /// Rashi lord (sign ruler). First level of the KP significator hierarchy. Its house ownership determines L4 significations.
    #[serde(rename = "signLord")]
    pub sign_lord: String,
    /// KP star lord, determines primary house signification.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// KP sub lord, the decisive factor. Planet gives results of the houses signified by its sub lord.
    #[serde(rename = "subLord")]
    pub sub_lord: String,
    /// KP sub-sub lord (SSL) of the planet. Third level of Vimshottari subdivision for precise timing analysis.
    #[serde(rename = "subSubLord")]
    pub sub_sub_lord: String,
}
/// Lunar nodes (Rahu and Ketu) with KP stellar hierarchy. Nodes are powerful agents that amplify the significations of their dispositors.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPChartResponseNodes {
    /// Ketu (South Lunar Node), shadow planet, spiritual karmic indicator.
    pub ketu: KPChartResponseNodesKetu,
    /// Rahu (North Lunar Node), shadow planet, always retrograde, acts as agent of its sign lord and star lord.
    pub rahu: KPChartResponseNodesRahu,
}
/// Rahu (North Lunar Node), shadow planet, always retrograde, acts as agent of its sign lord and star lord.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPChartResponseNodesRahu {
    /// Occupied house number (1-12) based on Placidus cusps.
    pub house: f64,
    /// KP number (1-249) locating Rahu in the 249-division sub-lord scheme. Each of the 249 divisions maps to a unique sign, star lord and sub lord triple, so one integer pins the position precisely enough for KP event timing.
    #[serde(rename = "kpNumber")]
    pub kp_number: f64,
    /// Sidereal longitude of Rahu (North Node).
    pub longitude: f64,
    /// Nakshatra of Rahu.
    pub nakshatra: String,
    /// Nakshatra pada (1-4) of Rahu.
    pub pada: f64,
    /// Zodiac sign Rahu occupies.
    pub sign: String,
    /// Rashi lord of the sign Rahu occupies. Rahu has no sign of its own and acts as agent of this lord.
    #[serde(rename = "signLord")]
    pub sign_lord: String,
    /// KP star lord of Rahu.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// KP sub lord of Rahu.
    #[serde(rename = "subLord")]
    pub sub_lord: String,
    /// KP sub-sub lord (SSL) of Rahu.
    #[serde(rename = "subSubLord")]
    pub sub_sub_lord: String,
}
/// Ketu (South Lunar Node), shadow planet, spiritual karmic indicator.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPChartResponseNodesKetu {
    /// Occupied house number (1-12) based on Placidus cusps.
    pub house: f64,
    /// KP number (1-249) locating Ketu in the 249-division sub-lord scheme. Each of the 249 divisions maps to a unique sign, star lord and sub lord triple, so one integer pins the position precisely enough for KP event timing.
    #[serde(rename = "kpNumber")]
    pub kp_number: f64,
    /// Sidereal longitude of Ketu (South Node). Always 180 degrees from Rahu.
    pub longitude: f64,
    /// Nakshatra of Ketu.
    pub nakshatra: String,
    /// Nakshatra pada (1-4) of Ketu.
    pub pada: f64,
    /// Zodiac sign Ketu occupies.
    pub sign: String,
    /// Rashi lord of the sign Ketu occupies. Ketu has no sign of its own and acts as agent of this lord.
    #[serde(rename = "signLord")]
    pub sign_lord: String,
    /// KP star lord of Ketu.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// KP sub lord of Ketu.
    #[serde(rename = "subLord")]
    pub sub_lord: String,
    /// KP sub-sub lord (SSL) of Ketu.
    #[serde(rename = "subSubLord")]
    pub sub_sub_lord: String,
}
/// Chart metadata including birth data, ayanamsa, and house system.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPChartResponseMeta {
    /// KP Newcomb ayanamsa value in degrees. Precession correction applied to convert tropical to sidereal positions.
    pub ayanamsa: f64,
    /// Ayanamsa system used, echoing the ayanamsa field of the request: "kp-newcomb", "kp-old", "lahiri", "raman" or "custom".
    #[serde(rename = "ayanamsaType")]
    pub ayanamsa_type: String,
    /// Birth date in YYYY-MM-DD format used for this KP chart calculation.
    pub date: String,
    /// House system used (Placidus, standard for KP astrology).
    #[serde(rename = "houseSystem")]
    pub house_system: String,
    /// Birth location latitude in decimal degrees. Determines Placidus house cusps and Ascendant.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local sidereal time for house calculations.
    pub longitude: f64,
    /// Birth time in HH:MM:SS format used for Lagna and Placidus cusp calculations.
    pub time: String,
    /// Timezone offset from UTC in decimal hours used for time conversion.
    pub timezone: f64,
}
/// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPChartResponseHouseThemes {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, Vec<String>>,
}
string_enum! {
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    KPChartResponseFocus {
        General = "general",
        Finance = "finance",
    }
}
/// One entry of `cusps`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPChartResponseCuspsItem {
    /// House number (1-12).
    pub house: f64,
    /// KP number (1-249) for the cusp degree.
    #[serde(rename = "kpNumber")]
    pub kp_number: f64,
    /// Placidus cusp longitude in sidereal degrees.
    pub longitude: f64,
    /// Nakshatra at the cusp degree.
    pub nakshatra: String,
    /// Lord of the nakshatra at the cusp.
    #[serde(rename = "nakshatraLord")]
    pub nakshatra_lord: String,
    /// Nakshatra pada (1-4) at the cusp.
    pub pada: f64,
    /// Zodiac sign at the cusp.
    pub sign: String,
    /// Lord of the zodiac sign at the cusp (house owner).
    #[serde(rename = "signLord")]
    pub sign_lord: String,
    /// KP star lord of the cusp.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// KP sub lord of the cusp. the deciding factor for house-level predictions in KP astrology.
    #[serde(rename = "subLord")]
    pub sub_lord: String,
    /// KP sub-sub lord (SSL) of the cusp. Third level of Vimshottari subdivision for fine-grained cusp analysis.
    #[serde(rename = "subSubLord")]
    pub sub_sub_lord: String,
}
/// Ascendant (Lagna) details with full KP stellar hierarchy.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPChartResponseAscendant {
    /// KP number (1-249) for the Ascendant degree.
    #[serde(rename = "kpNumber")]
    pub kp_number: f64,
    /// Sidereal longitude of Ascendant (Lagna) in degrees.
    pub longitude: f64,
    /// Nakshatra (star) of the Ascendant.
    pub nakshatra: String,
    /// Lord of the Ascendant nakshatra.
    #[serde(rename = "nakshatraLord")]
    pub nakshatra_lord: String,
    /// Nakshatra pada (1-4) of the Ascendant.
    pub pada: f64,
    /// Zodiac sign of the Ascendant.
    pub sign: String,
    /// Ruling planet of the Ascendant sign (the rashi lord). In KP this is the weakest of the four lords, ranked below the star lord and sub lord, but it still sets the broad temperament of the Lagna.
    #[serde(rename = "signLord")]
    pub sign_lord: String,
    /// KP star lord of the Ascendant position.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// KP sub lord of the Ascendant. crucial for KP predictions. The Ascendant sub lord determines overall life promise.
    #[serde(rename = "subLord")]
    pub sub_lord: String,
    /// KP sub-sub lord (SSL) of the Ascendant. Third level of the Vimshottari subdivision hierarchy, used for fine-tuning predictions.
    #[serde(rename = "subSubLord")]
    pub sub_sub_lord: String,
}
/// Request body of `generateKpChart`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPChartRequest {
    /// Ayanamsa system for sidereal conversion. "kp-newcomb" uses the KP-Newcomb dynamic formula (most common for KP). "kp-old" uses the Krishnamurti original table. "lahiri" uses Lahiri/Chitrapaksha ayanamsa matching most traditional Vedic software. "raman" uses the B.V. Raman ayanamsa, about 1.45 degrees below Lahiri. "custom" allows providing your own value via ayanamsaValue. Defaults to "kp-newcomb".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<KPChartRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format
    pub date: String,
    /// Birth location latitude in decimal degrees
    pub latitude: f64,
    /// Birth location longitude in decimal degrees
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the Rahu and Ketu positions. Mean is the traditional Vedic default and what printed panchangs use; the choice can move a KP sub-lord in narrow boundary cases, where a span can be as small as 0.5 degrees. Defaults to "mean".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<KPChartRequestNodeType>,
    /// Birth time in 24-hour HH:MM:SS format. CRITICAL for accurate Lagna and house calculations.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5 (IST) for Vedic astrology.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<KPChartRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5 (IST) for Vedic astrology.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum KPChartRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the Rahu and Ketu positions. Mean is the traditional Vedic default and what printed panchangs use; the choice can move a KP sub-lord in narrow boundary cases, where a span can be as small as 0.5 degrees. Defaults to "mean".
    KPChartRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// Ayanamsa system for sidereal conversion. "kp-newcomb" uses the KP-Newcomb dynamic formula (most common for KP). "kp-old" uses the Krishnamurti original table. "lahiri" uses Lahiri/Chitrapaksha ayanamsa matching most traditional Vedic software. "raman" uses the B.V. Raman ayanamsa, about 1.45 degrees below Lahiri. "custom" allows providing your own value via ayanamsaValue. Defaults to "kp-newcomb".
    KPChartRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Response body of `calculateHouses`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct HousesResponse {
    /// Ascendant (rising sign) position. The eastern horizon point at the moment of birth, defining personality expression and physical appearance in Western astrology.
    pub ascendant: HousesResponseAscendant,
    /// Side-by-side house cusp comparison keyed by house system id: placidus, whole-sign, equal, koch. Only included when houseSystem is set to "all". A system that cannot be computed at the latitude (Placidus and Koch beyond 66 degrees 33 minutes north or south) is omitted, so every key present carries its own cusps, and the top level houses array is the first system present in that order. Useful for educational tools and system comparison.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub comparison: Option<HousesResponseComparison>,
    /// Input date used for this house cusp calculation.
    pub date: String,
    /// House system used for this calculation (placidus, whole-sign, equal, koch, or all).
    #[serde(rename = "houseSystem")]
    pub house_system: String,
    /// All 12 house cusps with their zodiac positions. House cusps divide the chart into life areas: identity (1st), resources (2nd), communication (3rd), home (4th), creativity (5th), health (6th), partnerships (7th), transformation (8th), philosophy (9th), career (10th), community (11th), spirituality (12th).
    pub houses: Vec<HousesResponseHousesItem>,
    /// Observer latitude used for horizon-based house calculations.
    pub latitude: f64,
    /// Observer longitude used for local sidereal time.
    pub longitude: f64,
    /// Midheaven (MC) position. The highest point of the ecliptic at birth, representing career aspirations and public image in natal astrology.
    pub midheaven: HousesResponseMidheaven,
    /// Input time used for this house cusp calculation.
    pub time: String,
    /// Timezone offset from UTC applied to this calculation.
    pub timezone: f64,
}
/// Midheaven (MC) position. The highest point of the ecliptic at birth, representing career aspirations and public image in natal astrology.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct HousesResponseMidheaven {
    /// Degree within the Midheaven sign (0-29.999).
    pub degree: f64,
    /// Absolute ecliptic longitude of the Midheaven in degrees (0-360).
    pub longitude: f64,
    /// Zodiac sign on the Midheaven (MC). Indicates career direction and public reputation.
    pub sign: String,
}
/// One entry of `houses`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct HousesResponseHousesItem {
    /// Degree within the zodiac sign on this cusp (0-29.999).
    pub degree: f64,
    /// Ecliptic longitude of this house cusp in degrees (0-360).
    pub longitude: f64,
    /// House number (1-12). Each house governs specific life areas.
    pub number: f64,
    /// Zodiac sign on this house cusp.
    pub sign: String,
}
/// Side-by-side house cusp comparison keyed by house system id: placidus, whole-sign, equal, koch. Only included when houseSystem is set to "all". A system that cannot be computed at the latitude (Placidus and Koch beyond 66 degrees 33 minutes north or south) is omitted, so every key present carries its own cusps, and the top level houses array is the first system present in that order. Useful for educational tools and system comparison.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct HousesResponseComparison {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<
        String,
        HousesResponseComparisonAdditionalProperty,
    >,
}
/// The twelve cusps under the one house system this key names, in the same shape as the top level houses array, so a caller can render any system through the same component.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct HousesResponseComparisonAdditionalProperty {
    /// All 12 house cusps as this system computes them. Compare the same house number across the four keys to see how far the systems disagree, which is largest at high latitudes and for the intermediate cusps.
    pub houses: Vec<HousesResponseComparisonAdditionalPropertyHousesItem>,
}
/// One entry of `houses`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct HousesResponseComparisonAdditionalPropertyHousesItem {
    /// Degree within the zodiac sign on this cusp (0-29.999).
    pub degree: f64,
    /// Ecliptic longitude of this house cusp in degrees (0-360), as this house system places it.
    pub longitude: f64,
    /// House number (1-12). Each house governs specific life areas.
    pub number: f64,
    /// Zodiac sign on this house cusp in this house system.
    pub sign: String,
}
/// Ascendant (rising sign) position. The eastern horizon point at the moment of birth, defining personality expression and physical appearance in Western astrology.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct HousesResponseAscendant {
    /// Degree within the Ascendant sign (0-29.999).
    pub degree: f64,
    /// Absolute ecliptic longitude of the Ascendant in degrees (0-360).
    pub longitude: f64,
    /// Zodiac sign on the Ascendant (rising sign). Determines the first house cusp.
    pub sign: String,
}
/// Heliacal rising and setting status of the six visible grahas.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct HeliacalResponse {
    /// Local calendar date the verdicts were read for, echoed from the request.
    pub date: String,
    /// One entry per visible graha, in classical order. A graha is omitted only when no horizon crossing exists for it at this latitude on this day.
    pub grahas: Vec<HeliacalResponseGrahasItem>,
}
/// Heliacal visibility of one graha on the requested day.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct HeliacalResponseGrahasItem {
    /// Graha name. Only the six with a visible body appear: Moon, Mars, Mercury, Jupiter, Venus and Saturn. The Sun cannot be lost in his own glare, and Rahu and Ketu are computed points with nothing to see.
    pub graha: String,
    /// Horizon this graha is currently judged at. West means it sets after the Sun and is an evening object, east that it rises before him and is a morning one.
    pub horizon: HeliacalResponseGrahasItemHorizon,
    /// The limit in degrees of time this graha must clear to be seen, per Surya Siddhanta ch. IX vv.6-8 and ch. X.1: Moon 12, Jupiter 11, Saturn 15, Mars 17, Venus 10 or 8, Mercury 14 or 12. Larger means the graha is fainter and needs more distance from the Sun.
    pub kalamsa: f64,
    /// The event that produced the current state, or null when none falls inside the search horizon (up to about one synodic period, so Mars can legitimately have none).
    #[serde(rename = "lastEvent")]
    pub last_event: Option<HeliacalResponseGrahasItemLastEvent>,
    /// Plain angular separation of the two ecliptic longitudes, in degrees. Returned beside timeDegrees so the two measures can be compared: this is what a combustion flag on a birth chart uses, and the gap between them is precisely what a location-aware heliacal calculation adds.
    #[serde(rename = "longitudeSeparation")]
    pub longitude_separation: f64,
    /// The event that will end the current state, or null when none falls inside the search horizon. For an invisible graha this is the udaya a practitioner is waiting for, so it answers when Guru Asta or Shukra Asta lifts.
    #[serde(rename = "nextEvent")]
    pub next_event: Option<HeliacalResponseGrahasItemNextEvent>,
    /// Whether the graha is retrograde, which for Mercury and Venus tightens the limit (Venus 10 to 8, Mercury 14 to 12). Retrograde puts them near inferior conjunction where they are far closer to Earth, so the larger brighter disk survives closer to the Sun.
    pub retrograde: bool,
    /// Separation from the Sun in degrees of TIME (kalamsa), measured along the equator between the two bodies horizon crossings. This is the quantity Surya Siddhanta actually compares against the limit, and it is not the same as the difference of ecliptic longitudes: the two diverge by roughly 3 degrees at Mumbai and by more than 15 further north, because it accounts for the angle the ecliptic makes with the local horizon.
    #[serde(rename = "timeDegrees")]
    pub time_degrees: f64,
    /// Whether the graha clears the Sun glare on this day. False is the state a practitioner calls asta or combust, during which classical muhurta withholds auspicious ceremonies, most strictly marriage while Jupiter or Venus is invisible.
    pub visible: bool,
}
/// The event that will end the current state, or null when none falls inside the search horizon. For an invisible graha this is the udaya a practitioner is waiting for, so it answers when Guru Asta or Shukra Asta lifts.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct HeliacalResponseGrahasItemNextEvent {
    /// Local civil datetime of the event (YYYY-MM-DDTHH:MM:SS), being the moment the graha itself crosses the horizon on the day its verdict changes. That instant, rather than sunrise or sunset, is what published Asta tables print.
    pub datetime: String,
    /// Horizon the event happens at. East means it is read before sunrise, so the graha is a morning object; west means after sunset, an evening object. A graha crosses to the other horizon as it passes the Sun, which is why an asta and the udaya that follows it are usually on opposite horizons.
    pub horizon: HeliacalResponseGrahasItemNextEventHorizon,
    /// The limit that was crossed. Can differ from the current reading limit for Mercury and Venus, whose limit tightens when they are retrograde, so an asta entered while retrograde may be left at a different threshold.
    pub kalamsa: f64,
    /// Separation from the Sun in degrees of time on the event day, measured the way the classical rule requires. Sits just either side of kalamsa, since that crossing is what defines the event.
    #[serde(rename = "timeDegrees")]
    pub time_degrees: f64,
    /// Udaya is heliacal rising, the graha re-emerging from the Sun rays and becoming visible again. Asta (also called lopa, moudhya or moudyami) is heliacal setting, the graha disappearing into them. Stable Sanskrit keys, never translated.
    pub r#type: HeliacalResponseGrahasItemNextEventType,
}
string_enum! {
    /// Udaya is heliacal rising, the graha re-emerging from the Sun rays and becoming visible again. Asta (also called lopa, moudhya or moudyami) is heliacal setting, the graha disappearing into them. Stable Sanskrit keys, never translated.
    HeliacalResponseGrahasItemNextEventType {
        Udaya = "udaya",
        Asta = "asta",
    }
}
string_enum! {
    /// Horizon the event happens at. East means it is read before sunrise, so the graha is a morning object; west means after sunset, an evening object. A graha crosses to the other horizon as it passes the Sun, which is why an asta and the udaya that follows it are usually on opposite horizons.
    HeliacalResponseGrahasItemNextEventHorizon {
        East = "east",
        West = "west",
    }
}
/// The event that produced the current state, or null when none falls inside the search horizon (up to about one synodic period, so Mars can legitimately have none).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct HeliacalResponseGrahasItemLastEvent {
    /// Local civil datetime of the event (YYYY-MM-DDTHH:MM:SS), being the moment the graha itself crosses the horizon on the day its verdict changes. That instant, rather than sunrise or sunset, is what published Asta tables print.
    pub datetime: String,
    /// Horizon the event happens at. East means it is read before sunrise, so the graha is a morning object; west means after sunset, an evening object. A graha crosses to the other horizon as it passes the Sun, which is why an asta and the udaya that follows it are usually on opposite horizons.
    pub horizon: HeliacalResponseGrahasItemLastEventHorizon,
    /// The limit that was crossed. Can differ from the current reading limit for Mercury and Venus, whose limit tightens when they are retrograde, so an asta entered while retrograde may be left at a different threshold.
    pub kalamsa: f64,
    /// Separation from the Sun in degrees of time on the event day, measured the way the classical rule requires. Sits just either side of kalamsa, since that crossing is what defines the event.
    #[serde(rename = "timeDegrees")]
    pub time_degrees: f64,
    /// Udaya is heliacal rising, the graha re-emerging from the Sun rays and becoming visible again. Asta (also called lopa, moudhya or moudyami) is heliacal setting, the graha disappearing into them. Stable Sanskrit keys, never translated.
    pub r#type: HeliacalResponseGrahasItemLastEventType,
}
string_enum! {
    /// Udaya is heliacal rising, the graha re-emerging from the Sun rays and becoming visible again. Asta (also called lopa, moudhya or moudyami) is heliacal setting, the graha disappearing into them. Stable Sanskrit keys, never translated.
    HeliacalResponseGrahasItemLastEventType {
        Udaya = "udaya",
        Asta = "asta",
    }
}
string_enum! {
    /// Horizon the event happens at. East means it is read before sunrise, so the graha is a morning object; west means after sunset, an evening object. A graha crosses to the other horizon as it passes the Sun, which is why an asta and the udaya that follows it are usually on opposite horizons.
    HeliacalResponseGrahasItemLastEventHorizon {
        East = "east",
        West = "west",
    }
}
string_enum! {
    /// Horizon this graha is currently judged at. West means it sets after the Sun and is an evening object, east that it rises before him and is a morning one.
    HeliacalResponseGrahasItemHorizon {
        East = "east",
        West = "west",
    }
}
/// Request body of `getHeliacalVisibility`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct HeliacalRequest {
    /// Local calendar date to judge, in YYYY-MM-DD format. There is deliberately no time field: heliacal visibility is a once-a-day verdict read at that day sunrise or sunset, so a clock time could only pick a different day.
    pub date: String,
    /// Observer latitude in decimal degrees, restricted to -60 to 60. Visibility depends on the observer, unlike the longitude orb every chart API reports, because the angle the ecliptic makes with the horizon decides how long a graha lingers after the Sun. Beyond this band the classical rule stops describing solar glare and starts describing polar horizon geometry, so it is declined rather than answered wrongly.
    pub latitude: f64,
    /// Observer longitude in decimal degrees. Sets local sunrise and sunset, which are the instants the verdict is read at. Example: Mumbai 72.8777, Delhi 77.2090, London -0.1278.
    pub longitude: f64,
    /// Timezone: IANA name (e.g. "Asia/Kolkata", "Europe/London") OR decimal hours from UTC. Fixes which local day the date refers to, and every datetime in the response is returned in it. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<HeliacalRequestTimezone>,
}
/// Timezone: IANA name (e.g. "Asia/Kolkata", "Europe/London") OR decimal hours from UTC. Fixes which local day the date refers to, and every datetime in the response is returned in it. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum HeliacalRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
/// Response body of `getZodiacSign`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetZodiacSignResponse {
    /// Greatest challenges and growth areas for this sign.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub challenges: Option<String>,
    /// Most compatible zodiac signs for this sign. Trine partners (same element, 120 degrees apart) listed first, followed by a sextile partner (complementary element, 60 degrees apart). Use for compatibility widgets, dating app onboarding, sign profile cards, and zodiac matchmaking.
    #[serde(rename = "compatibleSigns")]
    pub compatible_signs: Vec<String>,
    /// Tropical zodiac date range for this sign.
    pub dates: GetZodiacSignResponseDates,
    /// Sign description in short and long form.
    pub description: GetZodiacSignResponseDescription,
    /// Elemental classification: fire, earth, air, or water. Determines temperament and compatibility group. Always one of these four English literals, whatever the lang parameter says, so it stays safe to compare against in code. Use elementLocalized for anything a reader sees.
    pub element: GetZodiacSignResponseElement,
    /// Element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Notable people born under this zodiac sign.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub famous: Option<Vec<String>>,
    /// Greatest gifts and natural talents of this sign.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub gifts: Option<String>,
    /// Lowercase sign identifier.
    pub id: String,
    /// Key personality traits and descriptive words for this sign.
    pub keywords: Vec<String>,
    /// Quality/modality: cardinal (initiating), fixed (sustaining), or mutable (adapting). Always one of these three English literals, whatever the lang parameter says, so it stays safe to compare against in code. Use modalityLocalized for anything a reader sees.
    pub modality: GetZodiacSignResponseModality,
    /// Modality name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "modalityLocalized", skip_serializing_if = "Option::is_none")]
    pub modality_localized: Option<String>,
    /// Signature motto or tagline for this sign.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub motto: Option<String>,
    /// Display name of the zodiac sign.
    pub name: String,
    /// Traditional ruling planet that governs this sign. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use rulingPlanetLocalized for anything a reader sees.
    #[serde(rename = "rulingPlanet")]
    pub ruling_planet: String,
    /// Ruling planet name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "rulingPlanetLocalized", skip_serializing_if = "Option::is_none")]
    pub ruling_planet_localized: Option<String>,
    /// Key strengths and lovable qualities of this sign.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub strengths: Option<Vec<String>>,
    /// Unicode zodiac symbol.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub symbol: Option<String>,
    /// Symbol name or mascot associated with this sign.
    #[serde(rename = "symbolName")]
    pub symbol_name: String,
    /// Secret weapon or superpower of this sign.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub weapon: Option<String>,
}
string_enum! {
    /// Quality/modality: cardinal (initiating), fixed (sustaining), or mutable (adapting). Always one of these three English literals, whatever the lang parameter says, so it stays safe to compare against in code. Use modalityLocalized for anything a reader sees.
    GetZodiacSignResponseModality {
        Cardinal = "cardinal",
        Fixed = "fixed",
        Mutable = "mutable",
    }
}
string_enum! {
    /// Elemental classification: fire, earth, air, or water. Determines temperament and compatibility group. Always one of these four English literals, whatever the lang parameter says, so it stays safe to compare against in code. Use elementLocalized for anything a reader sees.
    GetZodiacSignResponseElement {
        Fire = "fire",
        Earth = "earth",
        Air = "air",
        Water = "water",
    }
}
/// Sign description in short and long form.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetZodiacSignResponseDescription {
    /// Detailed multi-paragraph sign profile with personality analysis.
    pub long: String,
    /// Brief 1-2 sentence personality overview.
    pub short: String,
}
/// Tropical zodiac date range for this sign.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetZodiacSignResponseDates {
    /// End date of this sign season.
    pub end: String,
    /// Start date of this sign season.
    pub start: String,
}
/// Path and query parameters of `getZodiacSign`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetZodiacSignParams {
    /// Sign ID (lowercase, e.g., aries, taurus) or display name (case-insensitive, e.g., Aries, TAURUS).
    pub id: String,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetZodiacSignParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetZodiacSignParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getZodiacCompatibility`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetZodiacCompatibilityResponse {
    /// The one thing worth doing differently, specific to this relation rather than generic relationship guidance.
    pub advice: String,
    /// Where the pair is most likely to grind, drawn from each sign own weaknesses. Difficult relations contribute from both signs; the rest from the first.
    pub frictions: Vec<String>,
    /// Which of the six classical branch relations the pair stands in. One of secret-friend (Liu He, the six harmonies), trine (San He, the three harmonies), same (both signs share a branch), neutral (no formal relation), harm (Liu Hai) or clash (Liu Chong, branches six apart). Exactly one applies to any pair, because no two of the conditions can hold at once. Always English so it stays safe to switch on.
    pub relationship: String,
    /// Classical name of the relation in traditional hanzi. Identical under every lang.
    #[serde(rename = "relationshipChinese")]
    pub relationship_chinese: String,
    /// Display name of the relation in English. Always English; use relationshipNameLocalized for anything a reader sees.
    #[serde(rename = "relationshipName")]
    pub relationship_name: String,
    /// Branch relation name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(
        rename = "relationshipNameLocalized",
        skip_serializing_if = "Option::is_none"
    )]
    pub relationship_name_localized: Option<String>,
    /// Tone-marked pinyin of the classical relation name.
    #[serde(rename = "relationshipPinyin")]
    pub relationship_pinyin: String,
    /// Compatibility score out of 100 for this relation. Fixed per relation rather than per pair, because the branch relation is what the tradition actually rates: 92 for a six-harmony pair, 85 for a trine, 65 for two of the same sign, 60 for no relation, 40 for a harm and 30 for a clash.
    pub score: f64,
    /// The Five Element phase the two branches combine into. Present only for a trine or a six-harmony pair, which are the two relations that combine; absent otherwise. This is generally neither animal own phase, which is the point of the combination.
    #[serde(rename = "sharedElement", skip_serializing_if = "Option::is_none")]
    pub shared_element: Option<String>,
    /// Five Element phase name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "sharedElementLocalized", skip_serializing_if = "Option::is_none")]
    pub shared_element_localized: Option<String>,
    /// The two signs compared, in the order they were requested. Always one object, never an array.
    pub signs: GetZodiacCompatibilityResponseSigns,
    /// What the pair has going for it, drawn from what each sign does well. Favourable relations contribute from both signs; the rest from the first.
    pub strengths: Vec<String>,
    /// Composed reading of the pair. The branch relation supplies the shape and the two temperaments supply the substance, so the reading is specific to this pair without being authored for it.
    pub summary: String,
    /// Coarse band the score falls in: excellent, strong, workable, challenging or difficult. Built for badges and filters that should not hard-code score thresholds.
    pub verdict: String,
}
/// The two signs compared, in the order they were requested. Always one object, never an array.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetZodiacCompatibilityResponseSigns {
    /// The `first` field.
    pub first: GetZodiacCompatibilityResponseSignsFirst,
    /// The `second` field.
    pub second: GetZodiacCompatibilityResponseSignsSecond,
}
/// The `second` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetZodiacCompatibilityResponseSignsSecond {
    /// Earthly Branch this animal names, as its pinyin identifier. The twelve branches are zi, chou, yin, mao, chen, si, wu, wei, shen, you, xu, hai, and they run in the same order as the animals. Every animal element, polarity and double-hour is a property of this branch.
    pub branch: String,
    /// Traditional hanzi character for the animal itself, not for its Earthly Branch. Data rather than a translation, so it is identical under every lang.
    pub chinese: String,
    /// Fixed Five Element (Wu Xing) phase of the animal own branch: Wood, Fire, Earth, Metal or Water. This never changes for a sign. It is NOT the year phase that makes a Metal Rat differ from a Water Rat, which comes from the year Heavenly Stem. Always English so it stays safe to compare against and to key colours off.
    pub element: String,
    /// Five Element phase name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Stable machine identifier for the animal. Always English and lowercase, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees. The twelve ids are rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, pig.
    pub id: String,
    /// Display name of the animal in English. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Animal name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone-marked Hanyu Pinyin for the animal name. Data rather than a translation, so it is identical under every lang.
    pub pinyin: String,
    /// Yin or yang polarity of the branch. The twelve branches alternate, starting yang at zi, so the six odd-numbered animals are yang and the six even-numbered are yin.
    pub polarity: String,
}
/// The `first` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetZodiacCompatibilityResponseSignsFirst {
    /// Earthly Branch this animal names, as its pinyin identifier. The twelve branches are zi, chou, yin, mao, chen, si, wu, wei, shen, you, xu, hai, and they run in the same order as the animals. Every animal element, polarity and double-hour is a property of this branch.
    pub branch: String,
    /// Traditional hanzi character for the animal itself, not for its Earthly Branch. Data rather than a translation, so it is identical under every lang.
    pub chinese: String,
    /// Fixed Five Element (Wu Xing) phase of the animal own branch: Wood, Fire, Earth, Metal or Water. This never changes for a sign. It is NOT the year phase that makes a Metal Rat differ from a Water Rat, which comes from the year Heavenly Stem. Always English so it stays safe to compare against and to key colours off.
    pub element: String,
    /// Five Element phase name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Stable machine identifier for the animal. Always English and lowercase, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees. The twelve ids are rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, pig.
    pub id: String,
    /// Display name of the animal in English. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Animal name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone-marked Hanyu Pinyin for the animal name. Data rather than a translation, so it is identical under every lang.
    pub pinyin: String,
    /// Yin or yang polarity of the branch. The twelve branches alternate, starting yang at zi, so the six odd-numbered animals are yang and the six even-numbered are yin.
    pub polarity: String,
}
/// Path and query parameters of `getZodiacCompatibility`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetZodiacCompatibilityParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetZodiacCompatibilityParamsLang>,
    /// First animal id, case-insensitive. One of rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, pig.
    pub sign1: GetZodiacCompatibilityParamsSign1,
    /// Second animal id, case-insensitive. The relation is symmetric, so swapping the two returns the same relationship and the same score, with the reading written from the first sign point of view.
    pub sign2: GetZodiacCompatibilityParamsSign2,
}
string_enum! {
    /// Second animal id, case-insensitive. The relation is symmetric, so swapping the two returns the same relationship and the same score, with the reading written from the first sign point of view.
    GetZodiacCompatibilityParamsSign2 {
        Rat = "rat",
        Ox = "ox",
        Tiger = "tiger",
        Rabbit = "rabbit",
        Dragon = "dragon",
        Snake = "snake",
        Horse = "horse",
        Goat = "goat",
        Monkey = "monkey",
        Rooster = "rooster",
        Dog = "dog",
        Pig = "pig",
    }
}
string_enum! {
    /// First animal id, case-insensitive. One of rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, pig.
    GetZodiacCompatibilityParamsSign1 {
        Rat = "rat",
        Ox = "ox",
        Tiger = "tiger",
        Rabbit = "rabbit",
        Dragon = "dragon",
        Snake = "snake",
        Horse = "horse",
        Goat = "goat",
        Monkey = "monkey",
        Rooster = "rooster",
        Dog = "dog",
        Pig = "pig",
    }
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetZodiacCompatibilityParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getZodiacAnimal`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetZodiacAnimalResponse {
    /// Earthly Branch this animal names, as its pinyin identifier. The twelve branches are zi, chou, yin, mao, chen, si, wu, wei, shen, you, xu, hai, and they run in the same order as the animals. Every animal element, polarity and double-hour is a property of this branch.
    pub branch: String,
    /// Traditional hanzi character for the animal itself, not for its Earthly Branch. Data rather than a translation, so it is identical under every lang.
    pub chinese: String,
    /// The clashing animal (Liu Chong): the branch directly opposite, six positions away. The tradition reads this as the most charged pairing in the cycle and the least restful.
    #[serde(rename = "clashPartner")]
    pub clash_partner: GetZodiacAnimalResponseClashPartner,
    /// How the sign behaves toward the other eleven in general. For a specific pair, call /zodiac/compatibility/{sign1}/{sign2}.
    #[serde(rename = "compatibilitySummary")]
    pub compatibility_summary: String,
    /// Fixed Five Element (Wu Xing) phase of the animal own branch: Wood, Fire, Earth, Metal or Water. This never changes for a sign. It is NOT the year phase that makes a Metal Rat differ from a Water Rat, which comes from the year Heavenly Stem. Always English so it stays safe to compare against and to key colours off.
    pub element: String,
    /// Five Element phase name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// The five phase variants of this sign across the sixty-year cycle, listed over 1924 to 2043. Exactly five, always, because a branch pairs only with the five Heavenly Stems of its own polarity and those five carry one phase each. A year number here names the sexagenary year, not a calendar range: a birth in January or early February may still belong to the previous year, which is what /zodiac/sign resolves.
    #[serde(rename = "elementVariants")]
    pub element_variants: Vec<GetZodiacAnimalResponseElementVariantsItem>,
    /// The harming animal (Liu Hai). Treated as less violent than a clash and harder to spot, because it works through accumulation rather than confrontation.
    #[serde(rename = "harmPartner")]
    pub harm_partner: GetZodiacAnimalResponseHarmPartner,
    /// The two-hour period of the day this animal branch governs. Used for the hour pillar in a Four Pillars chart, which is always read on local time.
    pub hours: GetZodiacAnimalResponseHours,
    /// Stable machine identifier for the animal. Always English and lowercase, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees. The twelve ids are rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, pig.
    pub id: String,
    /// Display name of the animal in English. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Animal name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone-marked Hanyu Pinyin for the animal name. Data rather than a translation, so it is identical under every lang.
    pub pinyin: String,
    /// Yin or yang polarity of the branch. The twelve branches alternate, starting yang at zi, so the six odd-numbered animals are yang and the six even-numbered are yin.
    pub polarity: String,
    /// The six-harmony partner (Liu He), traditionally called the secret friend because the support it gives arrives unasked. The element is the phase the two branches combine into, which is generally neither animal own phase.
    #[serde(rename = "secretFriend")]
    pub secret_friend: GetZodiacAnimalResponseSecretFriend,
    /// What the sign does well, as full sentences rather than keywords.
    pub strengths: Vec<String>,
    /// Character sketch of the sign, drawn from the season, the double-hour and the phase its branch occupies.
    pub summary: String,
    /// Short trait keywords for the sign, lowercase in English. Built for tag clouds, sign cards and compatibility widgets that need a glanceable character sketch rather than a paragraph.
    pub traits: Vec<String>,
    /// The three-harmony group (San He) this animal belongs to. Every animal belongs to exactly one.
    pub trine: GetZodiacAnimalResponseTrine,
    /// Where the same temperament costs the sign something. Each one is the shadow of a strength above rather than an unrelated flaw.
    pub weaknesses: Vec<String>,
}
/// The three-harmony group (San He) this animal belongs to. Every animal belongs to exactly one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetZodiacAnimalResponseTrine {
    /// The three Earthly Branches of the trine in classical notation, in the order the texts give them.
    pub chinese: String,
    /// Fixed Five Element (Wu Xing) phase of the animal own branch: Wood, Fire, Earth, Metal or Water. This never changes for a sign. It is NOT the year phase that makes a Metal Rat differ from a Water Rat, which comes from the year Heavenly Stem. Always English so it stays safe to compare against and to key colours off.
    pub element: String,
    /// Five Element phase name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Machine id of the trine: first, second, third or fourth. Always English.
    pub id: String,
    /// The three animal ids in this trine, including the one requested. Members sit four branches apart, so the four trines partition all twelve animals with none shared and none left over.
    pub members: Vec<String>,
    /// Position of the trine in the order the tradition lists them, 1 to 4. Not a ranking.
    pub number: f64,
    /// Tone-marked pinyin of the three branches.
    pub pinyin: String,
    /// What the alliance is traditionally said to produce. The three branches combine into the element above, which is not any one member own phase.
    pub theme: String,
}
/// The six-harmony partner (Liu He), traditionally called the secret friend because the support it gives arrives unasked. The element is the phase the two branches combine into, which is generally neither animal own phase.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetZodiacAnimalResponseSecretFriend {
    /// Traditional hanzi character for the related animal.
    pub chinese: String,
    /// Fixed Five Element (Wu Xing) phase of the animal own branch: Wood, Fire, Earth, Metal or Water. This never changes for a sign. It is NOT the year phase that makes a Metal Rat differ from a Water Rat, which comes from the year Heavenly Stem. Always English so it stays safe to compare against and to key colours off.
    pub element: String,
    /// Five Element phase name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Stable machine identifier for the animal. Always English and lowercase, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees. The twelve ids are rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, pig.
    pub id: String,
    /// Display name of the related animal in English. Always English; use nameLocalized for display.
    pub name: String,
    /// Animal name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone-marked pinyin for the related animal.
    pub pinyin: String,
}
/// The two-hour period of the day this animal branch governs. Used for the hour pillar in a Four Pillars chart, which is always read on local time.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetZodiacAnimalResponseHours {
    /// Hour the double-hour ends, exclusive, on a 24-hour local clock. Each branch governs exactly two hours.
    pub end: f64,
    /// First hour of the double-hour this branch governs, on a 24-hour local clock. The zi branch starts at 23, so the cycle begins the evening before midnight.
    pub start: f64,
}
/// The harming animal (Liu Hai). Treated as less violent than a clash and harder to spot, because it works through accumulation rather than confrontation.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetZodiacAnimalResponseHarmPartner {
    /// Traditional hanzi character for the related animal.
    pub chinese: String,
    /// Stable machine identifier for the animal. Always English and lowercase, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees. The twelve ids are rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, pig.
    pub id: String,
    /// Display name of the related animal in English. Always English; use nameLocalized for display.
    pub name: String,
    /// Animal name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone-marked pinyin for the related animal.
    pub pinyin: String,
}
/// One entry of `elementVariants`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetZodiacAnimalResponseElementVariantsItem {
    /// Fixed Five Element (Wu Xing) phase of the animal own branch: Wood, Fire, Earth, Metal or Water. This never changes for a sign. It is NOT the year phase that makes a Metal Rat differ from a Water Rat, which comes from the year Heavenly Stem. Always English so it stays safe to compare against and to key colours off.
    pub element: String,
    /// Five Element phase name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Sexagenary pillar id for this variant, stem then branch. This pair returns once every sixty years.
    pub pillar: String,
    /// Yin or yang polarity of the branch. The twelve branches alternate, starting yang at zi, so the six odd-numbered animals are yang and the six even-numbered are yin.
    pub polarity: String,
    /// Heavenly Stem of the year, as its pinyin identifier. The ten stems are jia, yi, bing, ding, wu, ji, geng, xin, ren, gui.
    pub stem: String,
    /// Gregorian years in the published window that carry this variant. Two per variant, sixty years apart.
    pub years: Vec<f64>,
}
/// The clashing animal (Liu Chong): the branch directly opposite, six positions away. The tradition reads this as the most charged pairing in the cycle and the least restful.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetZodiacAnimalResponseClashPartner {
    /// Traditional hanzi character for the related animal.
    pub chinese: String,
    /// Stable machine identifier for the animal. Always English and lowercase, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees. The twelve ids are rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, pig.
    pub id: String,
    /// Display name of the related animal in English. Always English; use nameLocalized for display.
    pub name: String,
    /// Animal name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone-marked pinyin for the related animal.
    pub pinyin: String,
}
/// Path and query parameters of `getZodiacAnimal`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetZodiacAnimalParams {
    /// Animal id, case-insensitive and punctuation-insensitive. One of rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, pig. The sheep and the ram are the same animal as the goat and resolve to goat.
    pub id: GetZodiacAnimalParamsId,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetZodiacAnimalParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetZodiacAnimalParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Animal id, case-insensitive and punctuation-insensitive. One of rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, pig. The sheep and the ram are the same animal as the goat and resolve to goat.
    GetZodiacAnimalParamsId {
        Rat = "rat",
        Ox = "ox",
        Tiger = "tiger",
        Rabbit = "rabbit",
        Dragon = "dragon",
        Snake = "snake",
        Horse = "horse",
        Goat = "goat",
        Monkey = "monkey",
        Rooster = "rooster",
        Dog = "dog",
        Pig = "pig",
    }
}
/// Path and query parameters of `getYoga`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetYogaParams {
    /// Yoga identifier (lowercase, hyphenated)
    pub id: GetYogaParamsId,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetYogaParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetYogaParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Yoga identifier (lowercase, hyphenated)
    GetYogaParamsId {
        Gajakesari = "gajakesari",
        Sunapha = "sunapha",
        Anapha = "anapha",
        Dhurdhura = "dhurdhura",
        Kemadruma = "kemadruma",
        Chandramangala = "chandramangala",
        Adhi = "adhi",
        Chatussagara = "chatussagara",
        Vasumathi = "vasumathi",
        Rajalakshana = "rajalakshana",
        Vanchanachorabheethi = "vanchanachorabheethi",
        Sakata = "sakata",
        Amala = "amala",
        Parvata = "parvata",
        Kahala = "kahala",
        Vesi = "vesi",
        Vasi = "vasi",
        Obhayachari = "obhayachari",
        Hamsa = "hamsa",
        Malavya = "malavya",
        Sasa = "sasa",
        Ruchaka = "ruchaka",
        Bhadra = "bhadra",
        Budhaaditya = "budhaaditya",
        Mahabhagya = "mahabhagya",
        Pushkala = "pushkala",
        Lakshmi = "lakshmi",
        Gauri = "gauri",
        Bharathi = "bharathi",
        Chapa = "chapa",
        Sreenatha = "sreenatha",
        Lagnamalika = "lagnamalika",
        Dhanamalika = "dhanamalika",
        Vikramamalika = "vikramamalika",
        Sukhamalika = "sukhamalika",
        Putramalika = "putramalika",
        Satrumalika = "satrumalika",
        Kalatramalika = "kalatramalika",
        Randhramalika = "randhramalika",
        Bhagyamalika = "bhagyamalika",
        Karmamalika = "karmamalika",
        Labhamalika = "labhamalika",
        Vrayamalika = "vrayamalika",
        Sankha = "sankha",
        Bheri = "bheri",
        Mridanga = "mridanga",
        Parijatha = "parijatha",
        Gaja = "gaja",
        Kalanidhi = "kalanidhi",
        Amsavatara = "amsavatara",
        Hariharabrahma = "hariharabrahma",
        Kusuma = "kusuma",
        Matsya = "matsya",
        Kurma = "kurma",
        Devendra = "devendra",
        Makuta = "makuta",
        Chandika = "chandika",
        Jaya = "jaya",
        Vidyut = "vidyut",
        Gandharva = "gandharva",
        Siva = "siva",
        Vishnu = "vishnu",
        Brahma = "brahma",
        Indra = "indra",
        Ravi = "ravi",
        Garuda = "garuda",
        Go = "go",
        Gola = "gola",
        Thrilochana = "thrilochana",
        Kulavardhana = "kulavardhana",
        Yupa = "yupa",
        Ishu = "ishu",
        Sakti = "sakti",
        Danda = "danda",
        Nav = "nav",
        Kuta = "kuta",
        Chhatra = "chhatra",
        Chapa2 = "chapa-2",
        Ardhachandra = "ardhachandra",
        Chandra = "chandra",
        Gada = "gada",
        Sakata2 = "sakata-2",
        Vihaga = "vihaga",
        Vajra = "vajra",
        Yava = "yava",
        Sringhataka = "sringhataka",
        Hala = "hala",
        Kamala = "kamala",
        Vapee = "vapee",
        Samudra = "samudra",
        Vallaki = "vallaki",
        Damni = "damni",
        Pasa = "pasa",
        Kedara = "kedara",
        Sula = "sula",
        Yuga = "yuga",
        Gola2 = "gola-2",
        Rajju = "rajju",
        Musala = "musala",
        Nala = "nala",
        Srik = "srik",
        Mala = "mala",
        Sarpa = "sarpa",
        Duryoga = "duryoga",
        Daridra = "daridra",
        Harsha = "harsha",
        Sarala = "sarala",
        Vimala = "vimala",
        Sareerasoukhya = "sareerasoukhya",
        Dehapushti = "dehapushti",
        Dehakashta = "dehakashta",
        Rogagrastha = "rogagrastha",
        Krisanga = "krisanga",
        Krisanga2 = "krisanga-2",
        Dehasthoulya = "dehasthoulya",
        Dehasthoulya2 = "dehasthoulya-2",
        Dehasthoulya3 = "dehasthoulya-3",
        Sadasanchara = "sadasanchara",
        Dhana = "dhana",
        Dhana2 = "dhana-2",
        Dhana3 = "dhana-3",
        Dhana4 = "dhana-4",
        Dhana5 = "dhana-5",
        Dhana6 = "dhana-6",
        Dhana7 = "dhana-7",
        Dhana8 = "dhana-8",
        Dhana9 = "dhana-9",
        Dhana10 = "dhana-10",
        Dhana11 = "dhana-11",
        Bahudravyarjana = "bahudravyarjana",
        Swaveeryaddhana = "swaveeryaddhana",
        Swaveeryaddhana2 = "swaveeryaddhana-2",
        Swaveeryaddhana3 = "swaveeryaddhana-3",
        Madhyavayasidhana = "madhyavayasidhana",
        Anthyavayasidhana = "anthyavayasidhana",
        Balyadhana = "balyadhana",
        Bhratrumooladdhanaprapti = "bhratrumooladdhanaprapti",
        Bhratrumooladdhanaprapti2 = "bhratrumooladdhanaprapti-2",
        Matrumooladdhana = "matrumooladdhana",
        Putramooladdhana = "putramooladdhana",
        Satrumooladdhana = "satrumooladdhana",
        Kalatramooladdhana = "kalatramooladdhana",
        Amarananthadhana = "amarananthadhana",
        Ayatnadhanalabha = "ayatnadhanalabha",
        Daridra2 = "daridra-2",
        Daridra3 = "daridra-3",
        Daridra4 = "daridra-4",
        Daridra5 = "daridra-5",
        Daridra6 = "daridra-6",
        Daridra7 = "daridra-7",
        Daridra8 = "daridra-8",
        Daridra9 = "daridra-9",
        Daridra10 = "daridra-10",
        Daridra11 = "daridra-11",
        Yukthisamanwithavagmi = "yukthisamanwithavagmi",
        Yukthisamanwithavagmi2 = "yukthisamanwithavagmi-2",
        Parihasaka = "parihasaka",
        Asatyavadi = "asatyavadi",
        Jada = "jada",
        Bhaskara = "bhaskara",
        Marud = "marud",
        Saraswathi = "saraswathi",
        Budha = "budha",
        Mooka = "mooka",
        Netranasa = "netranasa",
        Andha = "andha",
        Sumukha = "sumukha",
        Sumukha2 = "sumukha-2",
        Durmukha = "durmukha",
        Durmukha2 = "durmukha-2",
        Bhojanasoukhya = "bhojanasoukhya",
        Annadana = "annadana",
        Parannabhojana = "parannabhojana",
        Sraddhannabhuktha = "sraddhannabhuktha",
        Sarpaganda = "sarpaganda",
        Vakchalana = "vakchalana",
        Vishaprayoga = "vishaprayoga",
        Bhratruvriddhi = "bhratruvriddhi",
        Sodaranasa = "sodaranasa",
        Ekabhagini = "ekabhagini",
        Dwadasasahodara = "dwadasasahodara",
        Sapthasankhyasahodara = "sapthasankhyasahodara",
        Parakrama = "parakrama",
        Yuddhapraveena = "yuddhapraveena",
        Yuddhatpoorvadridhachitta = "yuddhatpoorvadridhachitta",
        Yuddhatpaschaddrudha = "yuddhatpaschaddrudha",
        Satkathadisravana = "satkathadisravana",
        Uttamagriha = "uttamagriha",
        Vichitrasaudhaprakara = "vichitrasaudhaprakara",
        Ayatnagrihaprapta = "ayatnagrihaprapta",
        Ayatnagrihaprapta2 = "ayatnagrihaprapta-2",
        Grihanasa = "grihanasa",
        Grihanasa2 = "grihanasa-2",
        Bandhupujya = "bandhupujya",
        Bandhupujya2 = "bandhupujya-2",
        Bandhubhisthyaktha = "bandhubhisthyaktha",
        Matrudeerghayur = "matrudeerghayur",
        Matrudeerghayur2 = "matrudeerghayur-2",
        Matrunasa = "matrunasa",
        Matrunasa2 = "matrunasa-2",
        Matrugami = "matrugami",
        Sahodareesangama = "sahodareesangama",
        Kapata = "kapata",
        Kapata2 = "kapata-2",
        Kapata3 = "kapata-3",
        Nishkapata = "nishkapata",
        Nishkapata2 = "nishkapata-2",
        Matrusatrutwa = "matrusatrutwa",
        Matrusneha = "matrusneha",
        Vahana = "vahana",
        Vahana2 = "vahana-2",
        Anapathya = "anapathya",
        Sarpasapa = "sarpasapa",
        Sarpasapa2 = "sarpasapa-2",
        Sarpasapa3 = "sarpasapa-3",
        Sarpasapa4 = "sarpasapa-4",
        Pitrusapasutakshaya = "pitrusapasutakshaya",
        Matrusapasutakshaya = "matrusapasutakshaya",
        Bhratrusapasutakshaya = "bhratrusapasutakshaya",
        Pretasapa = "pretasapa",
        Bahuputra = "bahuputra",
        Bahuputra2 = "bahuputra-2",
        Dattaputra = "dattaputra",
        Dattaputra2 = "dattaputra-2",
        Aputra = "aputra",
        Ekaputra = "ekaputra",
        Suputra = "suputra",
        Kalanirdesatputra = "kalanirdesatputra",
        Kalanirdesatputra2 = "kalanirdesatputra-2",
        Kalanirdesatputranasa = "kalanirdesatputranasa",
        Kalanirdesatputranasa2 = "kalanirdesatputranasa-2",
        Buddhimaturya = "buddhimaturya",
        Theevrabuddhi = "theevrabuddhi",
        Buddhijada = "buddhijada",
        Thrikalagnana = "thrikalagnana",
        Putrasukha = "putrasukha",
        Jara = "jara",
        Jarajaputra = "jarajaputra",
        Bahustree = "bahustree",
        Satkalatra = "satkalatra",
        Bhagachumbana = "bhagachumbana",
        Bhagya = "bhagya",
        Jananatpurvampitrumarana = "jananatpurvampitrumarana",
        Dhatrutwa = "dhatrutwa",
        Apakeerti = "apakeerti",
        Raja = "raja",
        Raja2 = "raja-2",
        Raja3 = "raja-3",
        Raja4 = "raja-4",
        Raja5 = "raja-5",
        Raja6 = "raja-6",
        Raja7 = "raja-7",
        Raja8 = "raja-8",
        Raja9 = "raja-9",
        Raja10 = "raja-10",
        Raja11 = "raja-11",
        Raja12 = "raja-12",
        Raja13 = "raja-13",
        Raja14 = "raja-14",
        Raja15 = "raja-15",
        Raja16 = "raja-16",
        Raja17 = "raja-17",
        Raja18 = "raja-18",
        Raja19 = "raja-19",
        Galakarna = "galakarna",
        Vrana = "vrana",
        Sisnavyadhi = "sisnavyadhi",
        Kalatrashanda = "kalatrashanda",
        Kushtaroga = "kushtaroga",
        Kushtaroga2 = "kushtaroga-2",
        Kshayaroga = "kshayaroga",
        Bandhana = "bandhana",
        Karascheda = "karascheda",
        Sirachcheda = "sirachcheda",
        Durmarana = "durmarana",
        Yuddhemarana = "yuddhemarana",
        Sanghatakamarana = "sanghatakamarana",
        Sanghatakamarana2 = "sanghatakamarana-2",
        Peenasaroga = "peenasaroga",
        Pittaroga = "pittaroga",
        Vikalangapatni = "vikalangapatni",
        Putrakalatraheena = "putrakalatraheena",
        Bharyasahavyabhichara = "bharyasahavyabhichara",
        Vamsacheda = "vamsacheda",
        Guhyaroga = "guhyaroga",
        Angaheena = "angaheena",
        Swetakushta = "swetakushta",
        Pisachagrastha = "pisachagrastha",
        Andha2 = "andha-2",
        Andha3 = "andha-3",
        Vatharoga = "vatharoga",
        Matibhramana = "matibhramana",
        Matibhramana2 = "matibhramana-2",
        Matibhramana3 = "matibhramana-3",
        Matibhramana4 = "matibhramana-4",
        Khalwata = "khalwata",
        Nishturabhashi = "nishturabhashi",
        Rajabhrashta = "rajabhrashta",
        Raja20 = "raja-20",
        Raja21 = "raja-21",
        Gohanta = "gohanta",
    }
}
/// Response body of `getYearlyHoroscope`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetYearlyHoroscopeResponse {
    /// The single actionable takeaway from the leading event of the period, read into the whole-sign houses of this sign and checkable against the events array. Drawn from the same event as overview, kept to a short, actionable pair of sentences rather than grown to match the other sections. Deterministic: the same sign and period always returns the same text.
    pub advice: String,
    /// The easiest month of the year for each of the four topic sections, by how many exact harmonious aspects (sextiles and trines) fall in that month and land in the houses that govern the area for this sign. An area is omitted only in the rare year that carries no harmonious aspect for it at all, so treat each key as optional. Use it for the best-months-for panel, and read the count as the evidence behind the word best.
    #[serde(rename = "bestPeriods")]
    pub best_periods: GetYearlyHoroscopeResponseBestPeriods,
    /// Yearly career and professional outlook, read into the whole-sign houses of this sign. The same ranked events that drive column, filtered to career, work and reputation, plus the standing placements that reach it. Every event named here is in the events array, so a piece can be fact-checked before it runs; this section reads an event through whichever of its houses carries career, work and reputation, which for an aspect between two houses can be the other one from the house the events array leads with, and both are whole-sign houses of the bodies involved counted from this sign. Typically 150 to 260 words. Render it alone for a single-topic page, or alongside the other five sections for a general reading; column is the same material woven into one piece instead of split by topic. Deterministic: the same sign and period always returns the same text.
    pub career: String,
    /// The full column for this period, ready to run as one piece, with paragraphs separated by a blank line. Names the events driving it and the dates they fall on, read into the whole-sign houses of this sign. Typically 600 to 900 words. The six section fields read the same ranked events filtered to their own life area, each composed as a column of its own rather than an excerpt of this one, so render either shape and never both. Deterministic: the same sign and period always returns the same column.
    pub column: String,
    /// Most compatible zodiac signs for this sign. Trine partners (same element) followed by a sextile partner (complementary element).
    #[serde(rename = "compatibleSigns")]
    pub compatible_signs: Vec<String>,
    /// Every solar and lunar eclipse of the year, with the house each one falls in for this sign. Usually four to six, and the dates match the published eclipse canon.
    pub eclipses: Vec<GetYearlyHoroscopeResponseEclipsesItem>,
    /// The dated astronomical events this reading is built on, earliest first. Every field in every row can be checked against an independent authority, so a column can be fact-checked before it is published. Empty on a period in which nothing exact happens, where the reading falls back to the standing positions instead.
    pub events: Vec<GetYearlyHoroscopeResponseEventsItem>,
    /// Yearly financial outlook, read into the whole-sign houses of this sign. The same ranked events that drive column, filtered to finance, plus the standing placements that reach it. Every event named here is in the events array, so a piece can be fact-checked before it runs; this section reads an event through whichever of its houses carries finance, which for an aspect between two houses can be the other one from the house the events array leads with, and both are whole-sign houses of the bodies involved counted from this sign. Typically 150 to 260 words. Render it alone for a single-topic page, or alongside the other five sections for a general reading; column is the same material woven into one piece instead of split by topic. Deterministic: the same sign and period always returns the same text.
    pub finance: String,
    /// Yearly health, energy, and wellness outlook, read into the whole-sign houses of this sign. The same ranked events that drive column, filtered to health, plus the standing placements that reach it. Every event named here is in the events array, so a piece can be fact-checked before it runs; this section reads an event through whichever of its houses carries health, which for an aspect between two houses can be the other one from the house the events array leads with, and both are whole-sign houses of the bodies involved counted from this sign. Typically 150 to 260 words. Render it alone for a single-topic page, or alongside the other five sections for a general reading; column is the same material woven into one piece instead of split by topic. Deterministic: the same sign and period always returns the same text.
    pub health: String,
    /// The year as a calendar of life areas: for each whole-sign house, the single dated stretch that most strongly activates it, ordered by start date. Twelve rows in a full year, one per house, so every life area gets a date range and none is named twice. Periods overlap freely, because more than one body is always moving. Use it for the dates-to-circle panel of a year-ahead page.
    #[serde(rename = "keyPeriods")]
    pub key_periods: Vec<GetYearlyHoroscopeResponseKeyPeriodsItem>,
    /// Yearly love and relationship outlook, read into the whole-sign houses of this sign. The same ranked events that drive column, filtered to romance and partnership, plus the standing placements that reach it. Every event named here is in the events array, so a piece can be fact-checked before it runs; this section reads an event through whichever of its houses carries romance and partnership, which for an aspect between two houses can be the other one from the house the events array leads with, and both are whole-sign houses of the bodies involved counted from this sign. Typically 150 to 260 words. Render it alone for a single-topic page, or alongside the other five sections for a general reading; column is the same material woven into one piece instead of split by topic. Deterministic: the same sign and period always returns the same text.
    pub love: String,
    /// Lucky color for the year, drawn from the three colors of the sign element and selected by the planet governing the reading.
    #[serde(rename = "luckyColor")]
    pub lucky_color: String,
    /// Four lucky numbers for the year, each 1 to 9 and all distinct, from the traditional planetary number correspondence applied to the four planets that govern this sign this year.
    #[serde(rename = "luckyNumbers")]
    pub lucky_numbers: Vec<f64>,
    /// The single most relevant event of the period, whichever life area it touches, read into the whole-sign houses of this sign. The same event that leads column, at lede length rather than developed into a full movement, and checkable against the events array. Typically 70 to 120 words. Join it with love, career, health and finance for a general reading built from the six sections. Deterministic: the same sign and period always returns the same text.
    pub overview: String,
    /// Every retrograde and direct station of the year, in order, with the house each falls in for this sign. Drives review windows and the not-yet warnings a yearly column is bought for.
    pub retrogrades: Vec<GetYearlyHoroscopeResponseRetrogradesItem>,
    /// Zodiac sign for this horoscope.
    pub sign: String,
    /// The backdrop of the year: which whole-sign house each slow-moving body occupies for this sign, Jupiter first and Pluto last. One row per unbroken stretch, so a body that stays put is a single row spanning the year and a body that changes sign is two rows with the exact date between them. Dates are the part of the stretch that falls inside this year; the full span of a change that happens inside the year is in the events array. Use it for the year-at-a-glance panel a year-ahead page opens with.
    pub themes: Vec<GetYearlyHoroscopeResponseThemesItem>,
    /// Calendar year this forecast covers. Echoes the year requested, or the current year when it was omitted.
    pub year: i64,
}
/// One entry of `themes`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetYearlyHoroscopeResponseThemesItem {
    /// The slow-moving body holding this theme, canonical English regardless of the requested language: Jupiter, Saturn, Uranus, Neptune, or Pluto.
    pub body: String,
    /// First date of the stretch inside this year, in UTC (YYYY-MM-DD). January 1 when the body was already there when the year opened, otherwise the date it arrived.
    pub from: String,
    /// Whole-sign house that sign is for this sign, 1 to 12.
    pub house: i64,
    /// Sign the body occupies through this stretch, lowercase. Checkable against NASA JPL Horizons for any date inside from and to.
    pub sign: String,
    /// What that house governs, so the placement reads as a life area rather than a coordinate.
    pub theme: String,
    /// Last date of the stretch inside this year, in UTC (YYYY-MM-DD). December 31 when the body is still there when the year closes, otherwise the date it leaves.
    pub to: String,
}
/// One entry of `retrogrades`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetYearlyHoroscopeResponseRetrogradesItem {
    /// Body making the station, canonical English.
    pub body: String,
    /// Date the body turns, in UTC (YYYY-MM-DD). The exact instant is in the events array.
    pub date: String,
    /// Which way it turns: retrograde when apparent motion reverses, direct when it resumes.
    pub direction: String,
    /// Whole-sign house the station falls in for this sign, 1 to 12.
    pub house: i64,
    /// What that house governs, so the station reads as a life area rather than a coordinate.
    pub theme: String,
}
/// One entry of `keyPeriods`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetYearlyHoroscopeResponseKeyPeriodsItem {
    /// Body driving the period, canonical English regardless of the requested language: Mercury, Venus, or Mars. The slower bodies are in the themes array instead, because a stretch measured in years is a backdrop rather than a date to circle.
    pub body: String,
    /// The life area that period is about, from the house it activates.
    pub focus: String,
    /// Date the period opens, in UTC (YYYY-MM-DD). Always inside the year requested: this is the day the body enters the sign.
    pub from: String,
    /// Whole-sign house the period activates for this sign, 1 to 12. Unique within the array: each house appears at most once.
    pub house: i64,
    /// Date the period closes, in UTC (YYYY-MM-DD), which is the day the body leaves that sign. A period that opens late in the year closes in the next one, by at most about three months, so a reader knows what they are still in on January 1.
    pub to: String,
}
/// One entry of `events`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetYearlyHoroscopeResponseEventsItem {
    /// Angle formed, on aspect events only: conjunction, sextile, square, trine, opposition, semi-sextile, quincunx, semi-square, or sesquiquadrate.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub aspect: Option<String>,
    /// Exact instant the event perfects, UTC, to the second. Verifiable against NASA JPL Horizons for a position event and against the US Naval Observatory for a lunar phase or eclipse.
    pub at: String,
    /// Bodies involved, canonical English regardless of the requested language so the value stays safe to switch on. Two entries for an aspect, faster body first. One entry for an ingress, a station, a lunar phase, or an eclipse.
    pub bodies: Vec<String>,
    /// Whole-sign house the event falls in, counted from the queried sign, 1 to 12. This is what turns one global sky event into a statement about this reader.
    pub house: i64,
    /// Sign the event falls in, lowercase, where it has exactly one. Absent for an aspect whose two bodies stand in different signs.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sign: Option<String>,
    /// End of the window this event holds open, UTC, given only where a bounded window is a real fact about it: the orb span of an aspect, the sign span of an ingress or a season, the retrograde span of a station. Absent for a lunar phase or an eclipse, which are instants and not spans.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub through: Option<String>,
    /// Kind of event. aspect is an exact angle between two moving bodies, sign-ingress a body entering a new sign, retrograde-station a body turning retrograde or direct, lunar-phase one of the four quarters, eclipse a solar or lunar eclipse, and solar-season the Sun entering a sign.
    pub r#type: GetYearlyHoroscopeResponseEventsItemType,
}
string_enum! {
    /// Kind of event. aspect is an exact angle between two moving bodies, sign-ingress a body entering a new sign, retrograde-station a body turning retrograde or direct, lunar-phase one of the four quarters, eclipse a solar or lunar eclipse, and solar-season the Sun entering a sign.
    GetYearlyHoroscopeResponseEventsItemType {
        Aspect = "aspect",
        SignIngress = "sign-ingress",
        RetrogradeStation = "retrograde-station",
        LunarPhase = "lunar-phase",
        Eclipse = "eclipse",
        SolarSeason = "solar-season",
    }
}
/// One entry of `eclipses`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetYearlyHoroscopeResponseEclipsesItem {
    /// Date of the eclipse peak in UTC (YYYY-MM-DD). The exact instant is in the events array.
    pub date: String,
    /// Whole-sign house the eclipse falls in for this sign, 1 to 12.
    pub house: i64,
    /// Eclipse kind: total, annular, partial, or penumbral.
    pub kind: String,
    /// What that house governs, so the eclipse reads as a life area rather than a coordinate.
    pub theme: String,
}
/// The easiest month of the year for each of the four topic sections, by how many exact harmonious aspects (sextiles and trines) fall in that month and land in the houses that govern the area for this sign. An area is omitted only in the rare year that carries no harmonious aspect for it at all, so treat each key as optional. Use it for the best-months-for panel, and read the count as the evidence behind the word best.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetYearlyHoroscopeResponseBestPeriods {
    /// Best month for career, work and reputation. Absent only if the whole year carries no harmonious aspect reaching this area.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub career: Option<GetYearlyHoroscopeResponseBestPeriodsCareer>,
    /// Best month for finance. Absent only if the whole year carries no harmonious aspect reaching this area.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub finance: Option<GetYearlyHoroscopeResponseBestPeriodsFinance>,
    /// Best month for health. Absent only if the whole year carries no harmonious aspect reaching this area.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub health: Option<GetYearlyHoroscopeResponseBestPeriodsHealth>,
    /// Best month for romance and partnership. Absent only if the whole year carries no harmonious aspect reaching this area.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub love: Option<GetYearlyHoroscopeResponseBestPeriodsLove>,
}
/// Best month for romance and partnership. Absent only if the whole year carries no harmonious aspect reaching this area.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetYearlyHoroscopeResponseBestPeriodsLove {
    /// How many exact harmonious aspects fell in that month and reached this area. This is the measurement the month was chosen on, and every aspect behind it can be checked against NASA JPL Horizons.
    pub count: i64,
    /// First day of the month, in UTC (YYYY-MM-DD).
    pub from: String,
    /// Last day of the month, in UTC (YYYY-MM-DD).
    pub to: String,
}
/// Best month for health. Absent only if the whole year carries no harmonious aspect reaching this area.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetYearlyHoroscopeResponseBestPeriodsHealth {
    /// How many exact harmonious aspects fell in that month and reached this area. This is the measurement the month was chosen on, and every aspect behind it can be checked against NASA JPL Horizons.
    pub count: i64,
    /// First day of the month, in UTC (YYYY-MM-DD).
    pub from: String,
    /// Last day of the month, in UTC (YYYY-MM-DD).
    pub to: String,
}
/// Best month for finance. Absent only if the whole year carries no harmonious aspect reaching this area.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetYearlyHoroscopeResponseBestPeriodsFinance {
    /// How many exact harmonious aspects fell in that month and reached this area. This is the measurement the month was chosen on, and every aspect behind it can be checked against NASA JPL Horizons.
    pub count: i64,
    /// First day of the month, in UTC (YYYY-MM-DD).
    pub from: String,
    /// Last day of the month, in UTC (YYYY-MM-DD).
    pub to: String,
}
/// Best month for career, work and reputation. Absent only if the whole year carries no harmonious aspect reaching this area.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetYearlyHoroscopeResponseBestPeriodsCareer {
    /// How many exact harmonious aspects fell in that month and reached this area. This is the measurement the month was chosen on, and every aspect behind it can be checked against NASA JPL Horizons.
    pub count: i64,
    /// First day of the month, in UTC (YYYY-MM-DD).
    pub from: String,
    /// Last day of the month, in UTC (YYYY-MM-DD).
    pub to: String,
}
/// Path and query parameters of `getYearlyHoroscope`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetYearlyHoroscopeParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetYearlyHoroscopeParamsLang>,
    /// Zodiac sign, case-insensitive (e.g., aries, Aries, ARIES all work).
    pub sign: GetYearlyHoroscopeParamsSign,
    /// Selects which year counts as current when year is omitted. Defaults to UTC, so the forecast rolls over at 00:00 UTC on January 1. Pass the timezone of the end user to roll over on their local clock instead. Ignored when year is set. Accepts an IANA name (e.g. "America/New_York"), decimal hours (e.g. 5.5 for IST), or a fixed UTC offset (e.g. "-05:00").
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
    /// Calendar year to forecast, 1900 to 2100. Defaults to the current year in the timezone parameter.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i64>,
}
string_enum! {
    /// Zodiac sign, case-insensitive (e.g., aries, Aries, ARIES all work).
    GetYearlyHoroscopeParamsSign {
        Aries = "aries",
        Taurus = "taurus",
        Gemini = "gemini",
        Cancer = "cancer",
        Leo = "leo",
        Virgo = "virgo",
        Libra = "libra",
        Scorpio = "scorpio",
        Sagittarius = "sagittarius",
        Capricorn = "capricorn",
        Aquarius = "aquarius",
        Pisces = "pisces",
    }
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetYearlyHoroscopeParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getWeeklyHoroscope`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetWeeklyHoroscopeResponse {
    /// The single actionable takeaway from the leading event of the period, read into the whole-sign houses of this sign and checkable against the events array. Drawn from the same event as overview, kept to a short, actionable pair of sentences rather than grown to match the other sections. Deterministic: the same sign and period always returns the same text.
    pub advice: String,
    /// Weekly career and professional outlook, read into the whole-sign houses of this sign. The same ranked events that drive column, filtered to career, work and reputation, plus the standing placements that reach it. Every event named here is in the events array, so a piece can be fact-checked before it runs; this section reads an event through whichever of its houses carries career, work and reputation, which for an aspect between two houses can be the other one from the house the events array leads with, and both are whole-sign houses of the bodies involved counted from this sign. Typically 80 to 120 words. Render it alone for a single-topic page, or alongside the other five sections for a general reading; column is the same material woven into one piece instead of split by topic. Deterministic: the same sign and period always returns the same text.
    pub career: String,
    /// The full column for this period, ready to run as one piece, with paragraphs separated by a blank line. Names the events driving it and the dates they fall on, read into the whole-sign houses of this sign. Typically 250 to 450 words. The six section fields read the same ranked events filtered to their own life area, each composed as a column of its own rather than an excerpt of this one, so render either shape and never both. Deterministic: the same sign and period always returns the same column.
    pub column: String,
    /// Most compatible zodiac signs for this sign. Trine partners (same element) followed by a sextile partner (complementary element).
    #[serde(rename = "compatibleSigns")]
    pub compatible_signs: Vec<String>,
    /// The dated astronomical events this reading is built on, earliest first. Every field in every row can be checked against an independent authority, so a column can be fact-checked before it is published. Empty on a period in which nothing exact happens, where the reading falls back to the standing positions instead.
    pub events: Vec<GetWeeklyHoroscopeResponseEventsItem>,
    /// Weekly financial outlook, read into the whole-sign houses of this sign. The same ranked events that drive column, filtered to finance, plus the standing placements that reach it. Every event named here is in the events array, so a piece can be fact-checked before it runs; this section reads an event through whichever of its houses carries finance, which for an aspect between two houses can be the other one from the house the events array leads with, and both are whole-sign houses of the bodies involved counted from this sign. Typically 80 to 120 words. Render it alone for a single-topic page, or alongside the other five sections for a general reading; column is the same material woven into one piece instead of split by topic. Deterministic: the same sign and period always returns the same text.
    pub finance: String,
    /// Weekly health, energy, and wellness guidance, read into the whole-sign houses of this sign. The same ranked events that drive column, filtered to health, plus the standing placements that reach it. Every event named here is in the events array, so a piece can be fact-checked before it runs; this section reads an event through whichever of its houses carries health, which for an aspect between two houses can be the other one from the house the events array leads with, and both are whole-sign houses of the bodies involved counted from this sign. Typically 80 to 120 words. Render it alone for a single-topic page, or alongside the other five sections for a general reading; column is the same material woven into one piece instead of split by topic. Deterministic: the same sign and period always returns the same text.
    pub health: String,
    /// Weekly love and relationship forecast, read into the whole-sign houses of this sign. The same ranked events that drive column, filtered to romance and partnership, plus the standing placements that reach it. Every event named here is in the events array, so a piece can be fact-checked before it runs; this section reads an event through whichever of its houses carries romance and partnership, which for an aspect between two houses can be the other one from the house the events array leads with, and both are whole-sign houses of the bodies involved counted from this sign. Typically 80 to 120 words. Render it alone for a single-topic page, or alongside the other five sections for a general reading; column is the same material woven into one piece instead of split by topic. Deterministic: the same sign and period always returns the same text.
    pub love: String,
    /// The three most favorable days this week, from the planetary rulers of the seven weekdays, ranked by how strongly each of those planets stands for this sign.
    #[serde(rename = "luckyDays")]
    pub lucky_days: Vec<String>,
    /// Three lucky numbers for the week, each 1 to 9 and all distinct, from the traditional planetary number correspondence applied to the three planets that govern this sign this week.
    #[serde(rename = "luckyNumbers")]
    pub lucky_numbers: Vec<f64>,
    /// The single most relevant event of the period, whichever life area it touches, read into the whole-sign houses of this sign. The same event that leads column, at lede length rather than developed into a full movement, and checkable against the events array. Typically 40 to 80 words. Join it with love, career, health and finance for a general reading built from the six sections. Deterministic: the same sign and period always returns the same text.
    pub overview: String,
    /// Zodiac sign for this horoscope.
    pub sign: String,
    /// Start date of the forecast week (Monday).
    pub week: String,
}
/// One entry of `events`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetWeeklyHoroscopeResponseEventsItem {
    /// Angle formed, on aspect events only: conjunction, sextile, square, trine, opposition, semi-sextile, quincunx, semi-square, or sesquiquadrate.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub aspect: Option<String>,
    /// Exact instant the event perfects, UTC, to the second. Verifiable against NASA JPL Horizons for a position event and against the US Naval Observatory for a lunar phase or eclipse.
    pub at: String,
    /// Bodies involved, canonical English regardless of the requested language so the value stays safe to switch on. Two entries for an aspect, faster body first. One entry for an ingress, a station, a lunar phase, or an eclipse.
    pub bodies: Vec<String>,
    /// Whole-sign house the event falls in, counted from the queried sign, 1 to 12. This is what turns one global sky event into a statement about this reader.
    pub house: i64,
    /// Sign the event falls in, lowercase, where it has exactly one. Absent for an aspect whose two bodies stand in different signs.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sign: Option<String>,
    /// End of the window this event holds open, UTC, given only where a bounded window is a real fact about it: the orb span of an aspect, the sign span of an ingress or a season, the retrograde span of a station. Absent for a lunar phase or an eclipse, which are instants and not spans.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub through: Option<String>,
    /// Kind of event. aspect is an exact angle between two moving bodies, sign-ingress a body entering a new sign, retrograde-station a body turning retrograde or direct, lunar-phase one of the four quarters, eclipse a solar or lunar eclipse, and solar-season the Sun entering a sign.
    pub r#type: GetWeeklyHoroscopeResponseEventsItemType,
}
string_enum! {
    /// Kind of event. aspect is an exact angle between two moving bodies, sign-ingress a body entering a new sign, retrograde-station a body turning retrograde or direct, lunar-phase one of the four quarters, eclipse a solar or lunar eclipse, and solar-season the Sun entering a sign.
    GetWeeklyHoroscopeResponseEventsItemType {
        Aspect = "aspect",
        SignIngress = "sign-ingress",
        RetrogradeStation = "retrograde-station",
        LunarPhase = "lunar-phase",
        Eclipse = "eclipse",
        SolarSeason = "solar-season",
    }
}
/// Path and query parameters of `getWeeklyHoroscope`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetWeeklyHoroscopeParams {
    /// Any date inside the target week, in YYYY-MM-DD format. The forecast covers the Monday to Sunday week containing it. Defaults to the current period in the timezone parameter.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetWeeklyHoroscopeParamsLang>,
    /// Zodiac sign, case-insensitive (e.g., aries, Aries, ARIES all work).
    pub sign: GetWeeklyHoroscopeParamsSign,
    /// Selects which period counts as current when date is omitted. Defaults to UTC, so the forecast rolls over at 00:00 UTC on each Monday. Pass the timezone of the end user to roll over on their local clock instead. Ignored when date is set. Accepts an IANA name (e.g. "America/New_York"), decimal hours (e.g. 5.5 for IST), or a fixed UTC offset (e.g. "-05:00").
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
}
string_enum! {
    /// Zodiac sign, case-insensitive (e.g., aries, Aries, ARIES all work).
    GetWeeklyHoroscopeParamsSign {
        Aries = "aries",
        Taurus = "taurus",
        Gemini = "gemini",
        Cancer = "cancer",
        Leo = "leo",
        Virgo = "virgo",
        Libra = "libra",
        Scorpio = "scorpio",
        Sagittarius = "sagittarius",
        Capricorn = "capricorn",
        Aquarius = "aquarius",
        Pisces = "pisces",
    }
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetWeeklyHoroscopeParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getVedicDailyReading`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponse {
    /// Life areas carried as a TYPED closed set rather than an open map, so every generated SDK knows which keys exist. Finance ships alone in this version, because an area is a named classical house group with a citation and not a life category invented for a dropdown. Widening it later adds a key and breaks nothing.
    pub areas: GetVedicDailyReadingResponseAreas,
    /// Chandrabala for THIS native, windowed for the same reason as the tarabala: the Moon can change rashi inside the panchanga day. Ashtama Chandra is a separate flag on each window.
    pub chandrabala: Vec<GetVedicDailyReadingResponseChandrabalaItem>,
    /// The running Vimshottari chain at sunrise, outermost first, three levels deep. This is the frame the day is read inside, and it is also what the finance area reads the significators off. Empty for a chart whose cycle cannot be resolved.
    pub dasha: Vec<GetVedicDailyReadingResponseDashaItem>,
    /// Civil date this reading covers, echoing the request field or the UTC date it defaulted to.
    pub date: String,
    /// ISO instant the panchanga day ends, which is the next sunrise.
    #[serde(rename = "dayEnd")]
    pub day_end: String,
    /// ISO instant the panchanga day begins, which is SUNRISE at the birth coordinates and not midnight. Every limb below is resolved at this instant. Where the Sun does not rise, local noon is used instead and the substitution is named in degraded rather than applied silently.
    #[serde(rename = "dayStart")]
    pub day_start: String,
    /// Components this request could not supply, named rather than silently defaulted. Empty on an ordinary reading. A polar chart degrades through here instead of failing, so the caller still gets the gochara, the panchanga, the dasha and the natal basis of the finance area, and is told exactly what is missing.
    pub degraded: Vec<GetVedicDailyReadingResponseDegradedItem>,
    /// How many members the score was taken over, and its denominator: the nine grahas put through the gates plus the two Moon tests read at sunrise, tara\[0\] and chandrabala\[0\]. Rahu and Ketu are among the nine: they skip the bindu gate because they have no Bhinnashtakavarga, and a skipped gate is not a failed one, so they still reach a state through the other three.
    pub evaluated: f64,
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    pub focus: GetVedicDailyReadingResponseFocus,
    /// Every sidereal frame behind this reading, so a cached or forwarded payload is self describing and no number sits under a label it did not come from. TWO ayanamsas are in play by design: positions are Lahiri, and the Placidus cusps plus the KP significators are KP-Newcomb, which is the frame KP owns and the split a practitioner actually works in. The two differ by about 0.09 degrees, which is under a third of a KP sub-lord span and enough to move a placement near a boundary, so the reading declares which produced what rather than leaving a caller to guess. THREE entries for two ayanamsas, because Lahiri is read at two instants: the birth moment and the sunrise of the day being read, roughly half a degree apart on a chart forty years old, six times the gap between the two ayanamsas themselves. There is no ayanamsa request field on this route and there will not be one, since a single selector cannot honour two frames and accepting it would promise something the composition cannot deliver.
    pub frames: GetVedicDailyReadingResponseFrames,
    /// All nine transiting grahas, each with its four gate results and the ONE state they produced. The gates run in the order the sources give them: house from the natal Moon, then vedha, then the bindu gate, then the nullifiers of Phaladeepika XXVI.30 to XXVI.32. Obstruction is terminal, so a blocked transit is never rescued by the gates that follow it.
    pub grahas: Vec<GetVedicDailyReadingResponseGrahasItem>,
    /// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
    #[serde(rename = "houseThemes")]
    pub house_themes: GetVedicDailyReadingResponseHouseThemes,
    /// The four panchanga limbs, each resolved at sunrise and each carrying the instant it gives way, so a client can label the whole day rather than asserting one value for it.
    pub panchanga: GetVedicDailyReadingResponsePanchanga,
    /// Strength of this day for this native, 0 to 100, centred on 50, over eleven members: the nine transiting grahas and the two Moon tests of the day. Each graha counts +1 when its state is favourable, -1 when its state is unfavourable or aggravated, and 0 when it is underdelivered, obstructed, void. The tarabala window holding at sunrise, tara\[0\], counts +1 when its quality is favourable, -1 when unfavourable and 0 when neutral; the chandrabala window holding at sunrise, chandrabala\[0\], counts +1 when favourable and -1 otherwise. Then score = round(50 + 50 * (for minus against) / evaluated), so 50 is the balanced case with as many members for the native as against, 100 is every member for, 0 is every member against, and a member that is neither sits inside evaluated and pulls the result toward 50. Recompute it from this response: for is the favourable count in tally plus the Moon tests that are for, against is the unfavourable and aggravated counts plus the Moon tests that are against, evaluated is the field of that name. Worked example: 2 grahas for and 4 against, both Moon tests for, out of 11 evaluated is round(50 + 50 * (4 - 4) / 11) = 50. The Moon is counted three times on a day, through its own gochara row, its rashi test and its nakshatra test, because the gochara chapter and the muhurta chapter both weigh the Moon and ask different questions of it. The four gates that decide each graha state are classical, Phaladeepika XXVI.2 to XXVI.41 and B.V. Raman on Ashtakavarga, and each graha names the rule that decided it in stateSource; tarabala and chandrabala are the two per-native day tests of the muhurta genre. The count over all of them is a RoxyAPI convention, and it is a signed count rather than a weighted sum because the texts make a high bindu count an OVERRIDE and make aspect, dignity and combustion NULLIFIERS, not points to add. How to read it: an ordinary day sits in the 40s, because nine bodies casting drishti void most transits under XXVI.30, and the slow grahas hold one verdict for a year or more while the two Moon tests turn daily, so the day moves inside the month. Above 50 the day is in favour of the native, and the top band needs six more members for than against, which is rare. It measures support, never the outcome of a matter: whether the day suits a particular purpose depends on the purpose being judged.
    pub score: f64,
    /// The two natal reference points this whole reading is counted from, plus the longitude they come from.
    pub subject: GetVedicDailyReadingResponseSubject,
    /// The full per-state count over the nine grahas, always all six states including the zeros, so it sums to nine and not to evaluated. This is the graha part of the input to the score; the other two members are read from tara\[0\] and chandrabala\[0\]. Published so the number is reproducible by hand, and so a caller who reads the states differently can compute their own figure from this response.
    pub tally: Vec<GetVedicDailyReadingResponseTallyItem>,
    /// Tarabala for THIS native, as an array of windows rather than one value, because the Moon can change nakshatra inside a panchanga day and the reference panchangs print two windows when it does. Three windows happen and are returned when they do. One entry means the tara held all day.
    pub tara: Vec<GetVedicDailyReadingResponseTaraItem>,
    /// The score as one of four bands: "very-strong" above 75, "strong" above 50, "moderate" above 25, "weak" at 25 and below. A band starts above its edge, so a balanced day at exactly 50 is "moderate" and "strong" means the net is in favour of the native. "moderate" is the ordinary day. "weak" needs the members against to outnumber the members for by more than half of those evaluated, which is six of eleven, and "very-strong" is the mirror of that and is rare. The same four words band the finance score, the composite and each of its layers, on the same edges, so one word means one thing everywhere in this response. Canonical English machine values, the same enum every KP significator route returns.
    pub verdict: GetVedicDailyReadingResponseVerdict,
}
string_enum! {
    /// The score as one of four bands: "very-strong" above 75, "strong" above 50, "moderate" above 25, "weak" at 25 and below. A band starts above its edge, so a balanced day at exactly 50 is "moderate" and "strong" means the net is in favour of the native. "moderate" is the ordinary day. "weak" needs the members against to outnumber the members for by more than half of those evaluated, which is six of eleven, and "very-strong" is the mirror of that and is rare. The same four words band the finance score, the composite and each of its layers, on the same edges, so one word means one thing everywhere in this response. Canonical English machine values, the same enum every KP significator route returns.
    GetVedicDailyReadingResponseVerdict {
        VeryStrong = "very-strong",
        Strong = "strong",
        Moderate = "moderate",
        Weak = "weak",
    }
}
/// One entry of `tara`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponseTaraItem {
    /// Nakshatra the Moon occupies during this window. Canonical Sanskrit.
    #[serde(rename = "moonNakshatra")]
    pub moon_nakshatra: String,
    /// Name of the tara this native gets during this window, from the 9-tara cycle Janma through Parama Mitra. A Sanskrit proper noun and a canonical machine value, which is why the favourability is a separate field rather than something a caller has to infer from the word.
    pub name: GetVedicDailyReadingResponseTaraItemName,
    /// Tara number 1 to 9, counted inclusively from the Janma Nakshatra to the Moon nakshatra and folded by 9.
    pub number: f64,
    /// Where this tara falls in the three-way classical reading. Taras 2, 4, 6, 8 and 9 are favourable, 3, 5 and 7 are not, and the 1st (Janma) is neither.
    pub quality: GetVedicDailyReadingResponseTaraItemQuality,
    /// How long this component holds one verdict. Present on every component because this reading joins two genres classical literature keeps in separate books: a gochara verdict lasts as long as the graha stays in a rashi, which is years for Saturn, while a tarabala changes overnight. Without it a Saturn verdict that reads identically for nine hundred days would sit under one date field beside a limb that turns over at dawn.
    pub timescale: GetVedicDailyReadingResponseTaraItemTimescale,
    /// ISO instant this tarabala window opens.
    #[serde(rename = "validFrom")]
    pub valid_from: String,
    /// ISO instant this tarabala window closes, which is when the Moon changes nakshatra.
    #[serde(rename = "validTo")]
    pub valid_to: String,
}
string_enum! {
    /// How long this component holds one verdict. Present on every component because this reading joins two genres classical literature keeps in separate books: a gochara verdict lasts as long as the graha stays in a rashi, which is years for Saturn, while a tarabala changes overnight. Without it a Saturn verdict that reads identically for nine hundred days would sit under one date field beside a limb that turns over at dawn.
    GetVedicDailyReadingResponseTaraItemTimescale {
        Hours = "hours",
        Days = "days",
        Months = "months",
        Years = "years",
    }
}
string_enum! {
    /// Where this tara falls in the three-way classical reading. Taras 2, 4, 6, 8 and 9 are favourable, 3, 5 and 7 are not, and the 1st (Janma) is neither.
    GetVedicDailyReadingResponseTaraItemQuality {
        Favourable = "favourable",
        Unfavourable = "unfavourable",
        Neutral = "neutral",
    }
}
string_enum! {
    /// Name of the tara this native gets during this window, from the 9-tara cycle Janma through Parama Mitra. A Sanskrit proper noun and a canonical machine value, which is why the favourability is a separate field rather than something a caller has to infer from the word.
    GetVedicDailyReadingResponseTaraItemName {
        Janma = "Janma",
        Sampat = "Sampat",
        Vipat = "Vipat",
        Kshema = "Kshema",
        Pratyari = "Pratyari",
        Sadhaka = "Sadhaka",
        Vadha = "Vadha",
        Mitra = "Mitra",
        ParamaMitra = "Parama Mitra",
    }
}
/// One entry of `tally`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponseTallyItem {
    /// How many of the evaluated grahas reached that state.
    pub count: f64,
    /// One of the six outcomes a transiting graha can reach.
    pub state: GetVedicDailyReadingResponseTallyItemState,
}
string_enum! {
    /// One of the six outcomes a transiting graha can reach.
    GetVedicDailyReadingResponseTallyItemState {
        Favourable = "favourable",
        Underdelivered = "underdelivered",
        Obstructed = "obstructed",
        Void = "void",
        Aggravated = "aggravated",
        Unfavourable = "unfavourable",
    }
}
/// The two natal reference points this whole reading is counted from, plus the longitude they come from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponseSubject {
    /// Natal Moon nakshatra, the reference point the tarabala is counted from. Canonical Sanskrit.
    #[serde(rename = "janmaNakshatra")]
    pub janma_nakshatra: String,
    /// Janma Nakshatra number 1 to 27, counted from Ashwini.
    #[serde(rename = "janmaNakshatraNumber")]
    pub janma_nakshatra_number: f64,
    /// Natal Moon rashi, the reference point every gochara house count in this response is taken from. Always English.
    #[serde(rename = "janmaRashi")]
    pub janma_rashi: String,
    /// Sidereal longitude of the natal Moon in degrees. The single value both reference points are derived from, so any disagreement with a reference chart can be traced to its source rather than to a verdict.
    #[serde(rename = "moonLongitude")]
    pub moon_longitude: f64,
}
/// The four panchanga limbs, each resolved at sunrise and each carrying the instant it gives way, so a client can label the whole day rather than asserting one value for it.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponsePanchanga {
    /// Karana running at sunrise, with the instant it ends. A karana is half a tithi, which is why it is the fastest of the four limbs.
    pub karana: GetVedicDailyReadingResponsePanchangaKarana,
    /// Nakshatra the Moon occupies at sunrise, with the instant it ends. This is the sky-wide limb; for what it means to THIS native, read the tara array.
    pub nakshatra: GetVedicDailyReadingResponsePanchangaNakshatra,
    /// Lunar fortnight at sunrise: Shukla for the waxing half, Krishna for the waning half.
    pub paksha: String,
    /// Tithi (lunar day) running at sunrise, with the instant it ends. The tithi is the 12-degree step of the Moon away from the Sun, so its length varies through the month.
    pub tithi: GetVedicDailyReadingResponsePanchangaTithi,
    /// Weekday of the panchanga day. The Hindu vara runs sunrise to sunrise, so it can differ from the civil weekday of the same date before dawn. Always English.
    pub vara: String,
    /// The same weekday under its Sanskrit name.
    #[serde(rename = "varaSanskrit")]
    pub vara_sanskrit: String,
    /// Nitya yoga running at sunrise, with the instant it ends. The 27 yogas step through the combined longitude of the Sun and the Moon.
    pub yoga: GetVedicDailyReadingResponsePanchangaYoga,
}
/// Nitya yoga running at sunrise, with the instant it ends. The 27 yogas step through the combined longitude of the Sun and the Moon.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponsePanchangaYoga {
    /// Name of the yoga running at sunrise. Canonical Sanskrit, so it stays safe to compare against in code.
    pub name: String,
    /// The yoga that follows, so the rest of the day can be labelled without a second request.
    pub next: String,
    /// yoga number in its own cycle, resolved at sunrise.
    pub number: f64,
    /// How long this component holds one verdict. Present on every component because this reading joins two genres classical literature keeps in separate books: a gochara verdict lasts as long as the graha stays in a rashi, which is years for Saturn, while a tarabala changes overnight. Without it a Saturn verdict that reads identically for nine hundred days would sit under one date field beside a limb that turns over at dawn.
    pub timescale: GetVedicDailyReadingResponsePanchangaYogaTimescale,
    /// ISO instant this yoga ends. Read from the same transition search POST /panchang/detailed publishes, never recomputed here, so the two endpoints cannot disagree about when the event happens.
    #[serde(rename = "validTo")]
    pub valid_to: String,
}
string_enum! {
    /// How long this component holds one verdict. Present on every component because this reading joins two genres classical literature keeps in separate books: a gochara verdict lasts as long as the graha stays in a rashi, which is years for Saturn, while a tarabala changes overnight. Without it a Saturn verdict that reads identically for nine hundred days would sit under one date field beside a limb that turns over at dawn.
    GetVedicDailyReadingResponsePanchangaYogaTimescale {
        Hours = "hours",
        Days = "days",
        Months = "months",
        Years = "years",
    }
}
/// Tithi (lunar day) running at sunrise, with the instant it ends. The tithi is the 12-degree step of the Moon away from the Sun, so its length varies through the month.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponsePanchangaTithi {
    /// Name of the tithi running at sunrise. Canonical Sanskrit, so it stays safe to compare against in code.
    pub name: String,
    /// The tithi that follows, so the rest of the day can be labelled without a second request.
    pub next: String,
    /// tithi number in its own cycle, resolved at sunrise.
    pub number: f64,
    /// How long this component holds one verdict. Present on every component because this reading joins two genres classical literature keeps in separate books: a gochara verdict lasts as long as the graha stays in a rashi, which is years for Saturn, while a tarabala changes overnight. Without it a Saturn verdict that reads identically for nine hundred days would sit under one date field beside a limb that turns over at dawn.
    pub timescale: GetVedicDailyReadingResponsePanchangaTithiTimescale,
    /// ISO instant this tithi ends. Read from the same transition search POST /panchang/detailed publishes, never recomputed here, so the two endpoints cannot disagree about when the event happens.
    #[serde(rename = "validTo")]
    pub valid_to: String,
}
string_enum! {
    /// How long this component holds one verdict. Present on every component because this reading joins two genres classical literature keeps in separate books: a gochara verdict lasts as long as the graha stays in a rashi, which is years for Saturn, while a tarabala changes overnight. Without it a Saturn verdict that reads identically for nine hundred days would sit under one date field beside a limb that turns over at dawn.
    GetVedicDailyReadingResponsePanchangaTithiTimescale {
        Hours = "hours",
        Days = "days",
        Months = "months",
        Years = "years",
    }
}
/// Nakshatra the Moon occupies at sunrise, with the instant it ends. This is the sky-wide limb; for what it means to THIS native, read the tara array.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponsePanchangaNakshatra {
    /// Name of the nakshatra running at sunrise. Canonical Sanskrit, so it stays safe to compare against in code.
    pub name: String,
    /// The nakshatra that follows, so the rest of the day can be labelled without a second request.
    pub next: String,
    /// nakshatra number in its own cycle, resolved at sunrise.
    pub number: f64,
    /// How long this component holds one verdict. Present on every component because this reading joins two genres classical literature keeps in separate books: a gochara verdict lasts as long as the graha stays in a rashi, which is years for Saturn, while a tarabala changes overnight. Without it a Saturn verdict that reads identically for nine hundred days would sit under one date field beside a limb that turns over at dawn.
    pub timescale: GetVedicDailyReadingResponsePanchangaNakshatraTimescale,
    /// ISO instant this nakshatra ends. Read from the same transition search POST /panchang/detailed publishes, never recomputed here, so the two endpoints cannot disagree about when the event happens.
    #[serde(rename = "validTo")]
    pub valid_to: String,
}
string_enum! {
    /// How long this component holds one verdict. Present on every component because this reading joins two genres classical literature keeps in separate books: a gochara verdict lasts as long as the graha stays in a rashi, which is years for Saturn, while a tarabala changes overnight. Without it a Saturn verdict that reads identically for nine hundred days would sit under one date field beside a limb that turns over at dawn.
    GetVedicDailyReadingResponsePanchangaNakshatraTimescale {
        Hours = "hours",
        Days = "days",
        Months = "months",
        Years = "years",
    }
}
/// Karana running at sunrise, with the instant it ends. A karana is half a tithi, which is why it is the fastest of the four limbs.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponsePanchangaKarana {
    /// Name of the karana running at sunrise. Canonical Sanskrit, so it stays safe to compare against in code.
    pub name: String,
    /// The karana that follows, so the rest of the day can be labelled without a second request.
    pub next: String,
    /// karana number in its own cycle, resolved at sunrise.
    pub number: f64,
    /// How long this component holds one verdict. Present on every component because this reading joins two genres classical literature keeps in separate books: a gochara verdict lasts as long as the graha stays in a rashi, which is years for Saturn, while a tarabala changes overnight. Without it a Saturn verdict that reads identically for nine hundred days would sit under one date field beside a limb that turns over at dawn.
    pub timescale: GetVedicDailyReadingResponsePanchangaKaranaTimescale,
    /// ISO instant this karana ends. Read from the same transition search POST /panchang/detailed publishes, never recomputed here, so the two endpoints cannot disagree about when the event happens.
    #[serde(rename = "validTo")]
    pub valid_to: String,
}
string_enum! {
    /// How long this component holds one verdict. Present on every component because this reading joins two genres classical literature keeps in separate books: a gochara verdict lasts as long as the graha stays in a rashi, which is years for Saturn, while a tarabala changes overnight. Without it a Saturn verdict that reads identically for nine hundred days would sit under one date field beside a limb that turns over at dawn.
    GetVedicDailyReadingResponsePanchangaKaranaTimescale {
        Hours = "hours",
        Days = "days",
        Months = "months",
        Years = "years",
    }
}
/// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponseHouseThemes {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, Vec<String>>,
}
/// One entry of `grahas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponseGrahasItem {
    /// Gate 4. Transiting natural benefics casting graha drishti on this graha. Under Phaladeepika XXVI.30 a benefic sight on a BAD result is what voids it. Read as drishti from the other TRANSITING grahas, which is a school choice this endpoint makes and states: the sloka sits between the vedha rules and the rules about the transiting graha own condition.
    #[serde(rename = "aspectedByBenefic")]
    pub aspected_by_benefic: Vec<String>,
    /// Gate 4. Transiting natural enemies of this graha casting graha drishti on it. Phaladeepika XXVI.30 voids the result either way for an enemy sight, whichever direction the baseline verdict pointed.
    #[serde(rename = "aspectedByEnemy")]
    pub aspected_by_enemy: Vec<String>,
    /// Gate 4. Transiting natural malefics casting graha drishti on this graha. A malefic sight on a GOOD result voids it under Phaladeepika XXVI.30. Rahu and Ketu never appear here: they cast no drishti in this package, which is its own documented school choice, although they can be aspected.
    #[serde(rename = "aspectedByMalefic")]
    pub aspected_by_malefic: Vec<String>,
    /// Gate 3. Bindus this graha holds in the whole sign it is transiting, 0 to 8, or null for Rahu and Ketu, which have no Bhinnashtakavarga and therefore SKIP this gate entirely rather than scoring zero. The gate reads the number two ways: a favourable house carrying fewer than 4 bindus under delivers, and an unfavourable house carrying a strict majority of the eight contributors, 5 or more, is turned good by Phaladeepika XXVI.41. Exactly 4 fires neither rule, which is the literal reading of both phrasings rather than a rounding choice. WHOSE READING THE NUMBER IS, stated because generalising it is ours: B.V. Raman prints 4 once and prints it about the MOON, then generalises the PRINCIPLE to every graha in the next sentence without repeating any number, and Phaladeepika XXVI.41 is general across grahas and also states no number. Applying 4 to all nine bodies is RoxyAPI reading the general rule through the one worked example the author gave it, and it is not a universally stated classical threshold.
    #[serde(rename = "binduCount")]
    pub bindu_count: Option<f64>,
    /// Gate 4. Whether the graha is combust at the transit moment, or null for the Sun and the two nodes where the question does not arise at all. Combustion voids a good transit under Phaladeepika XXVI.32 and aggravates a bad one.
    pub combust: Option<bool>,
    /// Gate 4. Dignity of the graha in the sign it is transiting, or null for Rahu and Ketu which have none. Feeds the Phaladeepika XXVI.31 shield ("exalted" or "own" does no harm in an untoward bhava) and the XXVI.32 weakness ("debilitated" or "enemy" voids a good transit). One of exalted, own, debilitated, enemy, neutral.
    pub dignity: Option<GetVedicDailyReadingResponseGrahasItemDignity>,
    /// Gate 1. Whether houseFromMoon is on this graha classical favourable list (Phaladeepika XXVI.2). The baseline verdict, before vedha, bindus or the nullifiers have had their say.
    pub favourable: bool,
    /// Gate 1 evidence: the whole favourable list for this graha, so the baseline verdict can be checked in place without a second request or a table lookup.
    #[serde(rename = "favourableHouses")]
    pub favourable_houses: Vec<f64>,
    /// Graha name, Sun through Ketu. Always English, whatever the lang parameter says, so it stays safe to compare against in code.
    pub graha: String,
    /// House this graha transits counted whole-sign and inclusively from the natal Moon rashi (Janma Rashi), so the Moon rashi itself is 1. This is the reference classical Gochara is reckoned in: Phaladeepika XXVI.1 opens the transit chapter by saying that of all the Lagnas only the Moon Lagna matters for transit results. A reading counted from the Lagna instead answers a different question and every verdict below would be wrong.
    #[serde(rename = "houseFromMoon")]
    pub house_from_moon: f64,
    /// Gochara Kaksha: the ashtakavarga-qualified reading of this transit. The sign says where a graha is, this says whether the exact stretch it currently occupies is one its own Bhinnashtakavarga supports, which is the classical way of refining a transit verdict from sign-level to under four degrees.
    pub kaksha: GetVedicDailyReadingResponseGrahasItemKaksha,
    /// Sidereal longitude of the transiting graha in degrees, 0 to 360, Lahiri frame.
    pub longitude: f64,
    /// Gate 2. Grahas actually standing in vedhaHouse, with the mutual exemptions already applied. Empty when nothing obstructs. A non-empty list makes the state "obstructed", which is a THIRD outcome rather than a smaller number: the texts cancel the promised good outright rather than discounting it.
    #[serde(rename = "obstructedBy")]
    pub obstructed_by: Vec<String>,
    /// Rashi this graha is transiting on the day being read. Always English.
    pub sign: String,
    /// The single outcome the four gates produced for this graha, and the only field the score counts. "favourable" is the house list holding with nothing cancelling it, "underdelivered" is a favourable house below the bindu delivery floor, "obstructed" is vedha, "void" is an aspect, a dignity shield or a weakness emptying the result of effect, "aggravated" is the one compounding rule in the chapter, and "unfavourable" is a house that was never on the list. Canonical English machine values: every one is a classical outcome word rather than an invented label, which is why none carries a translated sibling.
    pub state: GetVedicDailyReadingResponseGrahasItemState,
    /// The rule that decided the state, named so a verdict can be checked against its sloka without leaving the payload.
    #[serde(rename = "stateSource")]
    pub state_source: String,
    /// How long this component holds one verdict. Present on every component because this reading joins two genres classical literature keeps in separate books: a gochara verdict lasts as long as the graha stays in a rashi, which is years for Saturn, while a tarabala changes overnight. Without it a Saturn verdict that reads identically for nine hundred days would sit under one date field beside a limb that turns over at dawn.
    pub timescale: GetVedicDailyReadingResponseGrahasItemTimescale,
    /// Gate 2. Grahas that cannot obstruct this one however they transit, from the two mutual exemptions the texts name: the Sun and Saturn do not obstruct each other, and neither do the Moon and Mercury.
    #[serde(rename = "vedhaExempt")]
    pub vedha_exempt: Vec<String>,
    /// Gate 2. The house whose occupation by another graha cancels this transit (Phaladeepika XXVI.3-8). Null when the transit is not favourable to begin with, since there is nothing for an obstruction to cancel.
    #[serde(rename = "vedhaHouse")]
    pub vedha_house: Option<f64>,
}
string_enum! {
    /// How long this component holds one verdict. Present on every component because this reading joins two genres classical literature keeps in separate books: a gochara verdict lasts as long as the graha stays in a rashi, which is years for Saturn, while a tarabala changes overnight. Without it a Saturn verdict that reads identically for nine hundred days would sit under one date field beside a limb that turns over at dawn.
    GetVedicDailyReadingResponseGrahasItemTimescale {
        Hours = "hours",
        Days = "days",
        Months = "months",
        Years = "years",
    }
}
string_enum! {
    /// The single outcome the four gates produced for this graha, and the only field the score counts. "favourable" is the house list holding with nothing cancelling it, "underdelivered" is a favourable house below the bindu delivery floor, "obstructed" is vedha, "void" is an aspect, a dignity shield or a weakness emptying the result of effect, "aggravated" is the one compounding rule in the chapter, and "unfavourable" is a house that was never on the list. Canonical English machine values: every one is a classical outcome word rather than an invented label, which is why none carries a translated sibling.
    GetVedicDailyReadingResponseGrahasItemState {
        Favourable = "favourable",
        Underdelivered = "underdelivered",
        Obstructed = "obstructed",
        Void = "void",
        Aggravated = "aggravated",
        Unfavourable = "unfavourable",
    }
}
/// Gochara Kaksha: the ashtakavarga-qualified reading of this transit. The sign says where a graha is, this says whether the exact stretch it currently occupies is one its own Bhinnashtakavarga supports, which is the classical way of refining a transit verdict from sign-level to under four degrees.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponseGrahasItemKaksha {
    /// Whether this kaksha lord gave the transiting graha a bindu in the sign being transited, which is the Gochara Kaksha verdict: true reads as a favourable stretch of the transit, false as an unfavourable one. Null means the question does not apply rather than that the answer is no, because Rahu and Ketu have no Bhinnashtakavarga to read. Never render null as unfavourable.
    pub bindu: Option<bool>,
    /// Bindus the transiting graha holds in this whole sign, 0-8, or null for Rahu and Ketu. Context for the verdict, since the same kaksha reads differently in a sign worth 7 than in one worth 1.
    #[serde(rename = "binduCount")]
    pub bindu_count: Option<f64>,
    /// Degree within the sign where this kaksha ends.
    #[serde(rename = "endDegree")]
    pub end_degree: f64,
    /// Graha ruling this kaksha. The eight lords run Saturn, Jupiter, Mars, Sun, Venus, Mercury, Moon, Lagna from the start of every sign, ordered by how long each takes to cross a sign.
    pub lord: String,
    /// Kaksha number 1-8 within the current sign. Each sign divides into eight kakshas of 3 degrees 45 minutes, crossed in order, so this is how far through the sign the graha has travelled.
    pub number: f64,
    /// Degree within the sign where this kaksha begins (0, 3.75, 7.5 and so on).
    #[serde(rename = "startDegree")]
    pub start_degree: f64,
}
string_enum! {
    /// Gate 4. Dignity of the graha in the sign it is transiting, or null for Rahu and Ketu which have none. Feeds the Phaladeepika XXVI.31 shield ("exalted" or "own" does no harm in an untoward bhava) and the XXVI.32 weakness ("debilitated" or "enemy" voids a good transit). One of exalted, own, debilitated, enemy, neutral.
    GetVedicDailyReadingResponseGrahasItemDignity {
        Exalted = "exalted",
        Own = "own",
        Debilitated = "debilitated",
        Enemy = "enemy",
        Neutral = "neutral",
        NullValue = "null",
    }
}
/// Every sidereal frame behind this reading, so a cached or forwarded payload is self describing and no number sits under a label it did not come from. TWO ayanamsas are in play by design: positions are Lahiri, and the Placidus cusps plus the KP significators are KP-Newcomb, which is the frame KP owns and the split a practitioner actually works in. The two differ by about 0.09 degrees, which is under a third of a KP sub-lord span and enough to move a placement near a boundary, so the reading declares which produced what rather than leaving a caller to guess. THREE entries for two ayanamsas, because Lahiri is read at two instants: the birth moment and the sunrise of the day being read, roughly half a degree apart on a chart forty years old, six times the gap between the two ayanamsas themselves. There is no ayanamsa request field on this route and there will not be one, since a single selector cannot honour two frames and accepting it would promise something the composition cannot deliver.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponseFrames {
    /// KP-Newcomb, read at UTC midnight of the birth date. Produces the Placidus cusps behind the Ashtakavarga Lagna row and the KP significators behind the finance area, exactly as every KP route on this API computes them.
    pub kp: GetVedicDailyReadingResponseFramesKp,
    /// Lahiri at the birth instant. Produces the natal Moon this whole reading is counted from, the Vimshottari balance, and the natal graha rows of the Ashtakavarga scorecard the bindu gate reads.
    pub natal: GetVedicDailyReadingResponseFramesNatal,
    /// Lahiri at sunrise on the day being read. Produces every transiting longitude and every panchanga limb. Inside one day precession moves it 0.14 arcseconds, so this one value speaks for every limb resolved between the two sunrises.
    pub transit: GetVedicDailyReadingResponseFramesTransit,
}
/// Lahiri at sunrise on the day being read. Produces every transiting longitude and every panchanga limb. Inside one day precession moves it 0.14 arcseconds, so this one value speaks for every limb resolved between the two sunrises.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponseFramesTransit {
    /// ISO instant the ayanamsa was read at. Part of the value, not metadata: an ayanamsa moves about 50.3 arcseconds a year, so the same frame read at a birth in 1984 and at a transit in 2026 differs by more than half a degree.
    pub at: String,
    /// Sidereal frame this part of the reading was cast in. Always "lahiri" here: it is not a caller choice, because the composition runs two frames at once and a single request field could only ever name one of them.
    pub ayanamsa: String,
    /// Degrees actually subtracted from every tropical longitude this frame produced. Subtract it back to recover the tropical positions, or compare it against your reference software to confirm you are in the same frame before chasing a placement difference.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
    /// Response sections this frame is a determinant of, as paths into this payload. One of subject, grahas, panchanga, tara, chandrabala, dasha, areas.finance. A section appears under EVERY frame that feeds it, which is why grahas is listed three times: the transiting longitudes and the natal Moon they are counted from are both Lahiri read at different instants, while the Ashtakavarga Lagna row behind binduCount and kaksha is KP-Newcomb. Exactly two sections belong to one frame alone, subject to the natal frame and panchanga to the transit frame.
    pub governs: Vec<GetVedicDailyReadingResponseFramesTransitGovernsItem>,
}
string_enum! {
    /// One entry of `governs`.
    GetVedicDailyReadingResponseFramesTransitGovernsItem {
        Subject = "subject",
        Grahas = "grahas",
        Panchanga = "panchanga",
        Tara = "tara",
        Chandrabala = "chandrabala",
        Dasha = "dasha",
        AreasFinance = "areas.finance",
    }
}
/// Lahiri at the birth instant. Produces the natal Moon this whole reading is counted from, the Vimshottari balance, and the natal graha rows of the Ashtakavarga scorecard the bindu gate reads.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponseFramesNatal {
    /// ISO instant the ayanamsa was read at. Part of the value, not metadata: an ayanamsa moves about 50.3 arcseconds a year, so the same frame read at a birth in 1984 and at a transit in 2026 differs by more than half a degree.
    pub at: String,
    /// Sidereal frame this part of the reading was cast in. Always "lahiri" here: it is not a caller choice, because the composition runs two frames at once and a single request field could only ever name one of them.
    pub ayanamsa: String,
    /// Degrees actually subtracted from every tropical longitude this frame produced. Subtract it back to recover the tropical positions, or compare it against your reference software to confirm you are in the same frame before chasing a placement difference.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
    /// Response sections this frame is a determinant of, as paths into this payload. One of subject, grahas, panchanga, tara, chandrabala, dasha, areas.finance. A section appears under EVERY frame that feeds it, which is why grahas is listed three times: the transiting longitudes and the natal Moon they are counted from are both Lahiri read at different instants, while the Ashtakavarga Lagna row behind binduCount and kaksha is KP-Newcomb. Exactly two sections belong to one frame alone, subject to the natal frame and panchanga to the transit frame.
    pub governs: Vec<GetVedicDailyReadingResponseFramesNatalGovernsItem>,
}
string_enum! {
    /// One entry of `governs`.
    GetVedicDailyReadingResponseFramesNatalGovernsItem {
        Subject = "subject",
        Grahas = "grahas",
        Panchanga = "panchanga",
        Tara = "tara",
        Chandrabala = "chandrabala",
        Dasha = "dasha",
        AreasFinance = "areas.finance",
    }
}
/// KP-Newcomb, read at UTC midnight of the birth date. Produces the Placidus cusps behind the Ashtakavarga Lagna row and the KP significators behind the finance area, exactly as every KP route on this API computes them.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponseFramesKp {
    /// ISO instant the ayanamsa was read at. Part of the value, not metadata: an ayanamsa moves about 50.3 arcseconds a year, so the same frame read at a birth in 1984 and at a transit in 2026 differs by more than half a degree.
    pub at: String,
    /// Sidereal frame this part of the reading was cast in. Always "kp-newcomb" here: it is not a caller choice, because the composition runs two frames at once and a single request field could only ever name one of them.
    pub ayanamsa: String,
    /// Degrees actually subtracted from every tropical longitude this frame produced. Subtract it back to recover the tropical positions, or compare it against your reference software to confirm you are in the same frame before chasing a placement difference.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
    /// Response sections this frame is a determinant of, as paths into this payload. One of subject, grahas, panchanga, tara, chandrabala, dasha, areas.finance. A section appears under EVERY frame that feeds it, which is why grahas is listed three times: the transiting longitudes and the natal Moon they are counted from are both Lahiri read at different instants, while the Ashtakavarga Lagna row behind binduCount and kaksha is KP-Newcomb. Exactly two sections belong to one frame alone, subject to the natal frame and panchanga to the transit frame.
    pub governs: Vec<GetVedicDailyReadingResponseFramesKpGovernsItem>,
}
string_enum! {
    /// One entry of `governs`.
    GetVedicDailyReadingResponseFramesKpGovernsItem {
        Subject = "subject",
        Grahas = "grahas",
        Panchanga = "panchanga",
        Tara = "tara",
        Chandrabala = "chandrabala",
        Dasha = "dasha",
        AreasFinance = "areas.finance",
    }
}
string_enum! {
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    GetVedicDailyReadingResponseFocus {
        General = "general",
        Finance = "finance",
    }
}
/// One entry of `degraded`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponseDegradedItem {
    /// Which part of the reading this location or date could not supply. "areas.finance.score" names the KP net by the member it is read through: the finance area itself always ships and its natal block is always populated, and it is the seven netted members that are null.
    pub component: GetVedicDailyReadingResponseDegradedItemComponent,
    /// Why it could not: "sun-does-not-rise" for a day with no sunrise at these coordinates, "polar-latitude" above 66.56 degrees where the Placidus cusps have no solution.
    pub reason: GetVedicDailyReadingResponseDegradedItemReason,
}
string_enum! {
    /// Why it could not: "sun-does-not-rise" for a day with no sunrise at these coordinates, "polar-latitude" above 66.56 degrees where the Placidus cusps have no solution.
    GetVedicDailyReadingResponseDegradedItemReason {
        SunDoesNotRise = "sun-does-not-rise",
        PolarLatitude = "polar-latitude",
    }
}
string_enum! {
    /// Which part of the reading this location or date could not supply. "areas.finance.score" names the KP net by the member it is read through: the finance area itself always ships and its natal block is always populated, and it is the seven netted members that are null.
    GetVedicDailyReadingResponseDegradedItemComponent {
        DayStart = "dayStart",
        DayEnd = "dayEnd",
        AreasFinanceScore = "areas.finance.score",
    }
}
/// One entry of `dasha`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponseDashaItem {
    /// ISO instant this period ends.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Which Vimshottari level this period is. Only mahadasha, antardasha, pratyantardasha are carried: the sookshma and prana lords turn over in hours and minutes, so embedding them would advertise a day-long cache lifetime over a value that is already stale. Use POST /dasha/current for those two.
    pub level: GetVedicDailyReadingResponseDashaItemLevel,
    /// Graha ruling this period. Always English.
    pub lord: String,
    /// ISO instant this period begins.
    #[serde(rename = "startDate")]
    pub start_date: String,
    /// How long this component holds one verdict. Present on every component because this reading joins two genres classical literature keeps in separate books: a gochara verdict lasts as long as the graha stays in a rashi, which is years for Saturn, while a tarabala changes overnight. Without it a Saturn verdict that reads identically for nine hundred days would sit under one date field beside a limb that turns over at dawn.
    pub timescale: GetVedicDailyReadingResponseDashaItemTimescale,
}
string_enum! {
    /// How long this component holds one verdict. Present on every component because this reading joins two genres classical literature keeps in separate books: a gochara verdict lasts as long as the graha stays in a rashi, which is years for Saturn, while a tarabala changes overnight. Without it a Saturn verdict that reads identically for nine hundred days would sit under one date field beside a limb that turns over at dawn.
    GetVedicDailyReadingResponseDashaItemTimescale {
        Hours = "hours",
        Days = "days",
        Months = "months",
        Years = "years",
    }
}
string_enum! {
    /// Which Vimshottari level this period is. Only mahadasha, antardasha, pratyantardasha are carried: the sookshma and prana lords turn over in hours and minutes, so embedding them would advertise a day-long cache lifetime over a value that is already stale. Use POST /dasha/current for those two.
    GetVedicDailyReadingResponseDashaItemLevel {
        Mahadasha = "mahadasha",
        Antardasha = "antardasha",
        Pratyantardasha = "pratyantardasha",
    }
}
/// One entry of `chandrabala`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponseChandrabalaItem {
    /// The Moon in the 8th from the Janma Rashi. Its OWN flag, printed beside chandrabala rather than folded into it, exactly as the reference panchangs print it. Folding it in would let a caller read one boolean and miss the warning the source deliberately separates.
    #[serde(rename = "ashtamaChandra")]
    pub ashtama_chandra: bool,
    /// Whether the Moon stands in one of the rashis that give this native chandrabala during this window.
    pub favourable: bool,
    /// House the Moon rashi makes from the Janma Rashi, counted whole-sign and inclusively, so the Janma Rashi itself is 1. This is the number chandrabala is read off.
    #[serde(rename = "houseFromMoon")]
    pub house_from_moon: f64,
    /// Rashi the Moon occupies during this window. Always English.
    #[serde(rename = "moonSign")]
    pub moon_sign: String,
    /// How long this component holds one verdict. Present on every component because this reading joins two genres classical literature keeps in separate books: a gochara verdict lasts as long as the graha stays in a rashi, which is years for Saturn, while a tarabala changes overnight. Without it a Saturn verdict that reads identically for nine hundred days would sit under one date field beside a limb that turns over at dawn.
    pub timescale: GetVedicDailyReadingResponseChandrabalaItemTimescale,
    /// ISO instant this chandrabala window opens.
    #[serde(rename = "validFrom")]
    pub valid_from: String,
    /// ISO instant this chandrabala window closes, which is when the Moon changes rashi.
    #[serde(rename = "validTo")]
    pub valid_to: String,
}
string_enum! {
    /// How long this component holds one verdict. Present on every component because this reading joins two genres classical literature keeps in separate books: a gochara verdict lasts as long as the graha stays in a rashi, which is years for Saturn, while a tarabala changes overnight. Without it a Saturn verdict that reads identically for nine hundred days would sit under one date field beside a limb that turns over at dawn.
    GetVedicDailyReadingResponseChandrabalaItemTimescale {
        Hours = "hours",
        Days = "days",
        Months = "months",
        Years = "years",
    }
}
/// Life areas carried as a TYPED closed set rather than an open map, so every generated SDK knows which keys exist. Finance ships alone in this version, because an area is a named classical house group with a citation and not a life category invented for a dropdown. Widening it later adds a key and breaks nothing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponseAreas {
    /// The finance area: the positive house group 2, 5, 11 netted against the negative group 6, 8, 12, read off the lords of the running dasha, bhukti and antara, because that is the KP rule for when a matter fructifies, plus the natal basis the day is read against. ALWAYS AN OBJECT. Above latitude 66.56 the seven netted members are null, because the Placidus cusps behind the significators have no solution there, while natal is still populated because it is a property of the birth chart and needs no cusps; the reading also still carries its gochara, panchanga and dasha and names the omission in degraded. The two house groups are Krishnamurti Paddhati practice, but the NET is a KP practitioner convention rather than a classical operation: the KP sources that carry these groups use them as a promise test and an avoidance test, never as arithmetic. The groups also vary by author, and TWO houses are live disagreements rather than one. The 6th: some KP authors place it on the POSITIVE side as service income and salary, the exact opposite of the assignment used here. The 5th: it is named as a speculative GAIN house in the same KP sources that elsewhere call it a negation house, reading it as the 12th from the 6th and therefore loss of earning capacity, and both readings appear in one publication. The 1st is treated as a negation house by some authors on the same logic, as the 12th from the 2nd, and is not on either side here. This is a six house net and it is NOT the focus=finance lens, which re-reads all twelve bhavas in money vocabulary and moves no number. The two are orthogonal and both ship.
    pub finance: GetVedicDailyReadingResponseAreasFinance,
}
/// The finance area: the positive house group 2, 5, 11 netted against the negative group 6, 8, 12, read off the lords of the running dasha, bhukti and antara, because that is the KP rule for when a matter fructifies, plus the natal basis the day is read against. ALWAYS AN OBJECT. Above latitude 66.56 the seven netted members are null, because the Placidus cusps behind the significators have no solution there, while natal is still populated because it is a property of the birth chart and needs no cusps; the reading also still carries its gochara, panchanga and dasha and names the omission in degraded. The two house groups are Krishnamurti Paddhati practice, but the NET is a KP practitioner convention rather than a classical operation: the KP sources that carry these groups use them as a promise test and an avoidance test, never as arithmetic. The groups also vary by author, and TWO houses are live disagreements rather than one. The 6th: some KP authors place it on the POSITIVE side as service income and salary, the exact opposite of the assignment used here. The 5th: it is named as a speculative GAIN house in the same KP sources that elsewhere call it a negation house, reading it as the 12th from the 6th and therefore loss of earning capacity, and both readings appear in one publication. The 1st is treated as a negation house by some authors on the same logic, as the 12th from the 2nd, and is not on either side here. This is a six house net and it is NOT the focus=finance lens, which re-reads all twelve bhavas in money vocabulary and moves no number. The two are orthogonal and both ship.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponseAreasFinance {
    /// The band the finance score falls in, on the same ladder as the top-level verdict so the two can never disagree about what a word means: "very-strong" above 75, "strong" above 50, "moderate" above 25, "weak" at 25 and below. Null above latitude 66.56, where the Placidus cusps the KP significators are read from have no solution: the question does not apply there rather than the answer being no, so never render it as zero or as a weak verdict. The natal block beside it is unaffected and still ships, and degraded names areas.finance.score.
    pub band: Option<GetVedicDailyReadingResponseAreasFinanceBand>,
    /// Every negative-group connection, strongest KP level first. Null above latitude 66.56, where the Placidus cusps the KP significators are read from have no solution: the question does not apply there rather than the answer being no, so never render it as zero or as a weak verdict. The natal block beside it is unaffected and still ships, and degraded names areas.finance.score.
    pub cautions: Option<Vec<GetVedicDailyReadingResponseAreasFinanceCautionsItem>>,
    /// The equal-weight mean of the three day-level layer scores printed beside it, recomputable as round((day + finance + natal) / 3). WHICH LAYER IS WHICH: "day" is the top-level score of this reading, "finance" is areas.finance.score above, and "natal" is the four natal wealth yoga rows on the same signed net as the day, present positive yogas for the native, a present negative one against, an absent verdict of either kind neutral, over the four rows: round(50 + 50 * (for minus against) / evaluated), so 50 is the balanced case with as many members for the native as against, 100 is every member for, 0 is every member against, and a member that is neither sits inside evaluated and pulls the result toward 50, so it is 38, 50, 63, 75 or 88 and a chart with none of the four reads 50. Every layer is centred on 50 the same way, so the mean is too. Equal weights are a RoxyAPI convention: no classical authority weights the natal chart, the running dasha and the transiting sky against each other, so the three are averaged as they are and printed beside the result, and the band uses the same ladder as verdict. The composite measures how much of this reading backs the native on this day and never the outcome of any matter: read it as support, not as a prediction. NULL IN TWO CASES, and neither is a low score. Null when the running lords reach none of the six houses, because an absence of connection is not a verdict and must not be averaged as one. Null above latitude 66.56, where the Placidus cusps the KP significators are read from have no solution: the question does not apply there rather than the answer being no, so never render it as zero or as a weak verdict. The natal block beside it is unaffected and still ships, and degraded names areas.finance.score.
    pub composite: Option<GetVedicDailyReadingResponseAreasFinanceComposite>,
    /// Every positive-group connection, strongest KP level first. These are the specific lord-to-house links the score is made of, so the number can be audited rather than trusted. Null above latitude 66.56, where the Placidus cusps the KP significators are read from have no solution: the question does not apply there rather than the answer being no, so never render it as zero or as a weak verdict. The natal block beside it is unaffected and still ships, and degraded names areas.finance.score.
    pub drivers: Option<Vec<GetVedicDailyReadingResponseAreasFinanceDriversItem>>,
    /// The natal basis of this area: whether the chart is wealthy AT ALL, as the four classical wealth and poverty verdicts dhana, daridra, lakshmi, dhanamalika, each with the evidence that decided it. A PROPERTY OF THE BIRTH CHART AND NOT OF THE DAY, so it is the same block on every date this native is ever read for, which is exactly why it is CONTEXT rather than a term: it deliberately does not enter score, verdict, tally or evaluated, above or here, and the one number it does enter is the composite beside it, where it is printed as its own layer rather than folded in. Folding a constant into a per-day number would shift every day by the identical amount, carrying no information into the only comparison those numbers support, and it would break the published closed form that makes the top-level score reproducible by hand from grahas and the two sunrise windows alone. Read it as the standing question the day is being read against. The verdicts are the same ones POST /yoga/detect and POST /birth-chart return for this chart, computed in the Lahiri natal frame rather than in the KP-Newcomb frame the significators above use. PRESENT AT EVERY LATITUDE, including above the polar circle: these verdicts need only whole-sign houses from the Lagna, so nothing about them depends on the cusps the KP members above lose there.
    pub natal: Vec<GetVedicDailyReadingResponseAreasFinanceNatalItem>,
    /// How many connections land on the negative house group 6, 8, 12, which KP reads as debt, sudden loss and expenditure. Null above latitude 66.56, where the Placidus cusps the KP significators are read from have no solution: the question does not apply there rather than the answer being no, so never render it as zero or as a weak verdict. The natal block beside it is unaffected and still ships, and degraded names areas.finance.score.
    pub negative: Option<f64>,
    /// How many connections land on the positive house group 2, 5, 11, which KP reads as accumulated wealth, speculation and gains. Null above latitude 66.56, where the Placidus cusps the KP significators are read from have no solution: the question does not apply there rather than the answer being no, so never render it as zero or as a weak verdict. The natal block beside it is unaffected and still ships, and degraded names areas.finance.score.
    pub positive: Option<f64>,
    /// Share of the running lords six-house connections that land on the positive group, 0 to 100, rounded. A COUNT, so positive and negative below reproduce it in one division: round(positive / (positive + negative) * 100), which is the same signed net the top-level score uses with no neutral member, so 50 is as many connections on each side. Zero when the running lords reach none of the six houses, which is an ABSENCE of connection rather than a negative verdict. Null above latitude 66.56, where the Placidus cusps the KP significators are read from have no solution: the question does not apply there rather than the answer being no, so never render it as zero or as a weak verdict. The natal block beside it is unaffected and still ships, and degraded names areas.finance.score. The two house groups are Krishnamurti Paddhati practice, but the NET is a KP practitioner convention rather than a classical operation: the KP sources that carry these groups use them as a promise test and an avoidance test, never as arithmetic. The groups also vary by author, and TWO houses are live disagreements rather than one. The 6th: some KP authors place it on the POSITIVE side as service income and salary, the exact opposite of the assignment used here. The 5th: it is named as a speculative GAIN house in the same KP sources that elsewhere call it a negation house, reading it as the 12th from the 6th and therefore loss of earning capacity, and both readings appear in one publication. The 1st is treated as a negation house by some authors on the same logic, as the 12th from the 2nd, and is not on either side here. This is a six house net and it is NOT the focus=finance lens, which re-reads all twelve bhavas in money vocabulary and moves no number. The two are orthogonal and both ship.
    pub score: Option<f64>,
}
/// One entry of `natal`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponseAreasFinanceNatalItem {
    /// Why the verdict reads the way it does: every rule that matched, named by its own glossary id and its verse, with the exact condition it matched on, then the scope of the family. This is what makes the verdict checkable against a text rather than a label to be trusted, and it is also where the two excluded rules are declared: daridra-8 and daridra-9 rest on a single authority and are barred from deciding a verdict, though both still ship through GET /yoga/{id}. English in every language, like the per-graha stateSource, because it is provenance rather than display copy.
    pub evidence: String,
    /// Glossary id of the verdict, one of dhana, daridra, lakshmi, dhanamalika. Use it with GET /yoga/{id} for the full glossary entry, which carries the description and the classical result in every supported language. Canonical English, so it stays safe to switch on in code.
    pub id: String,
    /// Classical Sanskrit name of the combination. Canonical whatever the lang parameter says, exactly as the yoga endpoints return it.
    pub name: String,
    /// Whether the combination is on this chart. False means every rule in the family was evaluated and none held, which is a real answer rather than a missing one, and the evidence beside it names the full denominator.
    pub present: bool,
    /// Which way a present verdict points, carried because three of the four are wealth combinations and Daridra is a poverty one, so present alone does not tell a client whether to read it as support or as pressure. Canonical English machine value.
    pub quality: GetVedicDailyReadingResponseAreasFinanceNatalItemQuality,
}
string_enum! {
    /// Which way a present verdict points, carried because three of the four are wealth combinations and Daridra is a poverty one, so present alone does not tell a client whether to read it as support or as pressure. Canonical English machine value.
    GetVedicDailyReadingResponseAreasFinanceNatalItemQuality {
        Positive = "Positive",
        Negative = "Negative",
        Both = "Both",
    }
}
/// One entry of `drivers`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponseAreasFinanceDriversItem {
    /// Which of the running levels this graha rules. Carries the fact that one lord holds more than one level without letting it count twice.
    #[serde(rename = "dashaLevels")]
    pub dasha_levels: Vec<
        GetVedicDailyReadingResponseAreasFinanceDriversItemDashaLevelsItem,
    >,
    /// The KP letter for that level, on the standard A to D significator grading. A is the strongest connection.
    pub grade: GetVedicDailyReadingResponseAreasFinanceDriversItemGrade,
    /// The running dasha lord making this connection. A lord holding two of the three levels is listed once per house rather than twice, so nothing here is a hidden weight.
    pub graha: String,
    /// The finance house this lord reaches. One of the positive group 2, 5, 11 or the negative group 6, 8, 12.
    pub house: f64,
    /// Strongest KP significator level at which this lord reaches this house, 1 to 4. Level 1 is a planet in the constellation of the occupant, 2 the occupant, 3 a planet in the constellation of the house owner, 4 the house owner. Strongest level per house wins, which is step 1 of the published grading rule the dasha routes already use.
    pub level: i64,
}
string_enum! {
    /// The KP letter for that level, on the standard A to D significator grading. A is the strongest connection.
    GetVedicDailyReadingResponseAreasFinanceDriversItemGrade {
        A = "A",
        B = "B",
        C = "C",
        D = "D",
    }
}
string_enum! {
    /// One entry of `dashaLevels`.
    GetVedicDailyReadingResponseAreasFinanceDriversItemDashaLevelsItem {
        Mahadasha = "mahadasha",
        Antardasha = "antardasha",
        Pratyantardasha = "pratyantardasha",
    }
}
/// The equal-weight mean of the three day-level layer scores printed beside it, recomputable as round((day + finance + natal) / 3). WHICH LAYER IS WHICH: "day" is the top-level score of this reading, "finance" is areas.finance.score above, and "natal" is the four natal wealth yoga rows on the same signed net as the day, present positive yogas for the native, a present negative one against, an absent verdict of either kind neutral, over the four rows: round(50 + 50 * (for minus against) / evaluated), so 50 is the balanced case with as many members for the native as against, 100 is every member for, 0 is every member against, and a member that is neither sits inside evaluated and pulls the result toward 50, so it is 38, 50, 63, 75 or 88 and a chart with none of the four reads 50. Every layer is centred on 50 the same way, so the mean is too. Equal weights are a RoxyAPI convention: no classical authority weights the natal chart, the running dasha and the transiting sky against each other, so the three are averaged as they are and printed beside the result, and the band uses the same ladder as verdict. The composite measures how much of this reading backs the native on this day and never the outcome of any matter: read it as support, not as a prediction. NULL IN TWO CASES, and neither is a low score. Null when the running lords reach none of the six houses, because an absence of connection is not a verdict and must not be averaged as one. Null above latitude 66.56, where the Placidus cusps the KP significators are read from have no solution: the question does not apply there rather than the answer being no, so never render it as zero or as a weak verdict. The natal block beside it is unaffected and still ships, and degraded names areas.finance.score.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponseAreasFinanceComposite {
    /// The band the composite falls in, on the same ladder the top-level verdict uses: "very-strong" above 75, "strong" above 50, "moderate" above 25, "weak" at 25 and below.
    pub band: GetVedicDailyReadingResponseAreasFinanceCompositeBand,
    /// The three terms of the mean, always in the order day, finance, natal. Published so a caller who wants different weights can apply them to these same three numbers instead of asking for a second reading.
    pub layers: Vec<GetVedicDailyReadingResponseAreasFinanceCompositeLayersItem>,
    /// The mean itself, 0 to 100, rounded, centred on 50 like each of its terms. Every term is printed in the layers below, so the division can be redone rather than trusted.
    pub score: f64,
}
/// One entry of `layers`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponseAreasFinanceCompositeLayersItem {
    /// Where that one term lands on its own, on the same ladder as the composite band above: "very-strong" above 75, "strong" above 50, "moderate" above 25, "weak" at 25 and below.
    pub band: GetVedicDailyReadingResponseAreasFinanceCompositeLayersItemBand,
    /// Which term this row carries: "day" the top-level score of this reading, "finance" the KP net score in this area, "natal" the natal wealth net over the four verdict rows. Canonical English machine value, so it stays safe to switch on in code.
    pub layer: GetVedicDailyReadingResponseAreasFinanceCompositeLayersItemLayer,
    /// The term that went into the mean, 0 to 100. Each one is either printed elsewhere in this response or counted off a block that is, so no number enters the average unseen.
    pub score: f64,
}
string_enum! {
    /// Which term this row carries: "day" the top-level score of this reading, "finance" the KP net score in this area, "natal" the natal wealth net over the four verdict rows. Canonical English machine value, so it stays safe to switch on in code.
    GetVedicDailyReadingResponseAreasFinanceCompositeLayersItemLayer {
        Day = "day",
        Finance = "finance",
        Natal = "natal",
    }
}
string_enum! {
    /// Where that one term lands on its own, on the same ladder as the composite band above: "very-strong" above 75, "strong" above 50, "moderate" above 25, "weak" at 25 and below.
    GetVedicDailyReadingResponseAreasFinanceCompositeLayersItemBand {
        VeryStrong = "very-strong",
        Strong = "strong",
        Moderate = "moderate",
        Weak = "weak",
    }
}
string_enum! {
    /// The band the composite falls in, on the same ladder the top-level verdict uses: "very-strong" above 75, "strong" above 50, "moderate" above 25, "weak" at 25 and below.
    GetVedicDailyReadingResponseAreasFinanceCompositeBand {
        VeryStrong = "very-strong",
        Strong = "strong",
        Moderate = "moderate",
        Weak = "weak",
    }
}
/// One entry of `cautions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingResponseAreasFinanceCautionsItem {
    /// Which of the running levels this graha rules. Carries the fact that one lord holds more than one level without letting it count twice.
    #[serde(rename = "dashaLevels")]
    pub dasha_levels: Vec<
        GetVedicDailyReadingResponseAreasFinanceCautionsItemDashaLevelsItem,
    >,
    /// The KP letter for that level, on the standard A to D significator grading. A is the strongest connection.
    pub grade: GetVedicDailyReadingResponseAreasFinanceCautionsItemGrade,
    /// The running dasha lord making this connection. A lord holding two of the three levels is listed once per house rather than twice, so nothing here is a hidden weight.
    pub graha: String,
    /// The finance house this lord reaches. One of the positive group 2, 5, 11 or the negative group 6, 8, 12.
    pub house: f64,
    /// Strongest KP significator level at which this lord reaches this house, 1 to 4. Level 1 is a planet in the constellation of the occupant, 2 the occupant, 3 a planet in the constellation of the house owner, 4 the house owner. Strongest level per house wins, which is step 1 of the published grading rule the dasha routes already use.
    pub level: i64,
}
string_enum! {
    /// The KP letter for that level, on the standard A to D significator grading. A is the strongest connection.
    GetVedicDailyReadingResponseAreasFinanceCautionsItemGrade {
        A = "A",
        B = "B",
        C = "C",
        D = "D",
    }
}
string_enum! {
    /// One entry of `dashaLevels`.
    GetVedicDailyReadingResponseAreasFinanceCautionsItemDashaLevelsItem {
        Mahadasha = "mahadasha",
        Antardasha = "antardasha",
        Pratyantardasha = "pratyantardasha",
    }
}
string_enum! {
    /// The band the finance score falls in, on the same ladder as the top-level verdict so the two can never disagree about what a word means: "very-strong" above 75, "strong" above 50, "moderate" above 25, "weak" at 25 and below. Null above latitude 66.56, where the Placidus cusps the KP significators are read from have no solution: the question does not apply there rather than the answer being no, so never render it as zero or as a weak verdict. The natal block beside it is unaffected and still ships, and degraded names areas.finance.score.
    GetVedicDailyReadingResponseAreasFinanceBand {
        VeryStrong = "very-strong",
        Strong = "strong",
        Moderate = "moderate",
        Weak = "weak",
        NullValue = "null",
    }
}
/// Request body of `getVedicDailyReading`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetVedicDailyReadingRequest {
    /// Birth date in YYYY-MM-DD format. Fixes the Janma Rashi and Janma Nakshatra every part of this reading is counted from, and the natal Ashtakavarga the bindu gate reads.
    #[serde(rename = "birthDate")]
    pub birth_date: String,
    /// Birth time in HH:MM:SS format (24-hour). The Moon moves about half a degree an hour, so an error here moves the Janma Rashi and Janma Nakshatra and therefore every gochara house count, the tarabala and the chandrabala in this response.
    #[serde(rename = "birthTime")]
    pub birth_time: String,
    /// Civil date to read, in YYYY-MM-DD format. Defaults to today (UTC). The panchanga day it names runs from sunrise at the birth coordinates to the next sunrise, not from midnight, so a reading for this date covers the night that follows it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Birth location latitude in decimal degrees. Sets the natal house cusps behind the Ashtakavarga scorecard and the KP significators, and the sunrise that opens the panchanga day.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local sidereal time for the natal cusps and the sunrise the reading is composed at.
    pub longitude: f64,
    /// Lunar node type for Rahu and Ketu. "mean" uses the smooth mean node, which is the traditional Vedic default and what printed panchangs use. "true" uses the osculating node, which swings up to 1.5 degrees either side of mean and can therefore move a node into a different rashi and change its gochara house. Defaults to "mean".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<GetVedicDailyReadingRequestNodeType>,
    /// Timezone: IANA name (e.g. "Asia/Kolkata", "America/New_York") OR decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). IANA strings are resolved to the DST-correct offset for the date being read. Interprets the birth time and the civil date below. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetVedicDailyReadingRequestTimezone>,
}
/// Timezone: IANA name (e.g. "Asia/Kolkata", "America/New_York") OR decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). IANA strings are resolved to the DST-correct offset for the date being read. Interprets the birth time and the civil date below. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetVedicDailyReadingRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node type for Rahu and Ketu. "mean" uses the smooth mean node, which is the traditional Vedic default and what printed panchangs use. "true" uses the osculating node, which swings up to 1.5 degrees either side of mean and can therefore move a node into a different rashi and change its gochara house. Defaults to "mean".
    GetVedicDailyReadingRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Path and query parameters of `getVedicDailyReading`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetVedicDailyReadingParams {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<GetVedicDailyReadingParamsFocus>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetVedicDailyReadingParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetVedicDailyReadingParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    GetVedicDailyReadingParamsFocus {
        General = "general",
        Finance = "finance",
    }
}
/// Response body of `getUpcomingMoonPhases`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetUpcomingMoonPhasesResponse {
    /// Upcoming moon phase transition dates in chronological order.
    pub phases: Vec<GetUpcomingMoonPhasesResponsePhasesItem>,
}
/// One entry of `phases`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetUpcomingMoonPhasesResponsePhasesItem {
    /// Date of this moon phase transition (YYYY-MM-DD).
    pub date: String,
    /// Lunar phase name (New Moon, First Quarter Moon, Full Moon, Third Quarter Moon).
    pub phase: String,
}
/// Path and query parameters of `getUpcomingMoonPhases`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetUpcomingMoonPhasesParams {
    /// Number of upcoming moon phase transitions to return (1-20). Defaults to 8.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub count: Option<i64>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetUpcomingMoonPhasesParamsLang>,
    /// Start date in YYYY-MM-DD format. Defaults to today if omitted.
    #[serde(rename = "startDate", skip_serializing_if = "Option::is_none")]
    pub start_date: Option<String>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetUpcomingMoonPhasesParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `getTrigram`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetTrigramParams {
    /// Trigram number (1-8) or English name (Heaven, Earth, Thunder, Wind, Water, Fire, Mountain, Lake).
    pub id: String,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetTrigramParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetTrigramParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getTreeOfLife`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetTreeOfLifeResponse {
    /// The conventions this answer was computed under, echoed so it can be reproduced.
    pub conventions: GetTreeOfLifeResponseConventions,
    /// The order the emanation descends, top to bottom. Ten identifiers, no repeats.
    #[serde(rename = "lightningFlash")]
    pub lightning_flash: Vec<String>,
    /// The 22 paths, in path order.
    pub paths: Vec<GetTreeOfLifeResponsePathsItem>,
    /// The ten emanations in order, with Daat last.
    pub sephirot: Vec<GetTreeOfLifeResponseSephirotItem>,
    /// The four worlds, with both published mappings of the sephirot onto them.
    pub worlds: Vec<GetTreeOfLifeResponseWorldsItem>,
}
/// One entry of `worlds`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetTreeOfLifeResponseWorldsItem {
    /// The English gloss, in the requested language.
    pub english: String,
    /// The name in Hebrew. Data, identical in every language.
    pub hebrew: String,
    /// Machine identifier of the world, an ASCII romanization.
    pub id: String,
    /// Latin transcription of the Hebrew, from the mechanical letter map.
    pub romanization: String,
    /// Which sephirot fall in this world under the Hermetic mapping, the one the world field on each sephirah uses.
    pub sephirot: Vec<String>,
    /// Which sephirot fall in this world under the second mapping in circulation. The two agree on Formation and Action and differ at the top, and neither is suppressed.
    #[serde(rename = "sephirotAlternate")]
    pub sephirot_alternate: Vec<String>,
}
/// One entry of `sephirot`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetTreeOfLifeResponseSephirotItem {
    /// The sphere assigned to the sephirah under the requested system, in the requested language. This is the sephirot allotment and it is NOT the planet series the seven double letters carry.
    pub attribution: String,
    /// The English gloss of the name, in the requested language.
    pub english: String,
    /// The name in Hebrew, with vowel points. Data, identical in every language.
    pub hebrew: String,
    /// Machine identifier of the sephirah, an ASCII romanization, always English so it stays safe to compare against in code. Several romanizations of each name are in circulation and none is canonical, which is exactly why the id is fixed here.
    pub id: String,
    /// What the emanation is said to hold, in the requested language.
    pub meaning: String,
    /// Position in the emanation, 1 to 10. Null for Daat, which is counted in some diagrams and left out of others and is never an eleventh emanation.
    pub number: Option<f64>,
    /// Which of the three pillars the sephirah stands on: left, middle or right. Always English.
    pub pillar: String,
    /// Display name of the pillar, in the requested language.
    #[serde(rename = "pillarName")]
    pub pillar_name: String,
    /// Latin transcription of the Hebrew beside it, from the one mechanical letter map. A label for reading the string back, never a pronunciation claim and not the same thing as the id.
    pub romanization: String,
    /// Which of the four worlds the sephirah belongs to under the Hermetic mapping. Null for Daat. A second mapping is in circulation and both are returned in the worlds block.
    pub world: Option<String>,
}
/// One entry of `paths`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetTreeOfLifeResponsePathsItem {
    /// The `attribution` field.
    pub attribution: GetTreeOfLifeResponsePathsItemAttribution,
    /// Machine identifier of the sephirah the path runs from.
    pub from: String,
    /// Machine identifier of the letter on the path. Each of the 22 appears exactly once.
    pub letter: String,
    /// The letter itself. Data, identical in every language.
    #[serde(rename = "letterGlyph")]
    pub letter_glyph: String,
    /// Path number, 11 to 32. The numbering continues the ten sephirot into the thirty two Paths of Wisdom, so path 11 is the eleventh Path and not the eleventh path.
    pub path: f64,
    /// Machine identifier of the sephirah the path runs to.
    pub to: String,
    /// The `trump` field.
    pub trump: GetTreeOfLifeResponsePathsItemTrump,
}
/// The `trump` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetTreeOfLifeResponsePathsItemTrump {
    /// Identifier of the tarot trump on this path. It resolves in the Tarot API on the same key.
    pub id: String,
    /// Display name of the trump.
    pub name: String,
    /// The trump number as the deck prints it.
    pub number: String,
}
/// The `attribution` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetTreeOfLifeResponsePathsItemAttribution {
    /// What the letter attribution names: element, planet or sign.
    pub kind: String,
    /// The element, planet or sign under the requested reading. Always English.
    pub value: String,
}
/// The conventions this answer was computed under, echoed so it can be reproduced.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetTreeOfLifeResponseConventions {
    /// Which reading assigned the element, planet or sign on each path.
    #[serde(rename = "letterAttribution")]
    pub letter_attribution: String,
    /// Which reading assigned the spheres.
    #[serde(rename = "sephirotSystem")]
    pub sephirot_system: String,
    /// Which arrangement of the paths produced this answer.
    #[serde(rename = "treeVariant")]
    pub tree_variant: String,
}
/// Path and query parameters of `getTreeOfLife`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetTreeOfLifeParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetTreeOfLifeParamsLang>,
    /// Which reading assigns the element, planet or sign to each letter. The seven double letters are the contested column and the four readings genuinely disagree on them; the twelve simple letters run in natural zodiacal order in all four. The golden-dawn member does NOT exchange He and Tzade, which is a later change from a different author.
    #[serde(rename = "letterAttribution", skip_serializing_if = "Option::is_none")]
    pub letter_attribution: Option<GetTreeOfLifeParamsLetterAttribution>,
    /// Which reading assigns a sphere to each sephirah. The two were compared row by row and agree on all ten, so the answer is the same either way; the parameter exists so a caller knows which one produced it rather than assuming.
    #[serde(rename = "sephirotSystem", skip_serializing_if = "Option::is_none")]
    pub sephirot_system: Option<GetTreeOfLifeParamsSephirotSystem>,
    /// Which arrangement of the twenty two paths. The 1652 arrangement, in which Malkuth carries three paths, is the only one with a published table that letters every path, so it is the only member.
    #[serde(rename = "treeVariant", skip_serializing_if = "Option::is_none")]
    pub tree_variant: Option<GetTreeOfLifeParamsTreeVariant>,
}
string_enum! {
    /// Which arrangement of the twenty two paths. The 1652 arrangement, in which Malkuth carries three paths, is the only one with a published table that letters every path, so it is the only member.
    GetTreeOfLifeParamsTreeVariant {
        Kircher = "kircher",
    }
}
string_enum! {
    /// Which reading assigns a sphere to each sephirah. The two were compared row by row and agree on all ten, so the answer is the same either way; the parameter exists so a caller knows which one produced it rather than assuming.
    GetTreeOfLifeParamsSephirotSystem {
        Classical = "classical",
        GoldenDawn = "golden-dawn",
    }
}
string_enum! {
    /// Which reading assigns the element, planet or sign to each letter. The seven double letters are the contested column and the four readings genuinely disagree on them; the twelve simple letters run in natural zodiacal order in all four. The golden-dawn member does NOT exchange He and Tzade, which is a later change from a different author.
    GetTreeOfLifeParamsLetterAttribution {
        SeferYetzirahGra = "sefer-yetzirah-gra",
        SeferYetzirahShort = "sefer-yetzirah-short",
        SeferYetzirahSaadia = "sefer-yetzirah-saadia",
        GoldenDawn = "golden-dawn",
    }
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetTreeOfLifeParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `getTrecena`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetTrecenaParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetTrecenaParamsLang>,
    /// Trecena number, 1 to 20. Trecena 1 opens on 1 Imix, trecena 2 on 1 Ix, and each subsequent period opens thirteen signs further round the twenty.
    pub number: i64,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetTrecenaParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getSymbolLetterCounts`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSymbolLetterCountsResponse {
    /// Map of starting letter to symbol count. Use to build A-Z dream dictionary navigation showing how many dream meanings exist per letter.
    pub letters: GetSymbolLetterCountsResponseLetters,
    /// Total number of dream symbols in the complete dream interpretation database.
    pub total: f64,
}
/// Map of starting letter to symbol count. Use to build A-Z dream dictionary navigation showing how many dream meanings exist per letter.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSymbolLetterCountsResponseLetters {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, f64>,
}
/// Response body of `getSubDashas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSubDashasResponse {
    /// Antardasha (bhukti) sub-periods within this Mahadasha, proportional to each planet Vimshottari years, sorted chronologically. Nine for any Mahadasha the native lived through in full. FEWER than nine for the first Mahadasha in the chart, because the Vimshottari cycle was already running at birth: the Antardashas that ended before the birth date are not part of the chart, and the one in force at birth starts on the birth date.
    pub antardashas: Vec<GetSubDashasResponseAntardashasItem>,
    /// Ayanamsa actually applied, in degrees. The precession offset subtracted from the tropical (sayana) longitude to get the sidereal (nirayana) one. Lahiri sits near 23 deg 43 min for a 1990 birth, KP-Newcomb near 23 deg 38 min.
    pub ayanamsa: f64,
    /// Ayanamsa system used, echoing the request field. One of "lahiri", "kp-newcomb", "kp-old" or "custom". Echoed so a client can confirm which frame produced these dates without re-deriving it. When it reads "custom" the ayanamsa field above carries the exact value you supplied.
    #[serde(rename = "ayanamsaType")]
    pub ayanamsa_type: GetSubDashasResponseAyanamsaType,
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<GetSubDashasResponseFocus>,
    /// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
    #[serde(rename = "houseThemes", skip_serializing_if = "Option::is_none")]
    pub house_themes: Option<GetSubDashasResponseHouseThemes>,
    /// Ruling planet of the requested Mahadasha period.
    #[serde(rename = "mahadashaLord")]
    pub mahadasha_lord: GetSubDashasResponseMahadashaLord,
    /// Full details of the parent Mahadasha including start/end dates and duration.
    #[serde(rename = "mahadashaPeriod")]
    pub mahadasha_period: GetSubDashasResponseMahadashaPeriod,
    /// Sidereal (nirayana) longitude of the birth Moon in degrees, 0 to 360, measured in the ayanamsa frame reported below. This single value determines the birth nakshatra and therefore every dasha start and end date in this response. Compare it against a reference chart to reconcile any date difference at its source.
    #[serde(rename = "moonLongitude")]
    pub moon_longitude: f64,
}
/// Full details of the parent Mahadasha including start/end dates and duration.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSubDashasResponseMahadashaPeriod {
    /// Duration of this dasha period in years. Mahadasha durations range from 6 years (Sun) to 20 years (Venus).
    #[serde(rename = "durationYears")]
    pub duration_years: f64,
    /// End datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Vedic interpretation of the planetary period describing themes, karmic lessons, and life areas affected by this graha.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interpretation: Option<String>,
    /// Theoretical start of this period, present ONLY when the birth date truncated it. The Vimshottari cycle is already running when a native is born, so the period in force at birth began earlier: startDate is clipped to the birth moment while this field keeps the real start. Its presence is also why the first period of a chart can contain fewer than 9 sub-periods, the earlier ones having finished before birth. Absent on every period that runs its full length.
    #[serde(rename = "nominalStartDate", skip_serializing_if = "Option::is_none")]
    pub nominal_start_date: Option<String>,
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    pub planet: GetSubDashasResponseMahadashaPeriodPlanet,
    /// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub significators: Option<GetSubDashasResponseMahadashaPeriodSignificators>,
    /// Start datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "startDate")]
    pub start_date: String,
}
/// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSubDashasResponseMahadashaPeriodSignificators {
    /// House 1-12 this lord occupies in the Placidus birth chart. Its own Level 2 signification, repeated here because the occupied house is the first thing a KP reading looks at.
    pub house: i64,
    /// Every house this lord signifies, deduplicated and ordered strongest tier first. Where a house is reached at more than one level it is listed once, at its strongest. This is the flat "houses signified" column of a KP dasha table.
    #[serde(rename = "signifiedHouses")]
    pub signified_houses: Vec<i64>,
    /// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
    pub signifies: GetSubDashasResponseMahadashaPeriodSignificatorsSignifies,
    /// Lord of the nakshatra this planet sits in, one of the 9 grahas. In KP the star lord outranks the planet itself: a period lord mainly delivers the houses its star lord occupies and owns, which is why those appear at L1 and L3 rather than the planet own house.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
    pub strength: GetSubDashasResponseMahadashaPeriodSignificatorsStrength,
    /// Subset of signifiedHouses reached at grade A or B (levels L1 and L2). These are the houses a KP reading acts on for this period; the rest are supporting connections.
    #[serde(rename = "strongHouses")]
    pub strong_houses: Vec<i64>,
    /// KP sub lord of this planet, the 1 of 249 subdivision its longitude falls in, one of the 9 grahas. The star lord says WHAT results the period gives, the sub lord says WHETHER they materialize, so KP judgement checks both.
    #[serde(rename = "subLord", skip_serializing_if = "Option::is_none")]
    pub sub_lord: Option<String>,
}
/// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSubDashasResponseMahadashaPeriodSignificatorsStrength {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    pub grade: GetSubDashasResponseMahadashaPeriodSignificatorsStrengthGrade,
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    pub label: GetSubDashasResponseMahadashaPeriodSignificatorsStrengthLabel,
    /// Mean KP percentage weight across signifiedHouses, each house counted at its strongest level (A 100, B 75, C 50, D 25). A mean rather than a total, so signifying many houses weakly does not outrank signifying two houses at grade A.
    pub score: f64,
}
string_enum! {
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    GetSubDashasResponseMahadashaPeriodSignificatorsStrengthLabel {
        VeryStrong = "very-strong",
        Strong = "strong",
        Moderate = "moderate",
        Weak = "weak",
    }
}
string_enum! {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    GetSubDashasResponseMahadashaPeriodSignificatorsStrengthGrade {
        A = "A",
        B = "B",
        C = "C",
        D = "D",
    }
}
/// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSubDashasResponseMahadashaPeriodSignificatorsSignifies {
    /// Level 1, the strongest signification (grade A). Houses influenced because this planet sits in the nakshatra (star) of a planet occupying those houses. For Rahu and Ketu, also includes the L1 houses of their agent planets (conjoined, aspecting, sign lord).
    #[serde(rename = "L1")]
    pub l1: Vec<i64>,
    /// Level 2 (grade B). The house this planet physically occupies. For Rahu and Ketu, also includes houses occupied by their agent planets.
    #[serde(rename = "L2")]
    pub l2: Vec<i64>,
    /// Level 3 (grade C). Houses influenced because this planet sits in the nakshatra of the sign lord (owner) of those houses. For Rahu and Ketu, also includes the L3 houses of their agent planets.
    #[serde(rename = "L3")]
    pub l3: Vec<i64>,
    /// Level 4, the weakest signification (grade D). Houses this planet rules by zodiac sign ownership, up to 2 for Sun through Saturn and 3 where a sign is intercepted. Rahu and Ketu own no sign, so their L4 comes entirely from their agent planets.
    #[serde(rename = "L4")]
    pub l4: Vec<i64>,
}
string_enum! {
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    GetSubDashasResponseMahadashaPeriodPlanet {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Ruling planet of the requested Mahadasha period.
    GetSubDashasResponseMahadashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSubDashasResponseHouseThemes {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, Vec<String>>,
}
string_enum! {
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    GetSubDashasResponseFocus {
        General = "general",
        Finance = "finance",
    }
}
string_enum! {
    /// Ayanamsa system used, echoing the request field. One of "lahiri", "kp-newcomb", "kp-old" or "custom". Echoed so a client can confirm which frame produced these dates without re-deriving it. When it reads "custom" the ayanamsa field above carries the exact value you supplied.
    GetSubDashasResponseAyanamsaType {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Antardasha (bhukti), sub-period within a Mahadasha. Each Mahadasha contains 9 Antardashas proportional to the Vimshottari years of each planet.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSubDashasResponseAntardashasItem {
    /// Duration of this dasha period in years. Mahadasha durations range from 6 years (Sun) to 20 years (Venus).
    #[serde(rename = "durationYears")]
    pub duration_years: f64,
    /// End datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Vedic interpretation of the planetary period describing themes, karmic lessons, and life areas affected by this graha.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interpretation: Option<String>,
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    #[serde(rename = "mahadashaLord")]
    pub mahadasha_lord: GetSubDashasResponseAntardashasItemMahadashaLord,
    /// Theoretical start of this period, present ONLY when the birth date truncated it. The Vimshottari cycle is already running when a native is born, so the period in force at birth began earlier: startDate is clipped to the birth moment while this field keeps the real start. Its presence is also why the first period of a chart can contain fewer than 9 sub-periods, the earlier ones having finished before birth. Absent on every period that runs its full length.
    #[serde(rename = "nominalStartDate", skip_serializing_if = "Option::is_none")]
    pub nominal_start_date: Option<String>,
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    pub planet: GetSubDashasResponseAntardashasItemPlanet,
    /// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub significators: Option<GetSubDashasResponseAntardashasItemSignificators>,
    /// Start datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "startDate")]
    pub start_date: String,
}
/// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSubDashasResponseAntardashasItemSignificators {
    /// House 1-12 this lord occupies in the Placidus birth chart. Its own Level 2 signification, repeated here because the occupied house is the first thing a KP reading looks at.
    pub house: i64,
    /// Every house this lord signifies, deduplicated and ordered strongest tier first. Where a house is reached at more than one level it is listed once, at its strongest. This is the flat "houses signified" column of a KP dasha table.
    #[serde(rename = "signifiedHouses")]
    pub signified_houses: Vec<i64>,
    /// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
    pub signifies: GetSubDashasResponseAntardashasItemSignificatorsSignifies,
    /// Lord of the nakshatra this planet sits in, one of the 9 grahas. In KP the star lord outranks the planet itself: a period lord mainly delivers the houses its star lord occupies and owns, which is why those appear at L1 and L3 rather than the planet own house.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
    pub strength: GetSubDashasResponseAntardashasItemSignificatorsStrength,
    /// Subset of signifiedHouses reached at grade A or B (levels L1 and L2). These are the houses a KP reading acts on for this period; the rest are supporting connections.
    #[serde(rename = "strongHouses")]
    pub strong_houses: Vec<i64>,
    /// KP sub lord of this planet, the 1 of 249 subdivision its longitude falls in, one of the 9 grahas. The star lord says WHAT results the period gives, the sub lord says WHETHER they materialize, so KP judgement checks both.
    #[serde(rename = "subLord", skip_serializing_if = "Option::is_none")]
    pub sub_lord: Option<String>,
}
/// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSubDashasResponseAntardashasItemSignificatorsStrength {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    pub grade: GetSubDashasResponseAntardashasItemSignificatorsStrengthGrade,
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    pub label: GetSubDashasResponseAntardashasItemSignificatorsStrengthLabel,
    /// Mean KP percentage weight across signifiedHouses, each house counted at its strongest level (A 100, B 75, C 50, D 25). A mean rather than a total, so signifying many houses weakly does not outrank signifying two houses at grade A.
    pub score: f64,
}
string_enum! {
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    GetSubDashasResponseAntardashasItemSignificatorsStrengthLabel {
        VeryStrong = "very-strong",
        Strong = "strong",
        Moderate = "moderate",
        Weak = "weak",
    }
}
string_enum! {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    GetSubDashasResponseAntardashasItemSignificatorsStrengthGrade {
        A = "A",
        B = "B",
        C = "C",
        D = "D",
    }
}
/// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSubDashasResponseAntardashasItemSignificatorsSignifies {
    /// Level 1, the strongest signification (grade A). Houses influenced because this planet sits in the nakshatra (star) of a planet occupying those houses. For Rahu and Ketu, also includes the L1 houses of their agent planets (conjoined, aspecting, sign lord).
    #[serde(rename = "L1")]
    pub l1: Vec<i64>,
    /// Level 2 (grade B). The house this planet physically occupies. For Rahu and Ketu, also includes houses occupied by their agent planets.
    #[serde(rename = "L2")]
    pub l2: Vec<i64>,
    /// Level 3 (grade C). Houses influenced because this planet sits in the nakshatra of the sign lord (owner) of those houses. For Rahu and Ketu, also includes the L3 houses of their agent planets.
    #[serde(rename = "L3")]
    pub l3: Vec<i64>,
    /// Level 4, the weakest signification (grade D). Houses this planet rules by zodiac sign ownership, up to 2 for Sun through Saturn and 3 where a sign is intercepted. Rahu and Ketu own no sign, so their L4 comes entirely from their agent planets.
    #[serde(rename = "L4")]
    pub l4: Vec<i64>,
}
string_enum! {
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    GetSubDashasResponseAntardashasItemPlanet {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    GetSubDashasResponseAntardashasItemMahadashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Request body of `getSubDashas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSubDashasRequest {
    /// Ayanamsa system used to place the birth Moon in its nakshatra, which sets every dasha start and end date. "lahiri" uses Lahiri/Chitrapaksha, the traditional Vedic standard, and is the default. "kp-newcomb" uses the KP-Newcomb dynamic formula, matching Krishnamurti Paddhati software. "kp-old" uses the Krishnamurti original table from KP Reader-1. "raman" uses the B.V. Raman ayanamsa, the second frame traditional Indian software commonly offers beside Lahiri. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. Switching frames shifts every dasha boundary by weeks, so pick the one your reference software uses.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<GetSubDashasRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Lunar node type for Rahu and Ketu, used ONLY when "significators" is true. Dasha dates themselves come from the Moon and never move with this field. "mean" uses the smooth mean node (traditional default). "true" uses the osculating node, which swings up to 1.5 degrees either side of mean over a 173-day cycle and can therefore change which house or star a node falls in. Defaults to "mean".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<GetSubDashasRequestNodeType>,
    /// Set true to attach the KP significators of each period lord: its star lord, sub lord, occupied house, the houses it signifies at levels L1 to L4, and a strength grade. Off by default, so responses stay exactly as they are for clients that only need dates. Requires the birth latitude and longitude, since significators are read off a Placidus house chart, and uses the same ayanamsa frame selected above.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub significators: Option<bool>,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetSubDashasRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetSubDashasRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node type for Rahu and Ketu, used ONLY when "significators" is true. Dasha dates themselves come from the Moon and never move with this field. "mean" uses the smooth mean node (traditional default). "true" uses the osculating node, which swings up to 1.5 degrees either side of mean over a 173-day cycle and can therefore change which house or star a node falls in. Defaults to "mean".
    GetSubDashasRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// Ayanamsa system used to place the birth Moon in its nakshatra, which sets every dasha start and end date. "lahiri" uses Lahiri/Chitrapaksha, the traditional Vedic standard, and is the default. "kp-newcomb" uses the KP-Newcomb dynamic formula, matching Krishnamurti Paddhati software. "kp-old" uses the Krishnamurti original table from KP Reader-1. "raman" uses the B.V. Raman ayanamsa, the second frame traditional Indian software commonly offers beside Lahiri. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. Switching frames shifts every dasha boundary by weeks, so pick the one your reference software uses.
    GetSubDashasRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Path and query parameters of `getSubDashas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSubDashasParams {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<GetSubDashasParamsFocus>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetSubDashasParamsLang>,
    /// Mahadasha planet name, case-insensitive (e.g., jupiter, Jupiter, JUPITER all work). Valid: Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury.
    pub mahadasha: GetSubDashasParamsMahadasha,
}
string_enum! {
    /// Mahadasha planet name, case-insensitive (e.g., jupiter, Jupiter, JUPITER all work). Valid: Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury.
    GetSubDashasParamsMahadasha {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetSubDashasParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    GetSubDashasParamsFocus {
        General = "general",
        Finance = "finance",
    }
}
/// Response body of `getSookshmaDashas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSookshmaDashasResponse {
    /// Ruling planet of the requested Antardasha sub-period.
    #[serde(rename = "antardashaLord")]
    pub antardasha_lord: GetSookshmaDashasResponseAntardashaLord,
    /// Ayanamsa actually applied, in degrees. The precession offset subtracted from the tropical (sayana) longitude to get the sidereal (nirayana) one. Lahiri sits near 23 deg 43 min for a 1990 birth, KP-Newcomb near 23 deg 38 min.
    pub ayanamsa: f64,
    /// Ayanamsa system used, echoing the request field. One of "lahiri", "kp-newcomb", "kp-old" or "custom". Echoed so a client can confirm which frame produced these dates without re-deriving it. When it reads "custom" the ayanamsa field above carries the exact value you supplied.
    #[serde(rename = "ayanamsaType")]
    pub ayanamsa_type: GetSookshmaDashasResponseAyanamsaType,
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<GetSookshmaDashasResponseFocus>,
    /// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
    #[serde(rename = "houseThemes", skip_serializing_if = "Option::is_none")]
    pub house_themes: Option<GetSookshmaDashasResponseHouseThemes>,
    /// Ruling planet of the requested Mahadasha period.
    #[serde(rename = "mahadashaLord")]
    pub mahadasha_lord: GetSookshmaDashasResponseMahadashaLord,
    /// Sidereal (nirayana) longitude of the birth Moon in degrees, 0 to 360, measured in the ayanamsa frame reported below. This single value determines the birth nakshatra and therefore every dasha start and end date in this response. Compare it against a reference chart to reconcile any date difference at its source.
    #[serde(rename = "moonLongitude")]
    pub moon_longitude: f64,
    /// Ruling planet of the requested Pratyantardasha sub-sub-period.
    #[serde(rename = "pratyantardashaLord")]
    pub pratyantardasha_lord: GetSookshmaDashasResponsePratyantardashaLord,
    /// Full details of the parent Pratyantardasha including start/end dates and duration.
    #[serde(rename = "pratyantardashaPeriod")]
    pub pratyantardasha_period: GetSookshmaDashasResponsePratyantardashaPeriod,
    /// Sookshma dasha periods within this Pratyantardasha, proportional to each planet Vimshottari years, sorted chronologically and starting with the Pratyantardasha lord. Fewer than nine only when the parent Pratyantardasha is the one that was already running at birth, in which case the periods that ended before the birth date are omitted.
    #[serde(rename = "sookshmaDashas")]
    pub sookshma_dashas: Vec<GetSookshmaDashasResponseSookshmaDashasItem>,
}
/// Sookshma dasha (sookshma antardasha), the fourth level of the Vimshottari dasha hierarchy. Each Pratyantardasha divides into 9 Sookshma periods running roughly 3 to 30 days each, used for day-level event timing and muhurta style selection.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSookshmaDashasResponseSookshmaDashasItem {
    /// Parent Antardasha lord under which this Pratyantardasha runs.
    #[serde(rename = "antardashaLord")]
    pub antardasha_lord: GetSookshmaDashasResponseSookshmaDashasItemAntardashaLord,
    /// Duration of this dasha period in years. Mahadasha durations range from 6 years (Sun) to 20 years (Venus).
    #[serde(rename = "durationYears")]
    pub duration_years: f64,
    /// End datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Vedic interpretation of the planetary period describing themes, karmic lessons, and life areas affected by this graha.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interpretation: Option<String>,
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    #[serde(rename = "mahadashaLord")]
    pub mahadasha_lord: GetSookshmaDashasResponseSookshmaDashasItemMahadashaLord,
    /// Theoretical start of this period, present ONLY when the birth date truncated it. The Vimshottari cycle is already running when a native is born, so the period in force at birth began earlier: startDate is clipped to the birth moment while this field keeps the real start. Its presence is also why the first period of a chart can contain fewer than 9 sub-periods, the earlier ones having finished before birth. Absent on every period that runs its full length.
    #[serde(rename = "nominalStartDate", skip_serializing_if = "Option::is_none")]
    pub nominal_start_date: Option<String>,
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    pub planet: GetSookshmaDashasResponseSookshmaDashasItemPlanet,
    /// Parent Pratyantardasha lord under which this Sookshma dasha runs.
    #[serde(rename = "pratyantardashaLord")]
    pub pratyantardasha_lord: GetSookshmaDashasResponseSookshmaDashasItemPratyantardashaLord,
    /// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub significators: Option<GetSookshmaDashasResponseSookshmaDashasItemSignificators>,
    /// Start datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "startDate")]
    pub start_date: String,
}
/// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSookshmaDashasResponseSookshmaDashasItemSignificators {
    /// House 1-12 this lord occupies in the Placidus birth chart. Its own Level 2 signification, repeated here because the occupied house is the first thing a KP reading looks at.
    pub house: i64,
    /// Every house this lord signifies, deduplicated and ordered strongest tier first. Where a house is reached at more than one level it is listed once, at its strongest. This is the flat "houses signified" column of a KP dasha table.
    #[serde(rename = "signifiedHouses")]
    pub signified_houses: Vec<i64>,
    /// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
    pub signifies: GetSookshmaDashasResponseSookshmaDashasItemSignificatorsSignifies,
    /// Lord of the nakshatra this planet sits in, one of the 9 grahas. In KP the star lord outranks the planet itself: a period lord mainly delivers the houses its star lord occupies and owns, which is why those appear at L1 and L3 rather than the planet own house.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
    pub strength: GetSookshmaDashasResponseSookshmaDashasItemSignificatorsStrength,
    /// Subset of signifiedHouses reached at grade A or B (levels L1 and L2). These are the houses a KP reading acts on for this period; the rest are supporting connections.
    #[serde(rename = "strongHouses")]
    pub strong_houses: Vec<i64>,
    /// KP sub lord of this planet, the 1 of 249 subdivision its longitude falls in, one of the 9 grahas. The star lord says WHAT results the period gives, the sub lord says WHETHER they materialize, so KP judgement checks both.
    #[serde(rename = "subLord", skip_serializing_if = "Option::is_none")]
    pub sub_lord: Option<String>,
}
/// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSookshmaDashasResponseSookshmaDashasItemSignificatorsStrength {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    pub grade: GetSookshmaDashasResponseSookshmaDashasItemSignificatorsStrengthGrade,
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    pub label: GetSookshmaDashasResponseSookshmaDashasItemSignificatorsStrengthLabel,
    /// Mean KP percentage weight across signifiedHouses, each house counted at its strongest level (A 100, B 75, C 50, D 25). A mean rather than a total, so signifying many houses weakly does not outrank signifying two houses at grade A.
    pub score: f64,
}
string_enum! {
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    GetSookshmaDashasResponseSookshmaDashasItemSignificatorsStrengthLabel {
        VeryStrong = "very-strong",
        Strong = "strong",
        Moderate = "moderate",
        Weak = "weak",
    }
}
string_enum! {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    GetSookshmaDashasResponseSookshmaDashasItemSignificatorsStrengthGrade {
        A = "A",
        B = "B",
        C = "C",
        D = "D",
    }
}
/// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSookshmaDashasResponseSookshmaDashasItemSignificatorsSignifies {
    /// Level 1, the strongest signification (grade A). Houses influenced because this planet sits in the nakshatra (star) of a planet occupying those houses. For Rahu and Ketu, also includes the L1 houses of their agent planets (conjoined, aspecting, sign lord).
    #[serde(rename = "L1")]
    pub l1: Vec<i64>,
    /// Level 2 (grade B). The house this planet physically occupies. For Rahu and Ketu, also includes houses occupied by their agent planets.
    #[serde(rename = "L2")]
    pub l2: Vec<i64>,
    /// Level 3 (grade C). Houses influenced because this planet sits in the nakshatra of the sign lord (owner) of those houses. For Rahu and Ketu, also includes the L3 houses of their agent planets.
    #[serde(rename = "L3")]
    pub l3: Vec<i64>,
    /// Level 4, the weakest signification (grade D). Houses this planet rules by zodiac sign ownership, up to 2 for Sun through Saturn and 3 where a sign is intercepted. Rahu and Ketu own no sign, so their L4 comes entirely from their agent planets.
    #[serde(rename = "L4")]
    pub l4: Vec<i64>,
}
string_enum! {
    /// Parent Pratyantardasha lord under which this Sookshma dasha runs.
    GetSookshmaDashasResponseSookshmaDashasItemPratyantardashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    GetSookshmaDashasResponseSookshmaDashasItemPlanet {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    GetSookshmaDashasResponseSookshmaDashasItemMahadashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Parent Antardasha lord under which this Pratyantardasha runs.
    GetSookshmaDashasResponseSookshmaDashasItemAntardashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Full details of the parent Pratyantardasha including start/end dates and duration.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSookshmaDashasResponsePratyantardashaPeriod {
    /// Parent Antardasha lord under which this Pratyantardasha runs.
    #[serde(rename = "antardashaLord")]
    pub antardasha_lord: GetSookshmaDashasResponsePratyantardashaPeriodAntardashaLord,
    /// Duration of this dasha period in years. Mahadasha durations range from 6 years (Sun) to 20 years (Venus).
    #[serde(rename = "durationYears")]
    pub duration_years: f64,
    /// End datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Vedic interpretation of the planetary period describing themes, karmic lessons, and life areas affected by this graha.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interpretation: Option<String>,
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    #[serde(rename = "mahadashaLord")]
    pub mahadasha_lord: GetSookshmaDashasResponsePratyantardashaPeriodMahadashaLord,
    /// Theoretical start of this period, present ONLY when the birth date truncated it. The Vimshottari cycle is already running when a native is born, so the period in force at birth began earlier: startDate is clipped to the birth moment while this field keeps the real start. Its presence is also why the first period of a chart can contain fewer than 9 sub-periods, the earlier ones having finished before birth. Absent on every period that runs its full length.
    #[serde(rename = "nominalStartDate", skip_serializing_if = "Option::is_none")]
    pub nominal_start_date: Option<String>,
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    pub planet: GetSookshmaDashasResponsePratyantardashaPeriodPlanet,
    /// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub significators: Option<
        GetSookshmaDashasResponsePratyantardashaPeriodSignificators,
    >,
    /// Start datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "startDate")]
    pub start_date: String,
}
/// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSookshmaDashasResponsePratyantardashaPeriodSignificators {
    /// House 1-12 this lord occupies in the Placidus birth chart. Its own Level 2 signification, repeated here because the occupied house is the first thing a KP reading looks at.
    pub house: i64,
    /// Every house this lord signifies, deduplicated and ordered strongest tier first. Where a house is reached at more than one level it is listed once, at its strongest. This is the flat "houses signified" column of a KP dasha table.
    #[serde(rename = "signifiedHouses")]
    pub signified_houses: Vec<i64>,
    /// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
    pub signifies: GetSookshmaDashasResponsePratyantardashaPeriodSignificatorsSignifies,
    /// Lord of the nakshatra this planet sits in, one of the 9 grahas. In KP the star lord outranks the planet itself: a period lord mainly delivers the houses its star lord occupies and owns, which is why those appear at L1 and L3 rather than the planet own house.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
    pub strength: GetSookshmaDashasResponsePratyantardashaPeriodSignificatorsStrength,
    /// Subset of signifiedHouses reached at grade A or B (levels L1 and L2). These are the houses a KP reading acts on for this period; the rest are supporting connections.
    #[serde(rename = "strongHouses")]
    pub strong_houses: Vec<i64>,
    /// KP sub lord of this planet, the 1 of 249 subdivision its longitude falls in, one of the 9 grahas. The star lord says WHAT results the period gives, the sub lord says WHETHER they materialize, so KP judgement checks both.
    #[serde(rename = "subLord", skip_serializing_if = "Option::is_none")]
    pub sub_lord: Option<String>,
}
/// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSookshmaDashasResponsePratyantardashaPeriodSignificatorsStrength {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    pub grade: GetSookshmaDashasResponsePratyantardashaPeriodSignificatorsStrengthGrade,
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    pub label: GetSookshmaDashasResponsePratyantardashaPeriodSignificatorsStrengthLabel,
    /// Mean KP percentage weight across signifiedHouses, each house counted at its strongest level (A 100, B 75, C 50, D 25). A mean rather than a total, so signifying many houses weakly does not outrank signifying two houses at grade A.
    pub score: f64,
}
string_enum! {
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    GetSookshmaDashasResponsePratyantardashaPeriodSignificatorsStrengthLabel {
        VeryStrong = "very-strong",
        Strong = "strong",
        Moderate = "moderate",
        Weak = "weak",
    }
}
string_enum! {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    GetSookshmaDashasResponsePratyantardashaPeriodSignificatorsStrengthGrade {
        A = "A",
        B = "B",
        C = "C",
        D = "D",
    }
}
/// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSookshmaDashasResponsePratyantardashaPeriodSignificatorsSignifies {
    /// Level 1, the strongest signification (grade A). Houses influenced because this planet sits in the nakshatra (star) of a planet occupying those houses. For Rahu and Ketu, also includes the L1 houses of their agent planets (conjoined, aspecting, sign lord).
    #[serde(rename = "L1")]
    pub l1: Vec<i64>,
    /// Level 2 (grade B). The house this planet physically occupies. For Rahu and Ketu, also includes houses occupied by their agent planets.
    #[serde(rename = "L2")]
    pub l2: Vec<i64>,
    /// Level 3 (grade C). Houses influenced because this planet sits in the nakshatra of the sign lord (owner) of those houses. For Rahu and Ketu, also includes the L3 houses of their agent planets.
    #[serde(rename = "L3")]
    pub l3: Vec<i64>,
    /// Level 4, the weakest signification (grade D). Houses this planet rules by zodiac sign ownership, up to 2 for Sun through Saturn and 3 where a sign is intercepted. Rahu and Ketu own no sign, so their L4 comes entirely from their agent planets.
    #[serde(rename = "L4")]
    pub l4: Vec<i64>,
}
string_enum! {
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    GetSookshmaDashasResponsePratyantardashaPeriodPlanet {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    GetSookshmaDashasResponsePratyantardashaPeriodMahadashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Parent Antardasha lord under which this Pratyantardasha runs.
    GetSookshmaDashasResponsePratyantardashaPeriodAntardashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Ruling planet of the requested Pratyantardasha sub-sub-period.
    GetSookshmaDashasResponsePratyantardashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Ruling planet of the requested Mahadasha period.
    GetSookshmaDashasResponseMahadashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSookshmaDashasResponseHouseThemes {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, Vec<String>>,
}
string_enum! {
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    GetSookshmaDashasResponseFocus {
        General = "general",
        Finance = "finance",
    }
}
string_enum! {
    /// Ayanamsa system used, echoing the request field. One of "lahiri", "kp-newcomb", "kp-old" or "custom". Echoed so a client can confirm which frame produced these dates without re-deriving it. When it reads "custom" the ayanamsa field above carries the exact value you supplied.
    GetSookshmaDashasResponseAyanamsaType {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
string_enum! {
    /// Ruling planet of the requested Antardasha sub-period.
    GetSookshmaDashasResponseAntardashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Request body of `getSookshmaDashas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSookshmaDashasRequest {
    /// Ayanamsa system used to place the birth Moon in its nakshatra, which sets every dasha start and end date. "lahiri" uses Lahiri/Chitrapaksha, the traditional Vedic standard, and is the default. "kp-newcomb" uses the KP-Newcomb dynamic formula, matching Krishnamurti Paddhati software. "kp-old" uses the Krishnamurti original table from KP Reader-1. "raman" uses the B.V. Raman ayanamsa, the second frame traditional Indian software commonly offers beside Lahiri. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. Switching frames shifts every dasha boundary by weeks, so pick the one your reference software uses.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<GetSookshmaDashasRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Lunar node type for Rahu and Ketu, used ONLY when "significators" is true. Dasha dates themselves come from the Moon and never move with this field. "mean" uses the smooth mean node (traditional default). "true" uses the osculating node, which swings up to 1.5 degrees either side of mean over a 173-day cycle and can therefore change which house or star a node falls in. Defaults to "mean".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<GetSookshmaDashasRequestNodeType>,
    /// Set true to attach the KP significators of each period lord: its star lord, sub lord, occupied house, the houses it signifies at levels L1 to L4, and a strength grade. Off by default, so responses stay exactly as they are for clients that only need dates. Requires the birth latitude and longitude, since significators are read off a Placidus house chart, and uses the same ayanamsa frame selected above.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub significators: Option<bool>,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetSookshmaDashasRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetSookshmaDashasRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node type for Rahu and Ketu, used ONLY when "significators" is true. Dasha dates themselves come from the Moon and never move with this field. "mean" uses the smooth mean node (traditional default). "true" uses the osculating node, which swings up to 1.5 degrees either side of mean over a 173-day cycle and can therefore change which house or star a node falls in. Defaults to "mean".
    GetSookshmaDashasRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// Ayanamsa system used to place the birth Moon in its nakshatra, which sets every dasha start and end date. "lahiri" uses Lahiri/Chitrapaksha, the traditional Vedic standard, and is the default. "kp-newcomb" uses the KP-Newcomb dynamic formula, matching Krishnamurti Paddhati software. "kp-old" uses the Krishnamurti original table from KP Reader-1. "raman" uses the B.V. Raman ayanamsa, the second frame traditional Indian software commonly offers beside Lahiri. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. Switching frames shifts every dasha boundary by weeks, so pick the one your reference software uses.
    GetSookshmaDashasRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Path and query parameters of `getSookshmaDashas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSookshmaDashasParams {
    /// Antardasha (bhukti) planet name inside that Mahadasha, case-insensitive.
    pub antardasha: GetSookshmaDashasParamsAntardasha,
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<GetSookshmaDashasParamsFocus>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetSookshmaDashasParamsLang>,
    /// Mahadasha planet name, case-insensitive. Valid: Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury.
    pub mahadasha: GetSookshmaDashasParamsMahadasha,
    /// Pratyantardasha (antara) planet name inside that Antardasha, case-insensitive.
    pub pratyantardasha: GetSookshmaDashasParamsPratyantardasha,
}
string_enum! {
    /// Pratyantardasha (antara) planet name inside that Antardasha, case-insensitive.
    GetSookshmaDashasParamsPratyantardasha {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Mahadasha planet name, case-insensitive. Valid: Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury.
    GetSookshmaDashasParamsMahadasha {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetSookshmaDashasParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    GetSookshmaDashasParamsFocus {
        General = "general",
        Finance = "finance",
    }
}
string_enum! {
    /// Antardasha (bhukti) planet name inside that Mahadasha, case-insensitive.
    GetSookshmaDashasParamsAntardasha {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Response body of `getShemName`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetShemNameResponse {
    /// Last degree of the arc, EXCLUSIVE. Seventy two arcs of five degrees tile the circle exactly, which only works if the upper bound is exclusive.
    #[serde(rename = "arcEnd")]
    pub arc_end: f64,
    /// First degree of the ecliptic arc this name governs, measured from 0 Aries. Inclusive.
    #[serde(rename = "arcStart")]
    pub arc_start: f64,
    /// The angelic choir this name belongs to under the published Renaissance table. Nine choirs of exactly eight names each.
    pub choir: String,
    /// Where the arc opens inside its sign, 0 to 25 in steps of five.
    #[serde(rename = "degreeInSign")]
    pub degree_in_sign: f64,
    /// The three letters read out of the verses, with any word final form written as its base letter, which is how every published list prints them.
    pub letters: String,
    /// The three letters exactly as they stand in the verses. Eighteen of the seventy two pick up a word final form because the source letter falls at a word end, and keeping this beside the normalized form is what makes the rule auditable.
    #[serde(rename = "lettersAsWritten")]
    pub letters_as_written: String,
    /// The suffixed name in Hebrew. Data, identical in every language.
    pub name: String,
    /// Index of the name, 1 to 72. The index is the identifier here, because the Latin spellings differ between published tables while the index never does.
    pub number: f64,
    /// Present only on the rows where a named published list differs from the derivation. Recorded rather than silently corrected, because a reader comparing two sources deserves to know which one moved. Absent on every other row, so a caller can branch on presence.
    #[serde(rename = "publishedDisagreement", skip_serializing_if = "Option::is_none")]
    pub published_disagreement: Option<GetShemNameResponsePublishedDisagreement>,
    /// Latin transcription of the Hebrew, from the one mechanical letter map. A label for reading the string back, and NOT the spelling the published tables print, which is in traditionalName.
    pub romanization: String,
    /// Which sign the arc falls in. Always English lowercase, so it stays safe to compare against in code. Six names fall in each sign.
    pub sign: String,
    /// The divine name suffix added to make the triplet pronounceable. Forty of the seventy two take one and thirty two take the other.
    pub suffix: String,
    /// The Latin spelling the published tables print. This is the search term a reader knows the name by. Several rows have two attested spellings across tables and the one used here is stated on the methodology page.
    #[serde(rename = "traditionalName")]
    pub traditional_name: String,
}
/// Present only on the rows where a named published list differs from the derivation. Recorded rather than silently corrected, because a reader comparing two sources deserves to know which one moved. Absent on every other row, so a caller can branch on presence.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetShemNameResponsePublishedDisagreement {
    /// Which published list prints something different on this row.
    pub list: String,
    /// What that list prints, so a caller matching against it can see why.
    pub prints: String,
}
/// Path and query parameters of `getShemName`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetShemNameParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetShemNameParamsLang>,
    /// Index of the name, 1 to 72.
    pub number: i64,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetShemNameParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getSephirah`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSephirahResponse {
    /// The sphere assigned to the sephirah under the requested system, in the requested language. This is the sephirot allotment and it is NOT the planet series the seven double letters carry.
    pub attribution: String,
    /// The conventions this answer was computed under.
    pub conventions: GetSephirahResponseConventions,
    /// The English gloss of the name, in the requested language.
    pub english: String,
    /// The name in Hebrew, with vowel points. Data, identical in every language.
    pub hebrew: String,
    /// Machine identifier of the sephirah, an ASCII romanization, always English so it stays safe to compare against in code. Several romanizations of each name are in circulation and none is canonical, which is exactly why the id is fixed here.
    pub id: String,
    /// What the emanation is said to hold, in the requested language.
    pub meaning: String,
    /// Position in the emanation, 1 to 10. Null for Daat, which is counted in some diagrams and left out of others and is never an eleventh emanation.
    pub number: Option<f64>,
    /// Every path that runs to or from this sephirah, in path order. Malkuth carries three under the arrangement this API ships, which is the whole difference between the two arrangements in circulation.
    pub paths: Vec<GetSephirahResponsePathsItem>,
    /// Which of the three pillars the sephirah stands on: left, middle or right. Always English.
    pub pillar: String,
    /// Display name of the pillar, in the requested language.
    #[serde(rename = "pillarName")]
    pub pillar_name: String,
    /// Latin transcription of the Hebrew beside it, from the one mechanical letter map. A label for reading the string back, never a pronunciation claim and not the same thing as the id.
    pub romanization: String,
    /// Which of the four worlds the sephirah belongs to under the Hermetic mapping. Null for Daat. A second mapping is in circulation and both are returned in the worlds block.
    pub world: Option<String>,
}
/// One entry of `paths`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSephirahResponsePathsItem {
    /// The `attribution` field.
    pub attribution: GetSephirahResponsePathsItemAttribution,
    /// Machine identifier of the sephirah the path runs from.
    pub from: String,
    /// Machine identifier of the letter on the path. Each of the 22 appears exactly once.
    pub letter: String,
    /// The letter itself. Data, identical in every language.
    #[serde(rename = "letterGlyph")]
    pub letter_glyph: String,
    /// Path number, 11 to 32. The numbering continues the ten sephirot into the thirty two Paths of Wisdom, so path 11 is the eleventh Path and not the eleventh path.
    pub path: f64,
    /// Machine identifier of the sephirah the path runs to.
    pub to: String,
    /// The `trump` field.
    pub trump: GetSephirahResponsePathsItemTrump,
}
/// The `trump` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSephirahResponsePathsItemTrump {
    /// Identifier of the tarot trump on this path. It resolves in the Tarot API on the same key.
    pub id: String,
    /// Display name of the trump.
    pub name: String,
    /// The trump number as the deck prints it.
    pub number: String,
}
/// The `attribution` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSephirahResponsePathsItemAttribution {
    /// What the letter attribution names: element, planet or sign.
    pub kind: String,
    /// The element, planet or sign under the requested reading. Always English.
    pub value: String,
}
/// The conventions this answer was computed under.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSephirahResponseConventions {
    /// Which reading assigned the element, planet or sign on each path.
    #[serde(rename = "letterAttribution")]
    pub letter_attribution: String,
    /// Which reading assigned the sphere.
    #[serde(rename = "sephirotSystem")]
    pub sephirot_system: String,
}
/// Path and query parameters of `getSephirah`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetSephirahParams {
    /// Sephirah identifier, one of keter, chokhmah, binah, chesed, gevurah, tiferet, netzach, hod, yesod, malkuth, daat. Matching folds case and punctuation.
    pub id: GetSephirahParamsId,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetSephirahParamsLang>,
    /// Which reading assigns the element, planet or sign to each letter. The seven double letters are the contested column and the four readings genuinely disagree on them; the twelve simple letters run in natural zodiacal order in all four. The golden-dawn member does NOT exchange He and Tzade, which is a later change from a different author.
    #[serde(rename = "letterAttribution", skip_serializing_if = "Option::is_none")]
    pub letter_attribution: Option<GetSephirahParamsLetterAttribution>,
    /// Which reading assigns a sphere to each sephirah. The two were compared row by row and agree on all ten, so the answer is the same either way; the parameter exists so a caller knows which one produced it rather than assuming.
    #[serde(rename = "sephirotSystem", skip_serializing_if = "Option::is_none")]
    pub sephirot_system: Option<GetSephirahParamsSephirotSystem>,
}
string_enum! {
    /// Which reading assigns a sphere to each sephirah. The two were compared row by row and agree on all ten, so the answer is the same either way; the parameter exists so a caller knows which one produced it rather than assuming.
    GetSephirahParamsSephirotSystem {
        Classical = "classical",
        GoldenDawn = "golden-dawn",
    }
}
string_enum! {
    /// Which reading assigns the element, planet or sign to each letter. The seven double letters are the contested column and the four readings genuinely disagree on them; the twelve simple letters run in natural zodiacal order in all four. The golden-dawn member does NOT exchange He and Tzade, which is a later change from a different author.
    GetSephirahParamsLetterAttribution {
        SeferYetzirahGra = "sefer-yetzirah-gra",
        SeferYetzirahShort = "sefer-yetzirah-short",
        SeferYetzirahSaadia = "sefer-yetzirah-saadia",
        GoldenDawn = "golden-dawn",
    }
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetSephirahParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Sephirah identifier, one of keter, chokhmah, binah, chesed, gevurah, tiferet, netzach, hod, yesod, malkuth, daat. Matching folds case and punctuation.
    GetSephirahParamsId {
        Keter = "keter",
        Chokhmah = "chokhmah",
        Binah = "binah",
        Chesed = "chesed",
        Gevurah = "gevurah",
        Tiferet = "tiferet",
        Netzach = "netzach",
        Hod = "hod",
        Yesod = "yesod",
        Malkuth = "malkuth",
        Daat = "daat",
    }
}
/// Response body of `getRitucharya`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetRitucharyaResponse {
    /// Which course the sun is in.
    pub ayana: GetRitucharyaResponseAyana,
    /// The conventions this reading was produced under.
    pub conventions: GetRitucharyaResponseConventions,
    /// The date this reading is for, echoing the request.
    pub date: String,
    /// Which humours the season moves, and how. A season moves at most three of the nine slots and often fewer, so an empty entry for a humour means the cycle simply says nothing about it in this season.
    #[serde(rename = "doshaCycle")]
    pub dosha_cycle: Vec<GetRitucharyaResponseDoshaCycleItem>,
    /// Scope of the response.
    pub meta: GetRitucharyaResponseMeta,
    /// The taking or giving half of the year.
    pub phase: GetRitucharyaResponsePhase,
    /// What the chapter states for this season. Roughly half its verses leave no item here once substances and clinical procedures are set aside, and those verses are absent rather than padded.
    pub regimen: Vec<GetRitucharyaResponseRegimenItem>,
    /// The season in force on this date.
    pub ritu: GetRitucharyaResponseRitu,
    /// Every work behind this response, once each.
    pub sources: Vec<GetRitucharyaResponseSourcesItem>,
    /// Where the season sits in the strength cycle.
    pub strength: GetRitucharyaResponseStrength,
    /// The season in prose, composed and translated in place.
    pub summary: String,
    /// The taste that grows IN NATURE across this season. It is not the taste to favour: the regimen for the same season is broadly the opposite, which is why this field is never named for a recommendation.
    #[serde(rename = "tasteIncreasing")]
    pub taste_increasing: GetRitucharyaResponseTasteIncreasing,
}
/// The taste that grows IN NATURE across this season. It is not the taste to favour: the regimen for the same season is broadly the opposite, which is why this field is never named for a recommendation.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetRitucharyaResponseTasteIncreasing {
    /// The taste in the requested language. This is the gloss and it does translate.
    pub english: String,
    /// The taste as a Sanskrit identifier. Never translated, so it stays safe to compare against and joins straight to the tastes catalogue.
    pub id: String,
    /// The same taste in the standard diacritic transliteration.
    #[serde(rename = "sanskritName")]
    pub sanskrit_name: String,
    /// Where one claim in this response comes from.
    pub source: GetRitucharyaResponseTasteIncreasingSource,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetRitucharyaResponseTasteIncreasingSource {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// Where the season sits in the strength cycle.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetRitucharyaResponseStrength {
    /// Bodily strength in this season: highest, moderate or lowest. Always English so it stays safe to switch on. The strongest pair is the cold season and the dewy season, which are adjacent in the cycle but sit at opposite ends of the two courses, and that wrap-around is the part a positional reading of the verse gets wrong.
    pub level: String,
    /// Where one claim in this response comes from.
    pub source: GetRitucharyaResponseStrengthSource,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetRitucharyaResponseStrengthSource {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetRitucharyaResponseSourcesItem {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// The season in force on this date.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetRitucharyaResponseRitu {
    /// The default-scheme season the classical layer was read from. Equal to the id in the ordinary case, and different under the alternate scheme, whose own verse states no strength cycle, taste cycle or dosha cycle for its seasons.
    #[serde(rename = "classicalRitu")]
    pub classical_ritu: String,
    /// The season in Devanagari. Data rather than a translation, so it is identical under every language.
    pub devanagari: String,
    /// When the season closes, as an ISO 8601 instant in UTC. It is the ingress that opens the next season, so two consecutive calls join without a gap.
    pub end: String,
    /// What the season is called in the requested language. This is the gloss and it does translate; the identifier above does not.
    pub gloss: String,
    /// The season as a Sanskrit identifier, always English-safe and never translated. One of sisira, vasanta, grisma, varsa, sarad and hemanta, plus pravrt which only the alternate scheme carries.
    pub id: String,
    /// The season in the standard diacritic transliteration.
    #[serde(rename = "sanskritName")]
    pub sanskrit_name: String,
    /// The two solar months the season spans, in order. A solar month is the interval the sun spends inside one rasi, which is why every boundary above is an ingress instant.
    #[serde(rename = "solarMonths")]
    pub solar_months: Vec<GetRitucharyaResponseRituSolarMonthsItem>,
    /// When the season opened, as an ISO 8601 instant in UTC. This is the ingress into the first of its two solar months, computed rather than tabulated, so it is exact to the second.
    pub start: String,
}
/// One of the two solar months the season spans.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetRitucharyaResponseRituSolarMonthsItem {
    /// The rasi as the lowercase English sign id every other RoxyAPI domain uses.
    pub id: String,
    /// Zero-based rasi index, 0 for Aries, so a caller can order the twelve without a name table.
    pub index: f64,
    /// The solar month under the name a panchang prints for it. Data, identical in every language.
    #[serde(rename = "sanskritName")]
    pub sanskrit_name: String,
}
/// One item of the seasonal regimen.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetRitucharyaResponseRegimenItem {
    /// The behaviour item, written from the source and translated in place. Behaviours, qualities and tastes only: the chapter also names specific substances and prescribes clinical procedures, and neither is carried here.
    pub guidance: String,
    /// Stable identifier for the item. Always English and lowercase, so it is safe to compare against.
    pub id: String,
    /// Where one claim in this response comes from.
    pub source: GetRitucharyaResponseRegimenItemSource,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetRitucharyaResponseRegimenItemSource {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// The taking or giving half of the year.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetRitucharyaResponsePhase {
    /// Whether the sun is taking or giving across this half of the year, as a Sanskrit identifier. Never translated, and deliberately so: the published translations render the two terms with four different English words between them, so an English value would not be stable enough to compare against.
    pub id: String,
    /// Where one claim in this response comes from.
    pub source: GetRitucharyaResponsePhaseSource,
    /// The three tastes that grow across this half of the year, in the order the verse gives them, one per season. This is the sequence the season taste below is one member of.
    pub tastes: Vec<GetRitucharyaResponsePhaseTastesItem>,
}
/// One of the six tastes, referenced from the seasonal cycle.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetRitucharyaResponsePhaseTastesItem {
    /// The taste in the requested language. This is the gloss and it does translate.
    pub english: String,
    /// The taste as a Sanskrit identifier. Never translated, so it stays safe to compare against and joins straight to the tastes catalogue.
    pub id: String,
    /// The same taste in the standard diacritic transliteration.
    #[serde(rename = "sanskritName")]
    pub sanskrit_name: String,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetRitucharyaResponsePhaseSource {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// Scope of the response.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetRitucharyaResponseMeta {
    /// The scope of everything in this response, in the requested language. Present on every response from this API, and intended to be shown to the reader rather than stripped.
    pub disclaimer: String,
}
/// One humour and where the season puts it.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetRitucharyaResponseDoshaCycleItem {
    /// The humour, as a Sanskrit identifier. Never translated.
    pub dosha: String,
    /// What the state is, in the requested language, defined by where the humour sits and how it behaves.
    pub meaning: String,
    /// A recorded disagreement about this row, present only where one exists.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Where the humour stands: accumulating, aggravated or settling. Always English so it stays safe to switch on. The three are positions and qualities rather than complaints, which is what the definitions below say.
    pub state: String,
}
/// The conventions this reading was produced under.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetRitucharyaResponseConventions {
    /// Which half of the world the season names are stated for. Echoes the request and is never inferred from a latitude.
    pub hemisphere: String,
    /// Which zodiac the boundaries were measured in. Echoes the request, and the two answers can differ by about 24 days.
    #[serde(rename = "rituZodiac")]
    pub ritu_zodiac: String,
    /// Which six-season division was applied. Echoes the request.
    #[serde(rename = "ritucharyaScheme")]
    pub ritucharya_scheme: String,
}
/// Which course the sun is in.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetRitucharyaResponseAyana {
    /// The half-year course of the sun, as a Sanskrit identifier. Never translated. It names what the sun is doing rather than what the weather is, so it is the same for every observer on the same day and is never rotated for the hemisphere.
    pub id: String,
    /// Where one claim in this response comes from.
    pub source: GetRitucharyaResponseAyanaSource,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetRitucharyaResponseAyanaSource {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// Path and query parameters of `getRitucharya`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetRitucharyaParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetRitucharyaParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetRitucharyaParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getReading`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetReadingResponse {
    /// Actionable 1-2 sentence guidance for the day based on the combined cycle analysis.
    pub advice: String,
    /// Birth date used for this calculation (YYYY-MM-DD).
    #[serde(rename = "birthDate")]
    pub birth_date: String,
    /// Critical day alerts. Present only when one or more primary cycles are at or near zero crossing.
    #[serde(rename = "criticalAlerts")]
    pub critical_alerts: Vec<GetReadingResponseCriticalAlertsItem>,
    /// All 10 biorhythm cycle readings. Keys: physical, emotional, intellectual, intuitive, aesthetic, awareness, spiritual, passion, mastery, wisdom.
    pub cycles: GetReadingResponseCycles,
    /// Total days alive from birth date to target date. This is the basis for all cycle calculations.
    #[serde(rename = "daysSinceBirth")]
    pub days_since_birth: f64,
    /// Overall energy score from 1 (deep recovery) to 10 (peak performance), derived from the three primary cycle positions.
    #[serde(rename = "energyRating")]
    pub energy_rating: f64,
    /// Editorial 3-5 sentence reading combining all cycle states into a coherent daily assessment.
    pub interpretation: String,
    /// Summary phase across every cycle for the day. One of: high_energy, mixed, recovery, critical.
    #[serde(rename = "overallPhase")]
    pub overall_phase: GetReadingResponseOverallPhase,
    /// Date this reading is for (YYYY-MM-DD).
    #[serde(rename = "targetDate")]
    pub target_date: String,
}
string_enum! {
    /// Summary phase across every cycle for the day. One of: high_energy, mixed, recovery, critical.
    GetReadingResponseOverallPhase {
        HighEnergy = "high_energy",
        Mixed = "mixed",
        Recovery = "recovery",
        Critical = "critical",
    }
}
/// All 10 biorhythm cycle readings. Keys: physical, emotional, intellectual, intuitive, aesthetic, awareness, spiritual, passion, mastery, wisdom.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetReadingResponseCycles {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<
        String,
        GetReadingResponseCyclesAdditionalProperty,
    >,
}
/// One cycle read for the target date: its position and raw sine value, phase and trend, day within the period, the distance to the next peak, trough and critical day, and a short reading.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetReadingResponseCyclesAdditionalProperty {
    /// Current day position within the cycle (1-based). Ranges from 1 to the cycle period length.
    #[serde(rename = "dayInCycle")]
    pub day_in_cycle: f64,
    /// Number of days until the next zero crossing in this cycle.
    #[serde(rename = "daysUntilCritical")]
    pub days_until_critical: f64,
    /// Number of days until the next peak (100%) in this cycle.
    #[serde(rename = "daysUntilPeak")]
    pub days_until_peak: f64,
    /// Number of days until the next trough (-100%) in this cycle.
    #[serde(rename = "daysUntilTrough")]
    pub days_until_trough: f64,
    /// Editorial 2-3 sentence reading specific to this cycle at its current phase position.
    pub interpretation: String,
    /// Current phase of the cycle. One of: peak, high, rising, critical_ascending, critical_descending, falling, low, trough. Canonical English whatever the lang parameter says, so it stays safe to compare against in code; phaseLabel carries the reader-facing form and IS translated.
    pub phase: GetReadingResponseCyclesAdditionalPropertyPhase,
    /// Human-readable phase name for display in UIs, dashboards, and reports.
    #[serde(rename = "phaseLabel")]
    pub phase_label: String,
    /// Raw sine wave value before percentage conversion, ranging from -1.0 to 1.0.
    #[serde(rename = "rawValue")]
    pub raw_value: f64,
    /// Short-term direction of the cycle, which is its SLOPE rather than its band, so it moves independently of phase. One of: rising, falling, peaking, bottoming. Canonical English, like phase.
    pub trend: GetReadingResponseCyclesAdditionalPropertyTrend,
    /// Percentage position in the cycle from -100 (trough) to 100 (peak). 0 represents a critical zero crossing.
    pub value: f64,
}
string_enum! {
    /// Short-term direction of the cycle, which is its SLOPE rather than its band, so it moves independently of phase. One of: rising, falling, peaking, bottoming. Canonical English, like phase.
    GetReadingResponseCyclesAdditionalPropertyTrend {
        Rising = "rising",
        Falling = "falling",
        Peaking = "peaking",
        Bottoming = "bottoming",
    }
}
string_enum! {
    /// Current phase of the cycle. One of: peak, high, rising, critical_ascending, critical_descending, falling, low, trough. Canonical English whatever the lang parameter says, so it stays safe to compare against in code; phaseLabel carries the reader-facing form and IS translated.
    GetReadingResponseCyclesAdditionalPropertyPhase {
        Peak = "peak",
        High = "high",
        Rising = "rising",
        CriticalAscending = "critical_ascending",
        CriticalDescending = "critical_descending",
        Falling = "falling",
        Low = "low",
        Trough = "trough",
    }
}
/// One entry of `criticalAlerts`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetReadingResponseCriticalAlertsItem {
    /// Specific advisory text for this critical alert.
    pub advisory: String,
    /// Which cycle is at or near zero crossing.
    pub cycle: GetReadingResponseCriticalAlertsItemCycle,
    /// Whether the cycle is rising through zero (ascending) or falling through zero (descending).
    pub direction: GetReadingResponseCriticalAlertsItemDirection,
    /// Alert type. One of: zero_crossing. Raised once for the whole critical band, when the cycle sits within 9 points of zero in either direction.
    pub r#type: GetReadingResponseCriticalAlertsItemType,
}
string_enum! {
    /// Alert type. One of: zero_crossing. Raised once for the whole critical band, when the cycle sits within 9 points of zero in either direction.
    GetReadingResponseCriticalAlertsItemType {
        ZeroCrossing = "zero_crossing",
    }
}
string_enum! {
    /// Whether the cycle is rising through zero (ascending) or falling through zero (descending).
    GetReadingResponseCriticalAlertsItemDirection {
        Ascending = "ascending",
        Descending = "descending",
    }
}
string_enum! {
    /// Which cycle is at or near zero crossing.
    GetReadingResponseCriticalAlertsItemCycle {
        Physical = "physical",
        Emotional = "emotional",
        Intellectual = "intellectual",
        Intuitive = "intuitive",
        Aesthetic = "aesthetic",
        Awareness = "awareness",
        Spiritual = "spiritual",
        Passion = "passion",
        Mastery = "mastery",
        Wisdom = "wisdom",
    }
}
/// Path and query parameters of `getReading`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetReadingParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetReadingParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetReadingParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `getRashi`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetRashiParams {
    /// Rashi ID slug. One of: mesha, vrishabha, mithun, karka, simha, kanya, tula, vrischika, dhanu, makar, kumbha, meen.
    pub id: GetRashiParamsId,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetRashiParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetRashiParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Rashi ID slug. One of: mesha, vrishabha, mithun, karka, simha, kanya, tula, vrischika, dhanu, makar, kumbha, meen.
    GetRashiParamsId {
        Mesha = "mesha",
        Vrishabha = "vrishabha",
        Mithun = "mithun",
        Karka = "karka",
        Simha = "simha",
        Kanya = "kanya",
        Tula = "tula",
        Vrischika = "vrischika",
        Dhanu = "dhanu",
        Makar = "makar",
        Kumbha = "kumbha",
        Meen = "meen",
    }
}
/// Response body of `getRandomSymbols`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetRandomSymbolsResponse {
    /// The `symbols` field.
    pub symbols: Vec<DreamSymbol>,
}
/// Response body of `getDreamSymbol`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DreamSymbol {
    /// Unique symbol identifier in kebab-case. Use this to fetch full interpretation via /symbols/{id}.
    pub id: String,
    /// Starting letter (a-z) for alphabetical dream dictionary navigation.
    pub letter: String,
    /// Full psychological dream interpretation explaining the subconscious symbolism, emotional significance, and waking-life connections of this dream symbol.
    pub meaning: String,
    /// Display name of the dream symbol.
    pub name: String,
}
/// Path and query parameters of `getRandomHexagram`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetRandomHexagramParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetRandomHexagramParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetRandomHexagramParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `getRandomCrystal`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetRandomCrystalParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetRandomCrystalParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetRandomCrystalParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getPratyantardashas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPratyantardashasResponse {
    /// Ruling planet of the requested Antardasha sub-period.
    #[serde(rename = "antardashaLord")]
    pub antardasha_lord: GetPratyantardashasResponseAntardashaLord,
    /// Full details of the parent Antardasha including start/end dates and duration.
    #[serde(rename = "antardashaPeriod")]
    pub antardasha_period: GetPratyantardashasResponseAntardashaPeriod,
    /// Ayanamsa actually applied, in degrees. The precession offset subtracted from the tropical (sayana) longitude to get the sidereal (nirayana) one. Lahiri sits near 23 deg 43 min for a 1990 birth, KP-Newcomb near 23 deg 38 min.
    pub ayanamsa: f64,
    /// Ayanamsa system used, echoing the request field. One of "lahiri", "kp-newcomb", "kp-old" or "custom". Echoed so a client can confirm which frame produced these dates without re-deriving it. When it reads "custom" the ayanamsa field above carries the exact value you supplied.
    #[serde(rename = "ayanamsaType")]
    pub ayanamsa_type: GetPratyantardashasResponseAyanamsaType,
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<GetPratyantardashasResponseFocus>,
    /// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
    #[serde(rename = "houseThemes", skip_serializing_if = "Option::is_none")]
    pub house_themes: Option<GetPratyantardashasResponseHouseThemes>,
    /// Ruling planet of the requested Mahadasha period.
    #[serde(rename = "mahadashaLord")]
    pub mahadasha_lord: GetPratyantardashasResponseMahadashaLord,
    /// Sidereal (nirayana) longitude of the birth Moon in degrees, 0 to 360, measured in the ayanamsa frame reported below. This single value determines the birth nakshatra and therefore every dasha start and end date in this response. Compare it against a reference chart to reconcile any date difference at its source.
    #[serde(rename = "moonLongitude")]
    pub moon_longitude: f64,
    /// Pratyantardasha (antara) periods within this Antardasha, proportional to each planet Vimshottari years, sorted chronologically and starting with the Antardasha lord. Fewer than nine only when the parent Antardasha is the one that was already running at birth, in which case the periods that ended before the birth date are omitted.
    pub pratyantardashas: Vec<GetPratyantardashasResponsePratyantardashasItem>,
}
/// Pratyantardasha (sub-sub-period), the third level of the Vimshottari dasha hierarchy, Provides finer timing within each Antardasha for event prediction.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPratyantardashasResponsePratyantardashasItem {
    /// Parent Antardasha lord under which this Pratyantardasha runs.
    #[serde(rename = "antardashaLord")]
    pub antardasha_lord: GetPratyantardashasResponsePratyantardashasItemAntardashaLord,
    /// Duration of this dasha period in years. Mahadasha durations range from 6 years (Sun) to 20 years (Venus).
    #[serde(rename = "durationYears")]
    pub duration_years: f64,
    /// End datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Vedic interpretation of the planetary period describing themes, karmic lessons, and life areas affected by this graha.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interpretation: Option<String>,
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    #[serde(rename = "mahadashaLord")]
    pub mahadasha_lord: GetPratyantardashasResponsePratyantardashasItemMahadashaLord,
    /// Theoretical start of this period, present ONLY when the birth date truncated it. The Vimshottari cycle is already running when a native is born, so the period in force at birth began earlier: startDate is clipped to the birth moment while this field keeps the real start. Its presence is also why the first period of a chart can contain fewer than 9 sub-periods, the earlier ones having finished before birth. Absent on every period that runs its full length.
    #[serde(rename = "nominalStartDate", skip_serializing_if = "Option::is_none")]
    pub nominal_start_date: Option<String>,
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    pub planet: GetPratyantardashasResponsePratyantardashasItemPlanet,
    /// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub significators: Option<
        GetPratyantardashasResponsePratyantardashasItemSignificators,
    >,
    /// Start datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "startDate")]
    pub start_date: String,
}
/// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPratyantardashasResponsePratyantardashasItemSignificators {
    /// House 1-12 this lord occupies in the Placidus birth chart. Its own Level 2 signification, repeated here because the occupied house is the first thing a KP reading looks at.
    pub house: i64,
    /// Every house this lord signifies, deduplicated and ordered strongest tier first. Where a house is reached at more than one level it is listed once, at its strongest. This is the flat "houses signified" column of a KP dasha table.
    #[serde(rename = "signifiedHouses")]
    pub signified_houses: Vec<i64>,
    /// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
    pub signifies: GetPratyantardashasResponsePratyantardashasItemSignificatorsSignifies,
    /// Lord of the nakshatra this planet sits in, one of the 9 grahas. In KP the star lord outranks the planet itself: a period lord mainly delivers the houses its star lord occupies and owns, which is why those appear at L1 and L3 rather than the planet own house.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
    pub strength: GetPratyantardashasResponsePratyantardashasItemSignificatorsStrength,
    /// Subset of signifiedHouses reached at grade A or B (levels L1 and L2). These are the houses a KP reading acts on for this period; the rest are supporting connections.
    #[serde(rename = "strongHouses")]
    pub strong_houses: Vec<i64>,
    /// KP sub lord of this planet, the 1 of 249 subdivision its longitude falls in, one of the 9 grahas. The star lord says WHAT results the period gives, the sub lord says WHETHER they materialize, so KP judgement checks both.
    #[serde(rename = "subLord", skip_serializing_if = "Option::is_none")]
    pub sub_lord: Option<String>,
}
/// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPratyantardashasResponsePratyantardashasItemSignificatorsStrength {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    pub grade: GetPratyantardashasResponsePratyantardashasItemSignificatorsStrengthGrade,
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    pub label: GetPratyantardashasResponsePratyantardashasItemSignificatorsStrengthLabel,
    /// Mean KP percentage weight across signifiedHouses, each house counted at its strongest level (A 100, B 75, C 50, D 25). A mean rather than a total, so signifying many houses weakly does not outrank signifying two houses at grade A.
    pub score: f64,
}
string_enum! {
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    GetPratyantardashasResponsePratyantardashasItemSignificatorsStrengthLabel {
        VeryStrong = "very-strong",
        Strong = "strong",
        Moderate = "moderate",
        Weak = "weak",
    }
}
string_enum! {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    GetPratyantardashasResponsePratyantardashasItemSignificatorsStrengthGrade {
        A = "A",
        B = "B",
        C = "C",
        D = "D",
    }
}
/// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPratyantardashasResponsePratyantardashasItemSignificatorsSignifies {
    /// Level 1, the strongest signification (grade A). Houses influenced because this planet sits in the nakshatra (star) of a planet occupying those houses. For Rahu and Ketu, also includes the L1 houses of their agent planets (conjoined, aspecting, sign lord).
    #[serde(rename = "L1")]
    pub l1: Vec<i64>,
    /// Level 2 (grade B). The house this planet physically occupies. For Rahu and Ketu, also includes houses occupied by their agent planets.
    #[serde(rename = "L2")]
    pub l2: Vec<i64>,
    /// Level 3 (grade C). Houses influenced because this planet sits in the nakshatra of the sign lord (owner) of those houses. For Rahu and Ketu, also includes the L3 houses of their agent planets.
    #[serde(rename = "L3")]
    pub l3: Vec<i64>,
    /// Level 4, the weakest signification (grade D). Houses this planet rules by zodiac sign ownership, up to 2 for Sun through Saturn and 3 where a sign is intercepted. Rahu and Ketu own no sign, so their L4 comes entirely from their agent planets.
    #[serde(rename = "L4")]
    pub l4: Vec<i64>,
}
string_enum! {
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    GetPratyantardashasResponsePratyantardashasItemPlanet {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    GetPratyantardashasResponsePratyantardashasItemMahadashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Parent Antardasha lord under which this Pratyantardasha runs.
    GetPratyantardashasResponsePratyantardashasItemAntardashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Ruling planet of the requested Mahadasha period.
    GetPratyantardashasResponseMahadashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPratyantardashasResponseHouseThemes {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, Vec<String>>,
}
string_enum! {
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    GetPratyantardashasResponseFocus {
        General = "general",
        Finance = "finance",
    }
}
string_enum! {
    /// Ayanamsa system used, echoing the request field. One of "lahiri", "kp-newcomb", "kp-old" or "custom". Echoed so a client can confirm which frame produced these dates without re-deriving it. When it reads "custom" the ayanamsa field above carries the exact value you supplied.
    GetPratyantardashasResponseAyanamsaType {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Full details of the parent Antardasha including start/end dates and duration.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPratyantardashasResponseAntardashaPeriod {
    /// Duration of this dasha period in years. Mahadasha durations range from 6 years (Sun) to 20 years (Venus).
    #[serde(rename = "durationYears")]
    pub duration_years: f64,
    /// End datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Vedic interpretation of the planetary period describing themes, karmic lessons, and life areas affected by this graha.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interpretation: Option<String>,
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    #[serde(rename = "mahadashaLord")]
    pub mahadasha_lord: GetPratyantardashasResponseAntardashaPeriodMahadashaLord,
    /// Theoretical start of this period, present ONLY when the birth date truncated it. The Vimshottari cycle is already running when a native is born, so the period in force at birth began earlier: startDate is clipped to the birth moment while this field keeps the real start. Its presence is also why the first period of a chart can contain fewer than 9 sub-periods, the earlier ones having finished before birth. Absent on every period that runs its full length.
    #[serde(rename = "nominalStartDate", skip_serializing_if = "Option::is_none")]
    pub nominal_start_date: Option<String>,
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    pub planet: GetPratyantardashasResponseAntardashaPeriodPlanet,
    /// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub significators: Option<GetPratyantardashasResponseAntardashaPeriodSignificators>,
    /// Start datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "startDate")]
    pub start_date: String,
}
/// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPratyantardashasResponseAntardashaPeriodSignificators {
    /// House 1-12 this lord occupies in the Placidus birth chart. Its own Level 2 signification, repeated here because the occupied house is the first thing a KP reading looks at.
    pub house: i64,
    /// Every house this lord signifies, deduplicated and ordered strongest tier first. Where a house is reached at more than one level it is listed once, at its strongest. This is the flat "houses signified" column of a KP dasha table.
    #[serde(rename = "signifiedHouses")]
    pub signified_houses: Vec<i64>,
    /// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
    pub signifies: GetPratyantardashasResponseAntardashaPeriodSignificatorsSignifies,
    /// Lord of the nakshatra this planet sits in, one of the 9 grahas. In KP the star lord outranks the planet itself: a period lord mainly delivers the houses its star lord occupies and owns, which is why those appear at L1 and L3 rather than the planet own house.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
    pub strength: GetPratyantardashasResponseAntardashaPeriodSignificatorsStrength,
    /// Subset of signifiedHouses reached at grade A or B (levels L1 and L2). These are the houses a KP reading acts on for this period; the rest are supporting connections.
    #[serde(rename = "strongHouses")]
    pub strong_houses: Vec<i64>,
    /// KP sub lord of this planet, the 1 of 249 subdivision its longitude falls in, one of the 9 grahas. The star lord says WHAT results the period gives, the sub lord says WHETHER they materialize, so KP judgement checks both.
    #[serde(rename = "subLord", skip_serializing_if = "Option::is_none")]
    pub sub_lord: Option<String>,
}
/// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPratyantardashasResponseAntardashaPeriodSignificatorsStrength {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    pub grade: GetPratyantardashasResponseAntardashaPeriodSignificatorsStrengthGrade,
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    pub label: GetPratyantardashasResponseAntardashaPeriodSignificatorsStrengthLabel,
    /// Mean KP percentage weight across signifiedHouses, each house counted at its strongest level (A 100, B 75, C 50, D 25). A mean rather than a total, so signifying many houses weakly does not outrank signifying two houses at grade A.
    pub score: f64,
}
string_enum! {
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    GetPratyantardashasResponseAntardashaPeriodSignificatorsStrengthLabel {
        VeryStrong = "very-strong",
        Strong = "strong",
        Moderate = "moderate",
        Weak = "weak",
    }
}
string_enum! {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    GetPratyantardashasResponseAntardashaPeriodSignificatorsStrengthGrade {
        A = "A",
        B = "B",
        C = "C",
        D = "D",
    }
}
/// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPratyantardashasResponseAntardashaPeriodSignificatorsSignifies {
    /// Level 1, the strongest signification (grade A). Houses influenced because this planet sits in the nakshatra (star) of a planet occupying those houses. For Rahu and Ketu, also includes the L1 houses of their agent planets (conjoined, aspecting, sign lord).
    #[serde(rename = "L1")]
    pub l1: Vec<i64>,
    /// Level 2 (grade B). The house this planet physically occupies. For Rahu and Ketu, also includes houses occupied by their agent planets.
    #[serde(rename = "L2")]
    pub l2: Vec<i64>,
    /// Level 3 (grade C). Houses influenced because this planet sits in the nakshatra of the sign lord (owner) of those houses. For Rahu and Ketu, also includes the L3 houses of their agent planets.
    #[serde(rename = "L3")]
    pub l3: Vec<i64>,
    /// Level 4, the weakest signification (grade D). Houses this planet rules by zodiac sign ownership, up to 2 for Sun through Saturn and 3 where a sign is intercepted. Rahu and Ketu own no sign, so their L4 comes entirely from their agent planets.
    #[serde(rename = "L4")]
    pub l4: Vec<i64>,
}
string_enum! {
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    GetPratyantardashasResponseAntardashaPeriodPlanet {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    GetPratyantardashasResponseAntardashaPeriodMahadashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Ruling planet of the requested Antardasha sub-period.
    GetPratyantardashasResponseAntardashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Request body of `getPratyantardashas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPratyantardashasRequest {
    /// Ayanamsa system used to place the birth Moon in its nakshatra, which sets every dasha start and end date. "lahiri" uses Lahiri/Chitrapaksha, the traditional Vedic standard, and is the default. "kp-newcomb" uses the KP-Newcomb dynamic formula, matching Krishnamurti Paddhati software. "kp-old" uses the Krishnamurti original table from KP Reader-1. "raman" uses the B.V. Raman ayanamsa, the second frame traditional Indian software commonly offers beside Lahiri. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. Switching frames shifts every dasha boundary by weeks, so pick the one your reference software uses.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<GetPratyantardashasRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Lunar node type for Rahu and Ketu, used ONLY when "significators" is true. Dasha dates themselves come from the Moon and never move with this field. "mean" uses the smooth mean node (traditional default). "true" uses the osculating node, which swings up to 1.5 degrees either side of mean over a 173-day cycle and can therefore change which house or star a node falls in. Defaults to "mean".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<GetPratyantardashasRequestNodeType>,
    /// Set true to attach the KP significators of each period lord: its star lord, sub lord, occupied house, the houses it signifies at levels L1 to L4, and a strength grade. Off by default, so responses stay exactly as they are for clients that only need dates. Requires the birth latitude and longitude, since significators are read off a Placidus house chart, and uses the same ayanamsa frame selected above.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub significators: Option<bool>,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetPratyantardashasRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetPratyantardashasRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node type for Rahu and Ketu, used ONLY when "significators" is true. Dasha dates themselves come from the Moon and never move with this field. "mean" uses the smooth mean node (traditional default). "true" uses the osculating node, which swings up to 1.5 degrees either side of mean over a 173-day cycle and can therefore change which house or star a node falls in. Defaults to "mean".
    GetPratyantardashasRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// Ayanamsa system used to place the birth Moon in its nakshatra, which sets every dasha start and end date. "lahiri" uses Lahiri/Chitrapaksha, the traditional Vedic standard, and is the default. "kp-newcomb" uses the KP-Newcomb dynamic formula, matching Krishnamurti Paddhati software. "kp-old" uses the Krishnamurti original table from KP Reader-1. "raman" uses the B.V. Raman ayanamsa, the second frame traditional Indian software commonly offers beside Lahiri. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. Switching frames shifts every dasha boundary by weeks, so pick the one your reference software uses.
    GetPratyantardashasRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Path and query parameters of `getPratyantardashas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPratyantardashasParams {
    /// Antardasha (bhukti) planet name inside that Mahadasha, case-insensitive. Every Mahadasha contains all 9 lords, so a repeat such as saturn/saturn is valid.
    pub antardasha: GetPratyantardashasParamsAntardasha,
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<GetPratyantardashasParamsFocus>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetPratyantardashasParamsLang>,
    /// Mahadasha planet name, case-insensitive (e.g. saturn, Saturn, SATURN all work). Valid: Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury.
    pub mahadasha: GetPratyantardashasParamsMahadasha,
}
string_enum! {
    /// Mahadasha planet name, case-insensitive (e.g. saturn, Saturn, SATURN all work). Valid: Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury.
    GetPratyantardashasParamsMahadasha {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetPratyantardashasParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    GetPratyantardashasParamsFocus {
        General = "general",
        Finance = "finance",
    }
}
string_enum! {
    /// Antardasha (bhukti) planet name inside that Mahadasha, case-insensitive. Every Mahadasha contains all 9 lords, so a repeat such as saturn/saturn is valid.
    GetPratyantardashasParamsAntardasha {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Response body of `getPranaDashas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPranaDashasResponse {
    /// Ruling planet of the requested Antardasha sub-period.
    #[serde(rename = "antardashaLord")]
    pub antardasha_lord: GetPranaDashasResponseAntardashaLord,
    /// Ayanamsa actually applied, in degrees. The precession offset subtracted from the tropical (sayana) longitude to get the sidereal (nirayana) one. Lahiri sits near 23 deg 43 min for a 1990 birth, KP-Newcomb near 23 deg 38 min.
    pub ayanamsa: f64,
    /// Ayanamsa system used, echoing the request field. One of "lahiri", "kp-newcomb", "kp-old" or "custom". Echoed so a client can confirm which frame produced these dates without re-deriving it. When it reads "custom" the ayanamsa field above carries the exact value you supplied.
    #[serde(rename = "ayanamsaType")]
    pub ayanamsa_type: GetPranaDashasResponseAyanamsaType,
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<GetPranaDashasResponseFocus>,
    /// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
    #[serde(rename = "houseThemes", skip_serializing_if = "Option::is_none")]
    pub house_themes: Option<GetPranaDashasResponseHouseThemes>,
    /// Ruling planet of the requested Mahadasha period.
    #[serde(rename = "mahadashaLord")]
    pub mahadasha_lord: GetPranaDashasResponseMahadashaLord,
    /// Sidereal (nirayana) longitude of the birth Moon in degrees, 0 to 360, measured in the ayanamsa frame reported below. This single value determines the birth nakshatra and therefore every dasha start and end date in this response. Compare it against a reference chart to reconcile any date difference at its source.
    #[serde(rename = "moonLongitude")]
    pub moon_longitude: f64,
    /// Prana dasha periods within this Sookshma dasha, proportional to each planet Vimshottari years, sorted chronologically and starting with the Sookshma lord. Fewer than nine only when the parent Sookshma dasha is the one that was already running at birth, in which case the periods that ended before the birth date are omitted.
    #[serde(rename = "pranaDashas")]
    pub prana_dashas: Vec<GetPranaDashasResponsePranaDashasItem>,
    /// Ruling planet of the requested Pratyantardasha sub-sub-period.
    #[serde(rename = "pratyantardashaLord")]
    pub pratyantardasha_lord: GetPranaDashasResponsePratyantardashaLord,
    /// Ruling planet of the requested Sookshma dasha.
    #[serde(rename = "sookshmaLord")]
    pub sookshma_lord: GetPranaDashasResponseSookshmaLord,
    /// Full details of the parent Sookshma dasha including start/end dates and duration.
    #[serde(rename = "sookshmaPeriod")]
    pub sookshma_period: GetPranaDashasResponseSookshmaPeriod,
}
/// Full details of the parent Sookshma dasha including start/end dates and duration.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPranaDashasResponseSookshmaPeriod {
    /// Parent Antardasha lord under which this Pratyantardasha runs.
    #[serde(rename = "antardashaLord")]
    pub antardasha_lord: GetPranaDashasResponseSookshmaPeriodAntardashaLord,
    /// Duration of this dasha period in years. Mahadasha durations range from 6 years (Sun) to 20 years (Venus).
    #[serde(rename = "durationYears")]
    pub duration_years: f64,
    /// End datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Vedic interpretation of the planetary period describing themes, karmic lessons, and life areas affected by this graha.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interpretation: Option<String>,
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    #[serde(rename = "mahadashaLord")]
    pub mahadasha_lord: GetPranaDashasResponseSookshmaPeriodMahadashaLord,
    /// Theoretical start of this period, present ONLY when the birth date truncated it. The Vimshottari cycle is already running when a native is born, so the period in force at birth began earlier: startDate is clipped to the birth moment while this field keeps the real start. Its presence is also why the first period of a chart can contain fewer than 9 sub-periods, the earlier ones having finished before birth. Absent on every period that runs its full length.
    #[serde(rename = "nominalStartDate", skip_serializing_if = "Option::is_none")]
    pub nominal_start_date: Option<String>,
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    pub planet: GetPranaDashasResponseSookshmaPeriodPlanet,
    /// Parent Pratyantardasha lord under which this Sookshma dasha runs.
    #[serde(rename = "pratyantardashaLord")]
    pub pratyantardasha_lord: GetPranaDashasResponseSookshmaPeriodPratyantardashaLord,
    /// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub significators: Option<GetPranaDashasResponseSookshmaPeriodSignificators>,
    /// Start datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "startDate")]
    pub start_date: String,
}
/// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPranaDashasResponseSookshmaPeriodSignificators {
    /// House 1-12 this lord occupies in the Placidus birth chart. Its own Level 2 signification, repeated here because the occupied house is the first thing a KP reading looks at.
    pub house: i64,
    /// Every house this lord signifies, deduplicated and ordered strongest tier first. Where a house is reached at more than one level it is listed once, at its strongest. This is the flat "houses signified" column of a KP dasha table.
    #[serde(rename = "signifiedHouses")]
    pub signified_houses: Vec<i64>,
    /// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
    pub signifies: GetPranaDashasResponseSookshmaPeriodSignificatorsSignifies,
    /// Lord of the nakshatra this planet sits in, one of the 9 grahas. In KP the star lord outranks the planet itself: a period lord mainly delivers the houses its star lord occupies and owns, which is why those appear at L1 and L3 rather than the planet own house.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
    pub strength: GetPranaDashasResponseSookshmaPeriodSignificatorsStrength,
    /// Subset of signifiedHouses reached at grade A or B (levels L1 and L2). These are the houses a KP reading acts on for this period; the rest are supporting connections.
    #[serde(rename = "strongHouses")]
    pub strong_houses: Vec<i64>,
    /// KP sub lord of this planet, the 1 of 249 subdivision its longitude falls in, one of the 9 grahas. The star lord says WHAT results the period gives, the sub lord says WHETHER they materialize, so KP judgement checks both.
    #[serde(rename = "subLord", skip_serializing_if = "Option::is_none")]
    pub sub_lord: Option<String>,
}
/// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPranaDashasResponseSookshmaPeriodSignificatorsStrength {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    pub grade: GetPranaDashasResponseSookshmaPeriodSignificatorsStrengthGrade,
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    pub label: GetPranaDashasResponseSookshmaPeriodSignificatorsStrengthLabel,
    /// Mean KP percentage weight across signifiedHouses, each house counted at its strongest level (A 100, B 75, C 50, D 25). A mean rather than a total, so signifying many houses weakly does not outrank signifying two houses at grade A.
    pub score: f64,
}
string_enum! {
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    GetPranaDashasResponseSookshmaPeriodSignificatorsStrengthLabel {
        VeryStrong = "very-strong",
        Strong = "strong",
        Moderate = "moderate",
        Weak = "weak",
    }
}
string_enum! {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    GetPranaDashasResponseSookshmaPeriodSignificatorsStrengthGrade {
        A = "A",
        B = "B",
        C = "C",
        D = "D",
    }
}
/// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPranaDashasResponseSookshmaPeriodSignificatorsSignifies {
    /// Level 1, the strongest signification (grade A). Houses influenced because this planet sits in the nakshatra (star) of a planet occupying those houses. For Rahu and Ketu, also includes the L1 houses of their agent planets (conjoined, aspecting, sign lord).
    #[serde(rename = "L1")]
    pub l1: Vec<i64>,
    /// Level 2 (grade B). The house this planet physically occupies. For Rahu and Ketu, also includes houses occupied by their agent planets.
    #[serde(rename = "L2")]
    pub l2: Vec<i64>,
    /// Level 3 (grade C). Houses influenced because this planet sits in the nakshatra of the sign lord (owner) of those houses. For Rahu and Ketu, also includes the L3 houses of their agent planets.
    #[serde(rename = "L3")]
    pub l3: Vec<i64>,
    /// Level 4, the weakest signification (grade D). Houses this planet rules by zodiac sign ownership, up to 2 for Sun through Saturn and 3 where a sign is intercepted. Rahu and Ketu own no sign, so their L4 comes entirely from their agent planets.
    #[serde(rename = "L4")]
    pub l4: Vec<i64>,
}
string_enum! {
    /// Parent Pratyantardasha lord under which this Sookshma dasha runs.
    GetPranaDashasResponseSookshmaPeriodPratyantardashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    GetPranaDashasResponseSookshmaPeriodPlanet {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    GetPranaDashasResponseSookshmaPeriodMahadashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Parent Antardasha lord under which this Pratyantardasha runs.
    GetPranaDashasResponseSookshmaPeriodAntardashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Ruling planet of the requested Sookshma dasha.
    GetPranaDashasResponseSookshmaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Ruling planet of the requested Pratyantardasha sub-sub-period.
    GetPranaDashasResponsePratyantardashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Prana dasha (praana antardasha), the fifth and finest level of the Vimshottari dasha hierarchy. Each Sookshma dasha divides into 9 Prana periods, running from about 20 minutes inside a Sun Mahadasha to about 4 days inside a Saturn one. This is the level that takes Vimshottari from day-level to hour-level timing, used for muhurta selection and pinpointing the trigger inside an already identified window.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPranaDashasResponsePranaDashasItem {
    /// Parent Antardasha lord under which this Pratyantardasha runs.
    #[serde(rename = "antardashaLord")]
    pub antardasha_lord: GetPranaDashasResponsePranaDashasItemAntardashaLord,
    /// Duration of this dasha period in years. Mahadasha durations range from 6 years (Sun) to 20 years (Venus).
    #[serde(rename = "durationYears")]
    pub duration_years: f64,
    /// End datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Vedic interpretation of the planetary period describing themes, karmic lessons, and life areas affected by this graha.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interpretation: Option<String>,
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    #[serde(rename = "mahadashaLord")]
    pub mahadasha_lord: GetPranaDashasResponsePranaDashasItemMahadashaLord,
    /// Theoretical start of this period, present ONLY when the birth date truncated it. The Vimshottari cycle is already running when a native is born, so the period in force at birth began earlier: startDate is clipped to the birth moment while this field keeps the real start. Its presence is also why the first period of a chart can contain fewer than 9 sub-periods, the earlier ones having finished before birth. Absent on every period that runs its full length.
    #[serde(rename = "nominalStartDate", skip_serializing_if = "Option::is_none")]
    pub nominal_start_date: Option<String>,
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    pub planet: GetPranaDashasResponsePranaDashasItemPlanet,
    /// Parent Pratyantardasha lord under which this Sookshma dasha runs.
    #[serde(rename = "pratyantardashaLord")]
    pub pratyantardasha_lord: GetPranaDashasResponsePranaDashasItemPratyantardashaLord,
    /// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub significators: Option<GetPranaDashasResponsePranaDashasItemSignificators>,
    /// Parent Sookshma dasha lord under which this Prana dasha runs.
    #[serde(rename = "sookshmaLord")]
    pub sookshma_lord: GetPranaDashasResponsePranaDashasItemSookshmaLord,
    /// Start datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "startDate")]
    pub start_date: String,
}
string_enum! {
    /// Parent Sookshma dasha lord under which this Prana dasha runs.
    GetPranaDashasResponsePranaDashasItemSookshmaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPranaDashasResponsePranaDashasItemSignificators {
    /// House 1-12 this lord occupies in the Placidus birth chart. Its own Level 2 signification, repeated here because the occupied house is the first thing a KP reading looks at.
    pub house: i64,
    /// Every house this lord signifies, deduplicated and ordered strongest tier first. Where a house is reached at more than one level it is listed once, at its strongest. This is the flat "houses signified" column of a KP dasha table.
    #[serde(rename = "signifiedHouses")]
    pub signified_houses: Vec<i64>,
    /// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
    pub signifies: GetPranaDashasResponsePranaDashasItemSignificatorsSignifies,
    /// Lord of the nakshatra this planet sits in, one of the 9 grahas. In KP the star lord outranks the planet itself: a period lord mainly delivers the houses its star lord occupies and owns, which is why those appear at L1 and L3 rather than the planet own house.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
    pub strength: GetPranaDashasResponsePranaDashasItemSignificatorsStrength,
    /// Subset of signifiedHouses reached at grade A or B (levels L1 and L2). These are the houses a KP reading acts on for this period; the rest are supporting connections.
    #[serde(rename = "strongHouses")]
    pub strong_houses: Vec<i64>,
    /// KP sub lord of this planet, the 1 of 249 subdivision its longitude falls in, one of the 9 grahas. The star lord says WHAT results the period gives, the sub lord says WHETHER they materialize, so KP judgement checks both.
    #[serde(rename = "subLord", skip_serializing_if = "Option::is_none")]
    pub sub_lord: Option<String>,
}
/// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPranaDashasResponsePranaDashasItemSignificatorsStrength {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    pub grade: GetPranaDashasResponsePranaDashasItemSignificatorsStrengthGrade,
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    pub label: GetPranaDashasResponsePranaDashasItemSignificatorsStrengthLabel,
    /// Mean KP percentage weight across signifiedHouses, each house counted at its strongest level (A 100, B 75, C 50, D 25). A mean rather than a total, so signifying many houses weakly does not outrank signifying two houses at grade A.
    pub score: f64,
}
string_enum! {
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    GetPranaDashasResponsePranaDashasItemSignificatorsStrengthLabel {
        VeryStrong = "very-strong",
        Strong = "strong",
        Moderate = "moderate",
        Weak = "weak",
    }
}
string_enum! {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    GetPranaDashasResponsePranaDashasItemSignificatorsStrengthGrade {
        A = "A",
        B = "B",
        C = "C",
        D = "D",
    }
}
/// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPranaDashasResponsePranaDashasItemSignificatorsSignifies {
    /// Level 1, the strongest signification (grade A). Houses influenced because this planet sits in the nakshatra (star) of a planet occupying those houses. For Rahu and Ketu, also includes the L1 houses of their agent planets (conjoined, aspecting, sign lord).
    #[serde(rename = "L1")]
    pub l1: Vec<i64>,
    /// Level 2 (grade B). The house this planet physically occupies. For Rahu and Ketu, also includes houses occupied by their agent planets.
    #[serde(rename = "L2")]
    pub l2: Vec<i64>,
    /// Level 3 (grade C). Houses influenced because this planet sits in the nakshatra of the sign lord (owner) of those houses. For Rahu and Ketu, also includes the L3 houses of their agent planets.
    #[serde(rename = "L3")]
    pub l3: Vec<i64>,
    /// Level 4, the weakest signification (grade D). Houses this planet rules by zodiac sign ownership, up to 2 for Sun through Saturn and 3 where a sign is intercepted. Rahu and Ketu own no sign, so their L4 comes entirely from their agent planets.
    #[serde(rename = "L4")]
    pub l4: Vec<i64>,
}
string_enum! {
    /// Parent Pratyantardasha lord under which this Sookshma dasha runs.
    GetPranaDashasResponsePranaDashasItemPratyantardashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    GetPranaDashasResponsePranaDashasItemPlanet {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    GetPranaDashasResponsePranaDashasItemMahadashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Parent Antardasha lord under which this Pratyantardasha runs.
    GetPranaDashasResponsePranaDashasItemAntardashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Ruling planet of the requested Mahadasha period.
    GetPranaDashasResponseMahadashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPranaDashasResponseHouseThemes {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, Vec<String>>,
}
string_enum! {
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    GetPranaDashasResponseFocus {
        General = "general",
        Finance = "finance",
    }
}
string_enum! {
    /// Ayanamsa system used, echoing the request field. One of "lahiri", "kp-newcomb", "kp-old" or "custom". Echoed so a client can confirm which frame produced these dates without re-deriving it. When it reads "custom" the ayanamsa field above carries the exact value you supplied.
    GetPranaDashasResponseAyanamsaType {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
string_enum! {
    /// Ruling planet of the requested Antardasha sub-period.
    GetPranaDashasResponseAntardashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Request body of `getPranaDashas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPranaDashasRequest {
    /// Ayanamsa system used to place the birth Moon in its nakshatra, which sets every dasha start and end date. "lahiri" uses Lahiri/Chitrapaksha, the traditional Vedic standard, and is the default. "kp-newcomb" uses the KP-Newcomb dynamic formula, matching Krishnamurti Paddhati software. "kp-old" uses the Krishnamurti original table from KP Reader-1. "raman" uses the B.V. Raman ayanamsa, the second frame traditional Indian software commonly offers beside Lahiri. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. Switching frames shifts every dasha boundary by weeks, so pick the one your reference software uses.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<GetPranaDashasRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Lunar node type for Rahu and Ketu, used ONLY when "significators" is true. Dasha dates themselves come from the Moon and never move with this field. "mean" uses the smooth mean node (traditional default). "true" uses the osculating node, which swings up to 1.5 degrees either side of mean over a 173-day cycle and can therefore change which house or star a node falls in. Defaults to "mean".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<GetPranaDashasRequestNodeType>,
    /// Set true to attach the KP significators of each period lord: its star lord, sub lord, occupied house, the houses it signifies at levels L1 to L4, and a strength grade. Off by default, so responses stay exactly as they are for clients that only need dates. Requires the birth latitude and longitude, since significators are read off a Placidus house chart, and uses the same ayanamsa frame selected above.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub significators: Option<bool>,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetPranaDashasRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetPranaDashasRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node type for Rahu and Ketu, used ONLY when "significators" is true. Dasha dates themselves come from the Moon and never move with this field. "mean" uses the smooth mean node (traditional default). "true" uses the osculating node, which swings up to 1.5 degrees either side of mean over a 173-day cycle and can therefore change which house or star a node falls in. Defaults to "mean".
    GetPranaDashasRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// Ayanamsa system used to place the birth Moon in its nakshatra, which sets every dasha start and end date. "lahiri" uses Lahiri/Chitrapaksha, the traditional Vedic standard, and is the default. "kp-newcomb" uses the KP-Newcomb dynamic formula, matching Krishnamurti Paddhati software. "kp-old" uses the Krishnamurti original table from KP Reader-1. "raman" uses the B.V. Raman ayanamsa, the second frame traditional Indian software commonly offers beside Lahiri. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. Switching frames shifts every dasha boundary by weeks, so pick the one your reference software uses.
    GetPranaDashasRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Path and query parameters of `getPranaDashas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPranaDashasParams {
    /// Antardasha (bhukti) planet name inside that Mahadasha, case-insensitive.
    pub antardasha: GetPranaDashasParamsAntardasha,
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<GetPranaDashasParamsFocus>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetPranaDashasParamsLang>,
    /// Mahadasha planet name, case-insensitive. Valid: Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury.
    pub mahadasha: GetPranaDashasParamsMahadasha,
    /// Pratyantardasha (antara) planet name inside that Antardasha, case-insensitive.
    pub pratyantardasha: GetPranaDashasParamsPratyantardasha,
    /// Sookshma dasha planet name inside that Pratyantardasha, case-insensitive. Every full period contains all 9 lords, so a repeat such as saturn/saturn/saturn/saturn is valid.
    pub sookshma: GetPranaDashasParamsSookshma,
}
string_enum! {
    /// Sookshma dasha planet name inside that Pratyantardasha, case-insensitive. Every full period contains all 9 lords, so a repeat such as saturn/saturn/saturn/saturn is valid.
    GetPranaDashasParamsSookshma {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Pratyantardasha (antara) planet name inside that Antardasha, case-insensitive.
    GetPranaDashasParamsPratyantardasha {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Mahadasha planet name, case-insensitive. Valid: Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury.
    GetPranaDashasParamsMahadasha {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetPranaDashasParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    GetPranaDashasParamsFocus {
        General = "general",
        Finance = "finance",
    }
}
string_enum! {
    /// Antardasha (bhukti) planet name inside that Mahadasha, case-insensitive.
    GetPranaDashasParamsAntardasha {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Response body of `getPlanetaryPositions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPlanetaryPositionsResponse {
    /// All 14 celestial bodies (10 classical planets, lunar nodes, Chiron, Black Moon Lilith) with zodiac signs, speeds, retrograde status, meanings, and interpretations.
    pub planets: Vec<GetPlanetaryPositionsResponsePlanetsItem>,
}
/// One entry of `planets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPlanetaryPositionsResponsePlanetsItem {
    /// Degree within the zodiac sign (0-29.999).
    pub degree: f64,
    /// Brief description of this planet in astrological context.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Planet-in-sign interpretation. How this planet expresses through the zodiac sign it currently occupies.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interpretation: Option<GetPlanetaryPositionsResponsePlanetsItemInterpretation>,
    /// Whether the planet is in apparent retrograde motion.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Key themes and traits associated with this planet.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub keywords: Option<Vec<String>>,
    /// Apparent geocentric ecliptic latitude of date, in degrees.
    pub latitude: f64,
    /// Apparent geocentric tropical longitude on the true ecliptic of date, in degrees (0-360): light time and aberration applied, nutation included, the convention desktop chart software and the NASA JPL Horizons observer tables print, so it compares directly with either.
    pub longitude: f64,
    /// Planet name (Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto, North Node, South Node, Chiron, Black Moon Lilith). The lunar nodes follow the request nodeType, which defaults to the true (osculating) node; pass "mean" for the smoothed node. The two differ by up to about 1.8 degrees and no other body is affected. Black Moon Lilith is always the mean lunar apogee, whatever nodeType says. POST /lilith returns the mean and the true (osculating) apogee side by side, each labelled by its variant.
    pub name: String,
    /// Tropical zodiac sign this planet occupies.
    pub sign: String,
    /// Daily motion in degrees per day. Negative values indicate retrograde.
    pub speed: f64,
    /// Unicode astronomical symbol for this planet.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub symbol: Option<String>,
    /// Short tagline summarizing what this planet governs.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tagline: Option<String>,
}
/// Planet-in-sign interpretation. How this planet expresses through the zodiac sign it currently occupies.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPlanetaryPositionsResponsePlanetsItemInterpretation {
    /// Keywords for this specific planet-in-sign combination.
    pub keywords: Vec<String>,
    /// General meaning of this planet in astrology.
    #[serde(rename = "planetMeaning")]
    pub planet_meaning: String,
    /// How this planet expresses through the current sign.
    #[serde(rename = "signExpression")]
    pub sign_expression: String,
    /// Interpretation of this planet in its current zodiac sign.
    pub summary: String,
}
/// Request body of `getPlanetaryPositions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPlanetaryPositionsRequest {
    /// Target date for planetary positions in YYYY-MM-DD format. Use current date for transit positions, or any historical/future date for research. Planets move daily, so this date determines their zodiac positions.
    pub date: String,
    /// Observer latitude in decimal degrees (-90 to 90). While planetary longitudes are geocentric (same worldwide), this is needed for house calculations if extending functionality. For basic ephemeris, use 0 as default.
    pub latitude: f64,
    /// Observer longitude in decimal degrees (-180 to 180). Used for precise local time conversion. For basic planetary positions, this has minimal impact but ensures accuracy.
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<GetPlanetaryPositionsRequestNodeType>,
    /// Time in 24-hour HH:MM:SS format for precise calculations. Moon moves ~13° per day, so time matters for accurate lunar position. Use 12:00:00 (noon) as default if exact time not needed.
    pub time: String,
    /// Decimal hours from UTC (e.g. -5 for EST, 5.5 for IST, 9 for JST, 5.75 for NPT) OR IANA name (e.g. "America/New_York"). IANA resolved to the DST-correct offset for the chart date.
    pub timezone: GetPlanetaryPositionsRequestTimezone,
}
/// Decimal hours from UTC (e.g. -5 for EST, 5.5 for IST, 9 for JST, 5.75 for NPT) OR IANA name (e.g. "America/New_York"). IANA resolved to the DST-correct offset for the chart date.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetPlanetaryPositionsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    GetPlanetaryPositionsRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Path and query parameters of `getPlanetaryPositions`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetPlanetaryPositionsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetPlanetaryPositionsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetPlanetaryPositionsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getPlanetaryNodePassages`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPlanetaryNodePassagesResponse {
    /// Every node passage in the year, in chronological order across all bodies. The fast bodies dominate: a slow body can go years or decades between node passages, so an absent planet means it did not cross that year rather than that it was not checked.
    pub events: Vec<GetPlanetaryNodePassagesResponseEventsItem>,
    /// Timezone the dates and times are reported in. Echoes the request.
    pub timezone: f64,
    /// Year that was scanned. Echoes the request.
    pub year: f64,
}
/// One entry of `events`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPlanetaryNodePassagesResponseEventsItem {
    /// Date of the crossing in the requested timezone (YYYY-MM-DD).
    pub date: String,
    /// Combined crossing timestamp in the requested timezone.
    pub datetime: String,
    /// ascending is the crossing from south of the ecliptic to north, at the body north node. descending is the reverse, at its south node.
    pub direction: GetPlanetaryNodePassagesResponseEventsItemDirection,
    /// Tropical ecliptic longitude of the body at the crossing, in degrees. This is the only value in the response that depends on the zodiac frame.
    pub longitude: f64,
    /// Body making the crossing. Always canonical English whatever the lang parameter says, so it stays safe to compare against in code. Use planetLocalized for anything a reader sees.
    pub planet: String,
    /// Body name in the requested language. Present only when lang is supplied.
    #[serde(rename = "planetLocalized", skip_serializing_if = "Option::is_none")]
    pub planet_localized: Option<String>,
    /// Tropical sign the body occupies at the crossing. Canonical English.
    pub sign: String,
    /// Sign in the requested language. Present only when lang is supplied.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
    /// Time of the crossing in the requested timezone (HH:MM).
    pub time: String,
}
string_enum! {
    /// ascending is the crossing from south of the ecliptic to north, at the body north node. descending is the reverse, at its south node.
    GetPlanetaryNodePassagesResponseEventsItemDirection {
        Ascending = "ascending",
        Descending = "descending",
    }
}
/// Request body of `getPlanetaryNodePassages`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPlanetaryNodePassagesRequest {
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved once, at the start of the window, and that offset applies to every time in the response. Crossing dates and times are reported in this zone. Defaults to 0 (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetPlanetaryNodePassagesRequestTimezone>,
    /// Year to scan for node passages (1551 to 2649).
    pub year: i64,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved once, at the start of the window, and that offset applies to every time in the response. Crossing dates and times are reported in this zone. Defaults to 0 (UTC).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetPlanetaryNodePassagesRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
/// Path and query parameters of `getPlanetaryNodePassages`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetPlanetaryNodePassagesParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetPlanetaryNodePassagesParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetPlanetaryNodePassagesParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `getPlanetPositions`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetPlanetPositionsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetPlanetPositionsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetPlanetPositionsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getPlanetMeaning`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPlanetMeaningResponse {
    /// Planet classification: personal (Sun-Mars), social (Jupiter-Saturn), or generational (Uranus-Pluto).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub category: Option<String>,
    /// Planet description in short and long form.
    pub description: GetPlanetMeaningResponseDescription,
    /// Sign of detriment. Opposite the rulership sign, where the planet struggles. Absent for the lunar nodes, Chiron, and Black Moon Lilith.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub detriment: Option<String>,
    /// Sign of exaltation. Where the planet is honored and amplified. Absent for the lunar nodes, Chiron, and Black Moon Lilith.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub exaltation: Option<String>,
    /// Deprecated: use exaltation. Retained for backward compatibility, scheduled for removal in v3. Sign of exaltation, carrying the same value as the exaltation field.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub exultation: Option<String>,
    /// Sign of fall. Opposite the exaltation sign, where the planet is weakened. Absent for the lunar nodes, Chiron, and Black Moon Lilith.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fall: Option<String>,
    /// Lowercase planet identifier.
    pub id: String,
    /// Positive and negative keyword associations for this planet.
    pub keywords: GetPlanetMeaningResponseKeywords,
    /// Display name of the planet.
    pub name: String,
    /// Orbital period around the Sun or zodiac cycle length.
    pub orbit: String,
    /// Whether this planet can appear retrograde. Always false for Sun and Moon.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub retrograde: Option<bool>,
    /// Zodiac sign this planet rules (domicile). Where the planet operates most naturally. Absent for the lunar nodes, Chiron, and Black Moon Lilith.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rulership: Option<String>,
    /// Unicode astronomical symbol.
    pub symbol: String,
    /// Short tagline summarizing this planet.
    pub tagline: String,
    /// Traditional planet temperature (Hot, Cold, or Neutral).
    pub temperature: String,
}
/// Positive and negative keyword associations for this planet.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPlanetMeaningResponseKeywords {
    /// Shadow traits when this planet is challenged or afflicted.
    pub negative: Vec<String>,
    /// Positive traits and keywords when this planet is well-aspected.
    pub positive: Vec<String>,
}
/// Planet description in short and long form.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPlanetMeaningResponseDescription {
    /// Detailed multi-paragraph description of the planet, its symbolism, and astrological meaning.
    pub long: String,
    /// Brief 1-2 sentence overview of the planet.
    pub short: String,
}
/// Path and query parameters of `getPlanetMeaning`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPlanetMeaningParams {
    /// Planet ID (lowercase, e.g., sun, moon, mercury) or display name (case-insensitive, e.g., Sun, MOON). Spaces, hyphens and underscores are interchangeable, so the two lunar nodes answer to north-node and south-node as well as to their ids north node and south node, and Black Moon Lilith answers to black-moon-lilith as well as to lilith.
    pub id: String,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetPlanetMeaningParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetPlanetMeaningParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getPhases`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPhasesResponse {
    /// Birth date used for this calculation.
    #[serde(rename = "birthDate")]
    pub birth_date: String,
    /// Total days alive from birth date to target date.
    #[serde(rename = "daysSinceBirth")]
    pub days_since_birth: f64,
    /// Phase information for all 10 cycles keyed by cycle ID.
    pub phases: GetPhasesResponsePhases,
    /// Quick overview string summarizing the current state of all cycles.
    pub summary: String,
    /// Date this phase info is for.
    #[serde(rename = "targetDate")]
    pub target_date: String,
}
/// Phase information for all 10 cycles keyed by cycle ID.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPhasesResponsePhases {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<
        String,
        GetPhasesResponsePhasesAdditionalProperty,
    >,
}
/// Where one cycle stands on the target date: its value, phase and trend, the day it has reached inside a period of totalDays, and how many days remain to the next zero crossing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPhasesResponsePhasesAdditionalProperty {
    /// Current day position within the cycle.
    #[serde(rename = "dayInCycle")]
    pub day_in_cycle: f64,
    /// Days until next zero crossing.
    #[serde(rename = "daysUntilCritical")]
    pub days_until_critical: f64,
    /// Current phase identifier.
    pub phase: GetPhasesResponsePhasesAdditionalPropertyPhase,
    /// Human-readable phase label.
    #[serde(rename = "phaseLabel")]
    pub phase_label: String,
    /// Cycle period in days. 0 for composite cycles (passion, mastery, wisdom).
    #[serde(rename = "totalDays")]
    pub total_days: f64,
    /// Short-term direction: rising, falling, peaking, or bottoming.
    pub trend: GetPhasesResponsePhasesAdditionalPropertyTrend,
    /// Cycle value from -100 to 100.
    pub value: f64,
}
string_enum! {
    /// Short-term direction: rising, falling, peaking, or bottoming.
    GetPhasesResponsePhasesAdditionalPropertyTrend {
        Rising = "rising",
        Falling = "falling",
        Peaking = "peaking",
        Bottoming = "bottoming",
    }
}
string_enum! {
    /// Current phase identifier.
    GetPhasesResponsePhasesAdditionalPropertyPhase {
        Peak = "peak",
        High = "high",
        Rising = "rising",
        CriticalAscending = "critical_ascending",
        CriticalDescending = "critical_descending",
        Falling = "falling",
        Low = "low",
        Trough = "trough",
    }
}
/// Path and query parameters of `getPhases`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetPhasesParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetPhasesParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetPhasesParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getNumberMeaning`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetNumberMeaningResponse {
    /// The `meaning` field.
    pub meaning: GetNumberMeaningResponseMeaning,
    /// Requested number
    pub number: f64,
    /// Number type
    pub r#type: GetNumberMeaningResponseType,
}
string_enum! {
    /// Number type
    GetNumberMeaningResponseType {
        Single = "single",
        Master = "master",
    }
}
/// The `meaning` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetNumberMeaningResponseMeaning {
    /// Tailored career guidance with specific job titles, industries, and work environments. Explains why certain professional paths resonate with this number.
    pub career: String,
    /// Growth areas and shadow qualities. Each entry explains the root cause, how it surfaces, and constructive strategies for working through it.
    pub challenges: Vec<String>,
    /// Core interpretation of the number covering personality, life purpose and core themes. Together with the strengths, challenges, career, relationships and spirituality fields it makes a full reading.
    pub description: String,
    /// Ten defining personality traits and energetic themes. Useful for personality snapshots, compatibility matching, and building numerology profile summaries.
    pub keywords: Vec<String>,
    /// Love, friendship, and family dynamics. Covers romantic compatibility with other numbers, communication style, and the key relationship lessons.
    pub relationships: String,
    /// Spiritual path, soul lessons, and recommended practices. Explores the deeper purpose behind this number and guidance for personal growth.
    pub spirituality: String,
    /// Core strengths and positive qualities. Each entry pairs a trait name with a detailed explanation of how it manifests in real life.
    pub strengths: Vec<String>,
    /// Numerology archetype name. A single phrase capturing the core identity of this number, such as "The Leader" for 1 or "The Master Builder" for 22.
    pub title: String,
}
/// Path and query parameters of `getNumberMeaning`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetNumberMeaningParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetNumberMeaningParamsLang>,
    /// Numerology number (1-9, 11, 22, 33)
    pub number: String,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetNumberMeaningParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `getNakshatra`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetNakshatraParams {
    /// Nakshatra ID slug. Examples: ashwini, bharani, krittika, rohini, mrigashira, ardra, punarvasu, pushya, ashlesha, magha, etc.
    pub id: GetNakshatraParamsId,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetNakshatraParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetNakshatraParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Nakshatra ID slug. Examples: ashwini, bharani, krittika, rohini, mrigashira, ardra, punarvasu, pushya, ashlesha, magha, etc.
    GetNakshatraParamsId {
        Ashwini = "ashwini",
        Bharani = "bharani",
        Krittika = "krittika",
        Rohini = "rohini",
        Mrigashira = "mrigashira",
        Ardra = "ardra",
        Punarvasu = "punarvasu",
        Pushya = "pushya",
        Ashlesha = "ashlesha",
        Magha = "magha",
        PurvaPhalguni = "purva-phalguni",
        UttaraPhalguni = "uttara-phalguni",
        Hasta = "hasta",
        Chitra = "chitra",
        Swati = "swati",
        Vishakha = "vishakha",
        Anuradha = "anuradha",
        Jyeshtha = "jyeshtha",
        Moola = "moola",
        PurvaAshadha = "purva-ashadha",
        UttaraAshadha = "uttara-ashadha",
        Shravana = "shravana",
        Dhanishta = "dhanishta",
        Shatabhisha = "shatabhisha",
        PurvaBhadrapada = "purva-bhadrapada",
        UttaraBhadrapada = "uttara-bhadrapada",
        Revati = "revati",
    }
}
/// Response body of `getMoonCalendar`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMoonCalendarResponse {
    /// Daily moon phase and illumination for every day of the month.
    pub calendar: Vec<GetMoonCalendarResponseCalendarItem>,
    /// Calendar month for this lunar calendar.
    pub month: f64,
    /// Month name, localized to the requested language. Saves the caller a lookup table when labelling a calendar heading, since the numeric month alone cannot be rendered without one.
    #[serde(rename = "monthName")]
    pub month_name: String,
    /// Calendar year for this lunar calendar.
    pub year: f64,
}
/// One entry of `calendar`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMoonCalendarResponseCalendarItem {
    /// Calendar date (YYYY-MM-DD).
    pub date: String,
    /// Moon illumination percentage (0-100) at noon on this date.
    pub illumination: f64,
    /// Lunar phase name for this date.
    pub phase: String,
}
/// Path and query parameters of `getMoonCalendar`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMoonCalendarParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetMoonCalendarParamsLang>,
    /// Calendar month (1-12). 1 = January, 12 = December.
    pub month: i64,
    /// Calendar year, 1551 to 2649.
    pub year: i64,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetMoonCalendarParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getMonthlyTzolkinCalendar`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyTzolkinCalendarResponse {
    /// The conventions this grid was computed under, echoed so the result is self describing.
    pub conventions: GetMonthlyTzolkinCalendarResponseConventions,
    /// The days of the month in calendar order, one row per day. Every date in the month is present exactly once, which is what makes this safe to render straight into a grid.
    pub days: Vec<GetMonthlyTzolkinCalendarResponseDaysItem>,
    /// Month of the grid, echoed or defaulted to the current month in UTC.
    pub month: f64,
    /// Number of days in the grid, which is the length of the civil month. Every day of the month appears exactly once and none is repeated.
    pub total: f64,
    /// Year of the grid, echoed or defaulted to the current year in UTC.
    pub year: f64,
}
/// One entry of `days`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyTzolkinCalendarResponseDaysItem {
    /// Calendar date of this row, in proleptic Gregorian.
    pub date: String,
    /// Machine identifier of the Tzolkin day sign, always lowercase ASCII Yucatec, so it stays safe to compare against in code.
    #[serde(rename = "daySign")]
    pub day_sign: String,
    /// Display name of the day sign. A proper noun carried as data, identical under every lang.
    #[serde(rename = "daySignName")]
    pub day_sign_name: String,
    /// The Haab date, written as the day inside its period followed by the period name. Day 0 is the seating of a period and is a real date.
    pub haab: String,
    /// The dotted Long Count for this day. Consecutive rows differ by exactly one kin.
    #[serde(rename = "longCount")]
    pub long_count: String,
    /// The Tzolkin coefficient for this day, 1 to 13.
    pub number: f64,
    /// Which of the twenty thirteen day periods this day falls in, 1 to 20. Consecutive rows share a trecena until the period turns.
    pub trecena: f64,
}
/// The conventions this grid was computed under, echoed so the result is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyTzolkinCalendarResponseConventions {
    /// The correlation constant actually applied, whether it was requested or defaulted. Store this beside any Maya date you persist: the same civil date resolves to a different Long Count under each constant, and a date with no correlation recorded cannot be reproduced.
    pub correlation: String,
}
/// Path and query parameters of `getMonthlyTzolkinCalendar`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetMonthlyTzolkinCalendarParams {
    /// Which correlation constant ties the day count to a civil date. This is the single choice that shifts every value in the response, so it is a parameter rather than a hidden default, and the resolved value comes back under conventions. "gmt-584283" is the commonly accepted constant and the default, and it is the one the major institutional converter runs on. "martinez-hernandez-584281" sits two days earlier, "astronomical-584285" two days later, and "martin-skidmore-584286" three days later, each shifting the Long Count by exactly its difference in days. Four of the eight published constants are offered: the other four sit tens of thousands of days away and are of historical interest only. The 584281 constant is the Martínez Hernández correlation, after Juan Martínez Hernández.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub correlation: Option<GetMonthlyTzolkinCalendarParamsCorrelation>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetMonthlyTzolkinCalendarParamsLang>,
    /// Calendar month of the grid, 1 to 12. Defaults to the current month in UTC.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub month: Option<i64>,
    /// Gregorian year of the grid, 1900 to 2100. Defaults to the current year in UTC. Wider historical ranges are available on the single date routes, which are not bounded to this window.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetMonthlyTzolkinCalendarParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Which correlation constant ties the day count to a civil date. This is the single choice that shifts every value in the response, so it is a parameter rather than a hidden default, and the resolved value comes back under conventions. "gmt-584283" is the commonly accepted constant and the default, and it is the one the major institutional converter runs on. "martinez-hernandez-584281" sits two days earlier, "astronomical-584285" two days later, and "martin-skidmore-584286" three days later, each shifting the Long Count by exactly its difference in days. Four of the eight published constants are offered: the other four sit tens of thousands of days away and are of historical interest only. The 584281 constant is the Martínez Hernández correlation, after Juan Martínez Hernández.
    GetMonthlyTzolkinCalendarParamsCorrelation {
        Gmt584283 = "gmt-584283",
        MartinezHernandez584281 = "martinez-hernandez-584281",
        Astronomical584285 = "astronomical-584285",
        MartinSkidmore584286 = "martin-skidmore-584286",
    }
}
/// Response body of `getMonthlyTropicalTransits`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyTropicalTransitsResponse {
    /// Month of the table. Echoes the month requested, or the current UTC month when it was omitted.
    pub month: f64,
    /// Where every body stands as the month opens, so a calendar can show the run-in as well as the changes.
    #[serde(rename = "startingPositions")]
    pub starting_positions: Vec<GetMonthlyTropicalTransitsResponseStartingPositionsItem>,
    /// Timezone the ingress dates and times are reported in. Echoes the request.
    pub timezone: f64,
    /// Every sign change in the month, in chronological order across all bodies. Empty only for a month in which nothing changes sign, which cannot happen while the Moon is included.
    #[serde(rename = "transitEvents")]
    pub transit_events: Vec<GetMonthlyTropicalTransitsResponseTransitEventsItem>,
    /// Year of the table. Echoes the year requested, or the current UTC year when it was omitted.
    pub year: f64,
}
/// One entry of `transitEvents`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyTropicalTransitsResponseTransitEventsItem {
    /// Date of the ingress in the requested timezone (YYYY-MM-DD).
    pub date: String,
    /// Combined ingress timestamp in the requested timezone.
    pub datetime: String,
    /// Tropical sign the body leaves. Canonical English.
    #[serde(rename = "fromSign")]
    pub from_sign: String,
    /// Sign left, in the requested language. Present only when lang is supplied.
    #[serde(rename = "fromSignLocalized", skip_serializing_if = "Option::is_none")]
    pub from_sign_localized: Option<String>,
    /// Whether the body was retrograde at the moment it crossed. A retrograde ingress is the body re-entering a sign it already left, which is why the same body can appear more than once in a month.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Body that changes sign during the month. One of the 14 Western bodies. Always canonical English whatever the lang parameter says, so it stays safe to compare against in code. Use planetLocalized for anything a reader sees.
    pub planet: String,
    /// Body name in the requested language. Present only when lang is supplied.
    #[serde(rename = "planetLocalized", skip_serializing_if = "Option::is_none")]
    pub planet_localized: Option<String>,
    /// Time of the ingress in the requested timezone (HH:MM).
    pub time: String,
    /// Tropical sign the body enters. Canonical English.
    #[serde(rename = "toSign")]
    pub to_sign: String,
    /// Sign entered, in the requested language. Present only when lang is supplied.
    #[serde(rename = "toSignLocalized", skip_serializing_if = "Option::is_none")]
    pub to_sign_localized: Option<String>,
}
/// One entry of `startingPositions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyTropicalTransitsResponseStartingPositionsItem {
    /// Tropical ecliptic longitude in degrees at 00:00 UTC on the first of the month.
    pub longitude: f64,
    /// Body name, canonical English.
    pub planet: String,
    /// Body name in the requested language.
    #[serde(rename = "planetLocalized", skip_serializing_if = "Option::is_none")]
    pub planet_localized: Option<String>,
    /// Tropical sign the body occupies at the start of the month.
    pub sign: String,
    /// Sign in the requested language.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
}
/// Request body of `getMonthlyTropicalTransits`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetMonthlyTropicalTransitsRequest {
    /// Month number (1-12). Defaults to the current month (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub month: Option<i64>,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<GetMonthlyTropicalTransitsRequestNodeType>,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved once, at the start of the window, and that offset applies to every time in the response. Ingress dates and times are reported in this zone, which is what makes a published calendar read correctly for its audience. Defaults to 0 (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetMonthlyTropicalTransitsRequestTimezone>,
    /// Year for the monthly transit table (1551 to 2649). Defaults to the current year (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i64>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved once, at the start of the window, and that offset applies to every time in the response. Ingress dates and times are reported in this zone, which is what makes a published calendar read correctly for its audience. Defaults to 0 (UTC).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetMonthlyTropicalTransitsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    GetMonthlyTropicalTransitsRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Path and query parameters of `getMonthlyTropicalTransits`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetMonthlyTropicalTransitsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetMonthlyTropicalTransitsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetMonthlyTropicalTransitsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getMonthlyTropicalEphemeris`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyTropicalEphemerisResponse {
    /// Daily planetary position entries for the entire month.
    pub days: Vec<GetMonthlyTropicalEphemerisResponseDaysItem>,
    /// Month of the ephemeris. Echoes the month that was requested, or the current UTC month when it was omitted.
    pub month: f64,
    /// Year of the ephemeris. Echoes the year that was requested, or the current UTC year when it was omitted.
    pub year: f64,
}
/// One entry of `days`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyTropicalEphemerisResponseDaysItem {
    /// Date in YYYY-MM-DD format.
    pub date: String,
    /// Tropical positions of all 14 Western bodies on this date at noon UTC.
    pub positions: Vec<GetMonthlyTropicalEphemerisResponseDaysItemPositionsItem>,
}
/// One entry of `positions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyTropicalEphemerisResponseDaysItemPositionsItem {
    /// Degrees traversed within the current sign (0-30). Useful for precise transit tracking and for printing a position as sign plus degree.
    #[serde(rename = "degreeInSign")]
    pub degree_in_sign: f64,
    /// Whether the body is in apparent retrograde motion on this date. The lunar nodes are always retrograde and Black Moon Lilith is always direct.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Tropical ecliptic longitude in degrees (0-360), measured from the vernal equinox. This is the Western zodiac, not the sidereal one, so the two differ by the ayanamsa of roughly 24 degrees.
    pub longitude: f64,
    /// Body name, one of the 14 bodies Western astrology reads: Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto, North Node, South Node, Chiron, Black Moon Lilith. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use planetLocalized for anything a reader sees.
    pub planet: String,
    /// Body name in the requested language, for display. Present only when lang is set to a language other than English, since in English it would repeat planet exactly.
    #[serde(rename = "planetLocalized", skip_serializing_if = "Option::is_none")]
    pub planet_localized: Option<String>,
    /// Tropical zodiac sign the body occupies on this date. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use signLocalized for anything a reader sees.
    pub sign: String,
    /// Zodiac sign name in the requested language, for display. Present only when lang is set to a language other than English, since in English it would repeat sign exactly.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
}
/// Path and query parameters of `getMonthlyTropicalEphemeris`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetMonthlyTropicalEphemerisParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetMonthlyTropicalEphemerisParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetMonthlyTropicalEphemerisParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getMonthlyTropicalAspects`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyTropicalAspectsResponse {
    /// Every aspect event in the month, in chronological order across all body pairs.
    pub events: Vec<GetMonthlyTropicalAspectsResponseEventsItem>,
    /// Month of the calendar. Echoes the month requested, or the current UTC month when it was omitted.
    pub month: f64,
    /// Timezone the event dates and times are reported in. Echoes the request.
    pub timezone: f64,
    /// Year of the calendar. Echoes the year requested, or the current UTC year when it was omitted.
    pub year: f64,
}
/// One entry of `events`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyTropicalAspectsResponseEventsItem {
    /// Aspect type, canonical English. One of conjunction (0 deg), semi-sextile (30 deg), semi-square (45 deg), sextile (60 deg), square (90 deg), trine (120 deg), sesquiquadrate (135 deg), quincunx (150 deg), opposition (180 deg).
    pub aspect: String,
    /// Aspect name in the requested language. Present only when lang is supplied.
    #[serde(rename = "aspectLocalized", skip_serializing_if = "Option::is_none")]
    pub aspect_localized: Option<String>,
    /// Date the aspect is closest to exact, in the requested timezone (YYYY-MM-DD).
    pub date: String,
    /// Combined timestamp of closest approach, in the requested timezone.
    pub datetime: String,
    /// Whether the aspect is harmonious, challenging or neutral. Canonical English, so a calendar can color or filter on it directly. natureLocalized carries the reader-facing form.
    pub nature: String,
    /// Nature in the requested language. Present only when lang is supplied.
    #[serde(rename = "natureLocalized", skip_serializing_if = "Option::is_none")]
    pub nature_localized: Option<String>,
    /// Distance from exact in degrees at the reported instant. Effectively zero for an aspect that perfects inside the month, and larger only where the pair turns before reaching exact.
    pub orb: f64,
    /// First body forming the aspect. Always canonical English whatever the lang parameter says, so it stays safe to compare against in code. Use planet1Localized for anything a reader sees.
    pub planet1: String,
    /// First body in the requested language. Present only when lang is supplied.
    #[serde(rename = "planet1Localized", skip_serializing_if = "Option::is_none")]
    pub planet1_localized: Option<String>,
    /// Tropical ecliptic longitude of the first body at the reported instant.
    #[serde(rename = "planet1Longitude")]
    pub planet1_longitude: f64,
    /// Second body forming the aspect. Always canonical English.
    pub planet2: String,
    /// Second body in the requested language. Present only when lang is supplied.
    #[serde(rename = "planet2Localized", skip_serializing_if = "Option::is_none")]
    pub planet2_localized: Option<String>,
    /// Tropical ecliptic longitude of the second body at the reported instant.
    #[serde(rename = "planet2Longitude")]
    pub planet2_longitude: f64,
    /// Actual angular separation between the two bodies in degrees at the reported instant, measured the short way round the circle.
    pub separation: f64,
    /// Time the aspect is closest to exact, in the requested timezone (HH:MM).
    pub time: String,
}
/// Request body of `getMonthlyTropicalAspects`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetMonthlyTropicalAspectsRequest {
    /// Month number (1-12). Defaults to the current month (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub month: Option<i64>,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<GetMonthlyTropicalAspectsRequestNodeType>,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved once, at the start of the window, and that offset applies to every time in the response. Event dates and times are reported in this zone, which is what makes a published calendar read correctly for its audience. Defaults to 0 (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetMonthlyTropicalAspectsRequestTimezone>,
    /// Year for the aspect calendar (1551 to 2649). Defaults to the current year (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i64>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved once, at the start of the window, and that offset applies to every time in the response. Event dates and times are reported in this zone, which is what makes a published calendar read correctly for its audience. Defaults to 0 (UTC).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetMonthlyTropicalAspectsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    GetMonthlyTropicalAspectsRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Path and query parameters of `getMonthlyTropicalAspects`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetMonthlyTropicalAspectsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetMonthlyTropicalAspectsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetMonthlyTropicalAspectsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getMonthlyTransits`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyTransitsResponse {
    /// Month of the monthly transit analysis. Echoes the month that was requested, or the current UTC month when it was omitted.
    pub month: f64,
    /// Planetary positions at the beginning of the month (day 1, 00:00 UTC).
    #[serde(rename = "startingPositions")]
    pub starting_positions: Vec<GetMonthlyTransitsResponseStartingPositionsItem>,
    /// Timezone offset from UTC in hours that the event dates and times are reported in. Echoes the requested timezone.
    pub timezone: f64,
    /// All sign change events during the month, sorted chronologically. Moon changes sign roughly every 2.25 days, Sun once a month, slow planets less frequently.
    #[serde(rename = "transitEvents")]
    pub transit_events: Vec<GetMonthlyTransitsResponseTransitEventsItem>,
    /// Year of the monthly transit analysis. Echoes the year that was requested, or the current UTC year when it was omitted.
    pub year: f64,
}
/// One entry of `transitEvents`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyTransitsResponseTransitEventsItem {
    /// Date of the sign change (YYYY-MM-DD). Adjusted to requested timezone.
    pub date: String,
    /// Full datetime of the sign change. Adjusted to requested timezone.
    pub datetime: String,
    /// Zodiac sign the planet is leaving (previous rashi). Always English. Use fromSignLocalized for anything a reader sees.
    #[serde(rename = "fromSign")]
    pub from_sign: String,
    /// Name of the sign being left, in the requested language, for display. Present only when lang is set to a language other than English.
    #[serde(rename = "fromSignLocalized", skip_serializing_if = "Option::is_none")]
    pub from_sign_localized: Option<String>,
    /// Whether the planet is in retrograde motion (vakri) at the time of sign change. A retrograde ingress means the planet is moving backward into the previous sign, which carries different astrological significance than a direct (forward) ingress. Rahu and Ketu are always retrograde.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Planet that changes sign (rashi) during this month. One of the Navagraha: Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn, Rahu, Ketu. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use planetLocalized for anything a reader sees.
    pub planet: String,
    /// Planet name in the requested language, for display. Present only when lang is set to a language other than English, since in English it would repeat planet exactly.
    #[serde(rename = "planetLocalized", skip_serializing_if = "Option::is_none")]
    pub planet_localized: Option<String>,
    /// Time of the sign change (HH:MM, 24-hour). Adjusted to requested timezone. Precise to ~1 minute via binary search.
    pub time: String,
    /// Zodiac sign the planet is entering (new rashi transit). Always English. Use toSignLocalized for anything a reader sees.
    #[serde(rename = "toSign")]
    pub to_sign: String,
    /// Name of the sign being entered, in the requested language, for display. Present only when lang is set to a language other than English.
    #[serde(rename = "toSignLocalized", skip_serializing_if = "Option::is_none")]
    pub to_sign_localized: Option<String>,
}
/// One entry of `startingPositions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyTransitsResponseStartingPositionsItem {
    /// Sidereal longitude at the start of the month.
    pub longitude: f64,
    /// Planet (graha) name. One of the 9 Navagraha used in Vedic transit (Gochar) analysis. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use planetLocalized for anything a reader sees.
    pub planet: String,
    /// Planet name in the requested language, for display. Present only when lang is set to a language other than English.
    #[serde(rename = "planetLocalized", skip_serializing_if = "Option::is_none")]
    pub planet_localized: Option<String>,
    /// Zodiac sign (rashi) the planet occupies at the start of the month. Always English. Use signLocalized for anything a reader sees.
    pub sign: String,
    /// Zodiac sign name in the requested language, for display. Present only when lang is set to a language other than English.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
}
/// Request body of `getMonthlyTransits`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetMonthlyTransitsRequest {
    /// Coordinate system for longitude output. "sidereal" (Nirayana) uses Lahiri ayanamsa, the standard for Vedic astrology. "tropical" (Sayana) uses raw ecliptic longitude matching Western astrology. Defaults to "sidereal".
    #[serde(rename = "coordinateSystem", skip_serializing_if = "Option::is_none")]
    pub coordinate_system: Option<GetMonthlyTransitsRequestCoordinateSystem>,
    /// Month number (1-12) for transit analysis. Defaults to the current month (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub month: Option<i64>,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved once, at the start of the window, and that offset applies to every time in the response. Output times are converted to this timezone. Defaults to 0 (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetMonthlyTransitsRequestTimezone>,
    /// Year for monthly transit analysis (1551 to 2649). Defaults to the current year (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i64>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved once, at the start of the window, and that offset applies to every time in the response. Output times are converted to this timezone. Defaults to 0 (UTC).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetMonthlyTransitsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Coordinate system for longitude output. "sidereal" (Nirayana) uses Lahiri ayanamsa, the standard for Vedic astrology. "tropical" (Sayana) uses raw ecliptic longitude matching Western astrology. Defaults to "sidereal".
    GetMonthlyTransitsRequestCoordinateSystem {
        Sidereal = "sidereal",
        Tropical = "tropical",
    }
}
/// Path and query parameters of `getMonthlyTransits`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetMonthlyTransitsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetMonthlyTransitsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetMonthlyTransitsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getMonthlyParallels`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyParallelsResponse {
    /// All parallel and contraparallel events detected during the month, sorted chronologically.
    pub events: Vec<GetMonthlyParallelsResponseEventsItem>,
    /// Month of the parallel analysis. Echoes the month that was requested, or the current UTC month when it was omitted.
    pub month: f64,
    /// Year of the parallel analysis. Echoes the year that was requested, or the current UTC year when it was omitted.
    pub year: f64,
}
/// One entry of `events`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyParallelsResponseEventsItem {
    /// Date of closest declination match (YYYY-MM-DD). Adjusted to requested timezone.
    pub date: String,
    /// Full datetime of closest declination match. Adjusted to requested timezone.
    pub datetime: String,
    /// Declination of the first planet in degrees.
    pub dec1: f64,
    /// Declination of the second planet in degrees.
    pub dec2: f64,
    /// Declination difference from exact parallel/contraparallel in degrees. Smaller = stronger.
    pub orb: f64,
    /// First planet in the parallel or contraparallel pair. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use planet1Localized for anything a reader sees.
    pub planet1: String,
    /// First planet name in the requested language, for display. Present only when lang is set to a language other than English, since in English it would repeat planet1 exactly.
    #[serde(rename = "planet1Localized", skip_serializing_if = "Option::is_none")]
    pub planet1_localized: Option<String>,
    /// Second planet in the pair. Always English, whatever the lang parameter says. Use planet2Localized for anything a reader sees.
    pub planet2: String,
    /// Second planet name in the requested language, for display. Present only when lang is set to a language other than English.
    #[serde(rename = "planet2Localized", skip_serializing_if = "Option::is_none")]
    pub planet2_localized: Option<String>,
    /// Time of closest declination match (HH:MM, 24-hour). Adjusted to requested timezone.
    pub time: String,
    /// Parallel = same declination (acts like conjunction in strength). Contraparallel = opposite declination (acts like opposition).
    pub r#type: GetMonthlyParallelsResponseEventsItemType,
}
string_enum! {
    /// Parallel = same declination (acts like conjunction in strength). Contraparallel = opposite declination (acts like opposition).
    GetMonthlyParallelsResponseEventsItemType {
        Parallel = "parallel",
        Contraparallel = "contraparallel",
    }
}
/// Request body of `getMonthlyParallels`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetMonthlyParallelsRequest {
    /// Month number (1-12) for parallel analysis. Defaults to the current month (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub month: Option<i64>,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved once, at the start of the window, and that offset applies to every time in the response. Output times are converted to this timezone. Defaults to 0 (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetMonthlyParallelsRequestTimezone>,
    /// Year for monthly parallel analysis (1551 to 2649). Defaults to the current year (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i64>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved once, at the start of the window, and that offset applies to every time in the response. Output times are converted to this timezone. Defaults to 0 (UTC).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetMonthlyParallelsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
/// Path and query parameters of `getMonthlyParallels`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetMonthlyParallelsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetMonthlyParallelsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetMonthlyParallelsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getMonthlyHoroscope`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyHoroscopeResponse {
    /// The single actionable takeaway from the leading event of the period, read into the whole-sign houses of this sign and checkable against the events array. Drawn from the same event as overview, kept to a short, actionable pair of sentences rather than grown to match the other sections. Deterministic: the same sign and period always returns the same text.
    pub advice: String,
    /// Monthly career and professional outlook, read into the whole-sign houses of this sign. The same ranked events that drive column, filtered to career, work and reputation, plus the standing placements that reach it. Every event named here is in the events array, so a piece can be fact-checked before it runs; this section reads an event through whichever of its houses carries career, work and reputation, which for an aspect between two houses can be the other one from the house the events array leads with, and both are whole-sign houses of the bodies involved counted from this sign. Typically 120 to 200 words. Render it alone for a single-topic page, or alongside the other five sections for a general reading; column is the same material woven into one piece instead of split by topic. Deterministic: the same sign and period always returns the same text.
    pub career: String,
    /// The full column for this period, ready to run as one piece, with paragraphs separated by a blank line. Names the events driving it and the dates they fall on, read into the whole-sign houses of this sign. Typically 400 to 700 words. The six section fields read the same ranked events filtered to their own life area, each composed as a column of its own rather than an excerpt of this one, so render either shape and never both. Deterministic: the same sign and period always returns the same column.
    pub column: String,
    /// Most compatible zodiac signs for this sign. Trine partners (same element) followed by a sextile partner (complementary element).
    #[serde(rename = "compatibleSigns")]
    pub compatible_signs: Vec<String>,
    /// The dated astronomical events this reading is built on, earliest first. Every field in every row can be checked against an independent authority, so a column can be fact-checked before it is published. Empty on a period in which nothing exact happens, where the reading falls back to the standing positions instead.
    pub events: Vec<GetMonthlyHoroscopeResponseEventsItem>,
    /// Monthly financial outlook and guidance, read into the whole-sign houses of this sign. The same ranked events that drive column, filtered to finance, plus the standing placements that reach it. Every event named here is in the events array, so a piece can be fact-checked before it runs; this section reads an event through whichever of its houses carries finance, which for an aspect between two houses can be the other one from the house the events array leads with, and both are whole-sign houses of the bodies involved counted from this sign. Typically 120 to 200 words. Render it alone for a single-topic page, or alongside the other five sections for a general reading; column is the same material woven into one piece instead of split by topic. Deterministic: the same sign and period always returns the same text.
    pub finance: String,
    /// Monthly health and wellness guidance, read into the whole-sign houses of this sign. The same ranked events that drive column, filtered to health, plus the standing placements that reach it. Every event named here is in the events array, so a piece can be fact-checked before it runs; this section reads an event through whichever of its houses carries health, which for an aspect between two houses can be the other one from the house the events array leads with, and both are whole-sign houses of the bodies involved counted from this sign. Typically 120 to 200 words. Render it alone for a single-topic page, or alongside the other five sections for a general reading; column is the same material woven into one piece instead of split by topic. Deterministic: the same sign and period always returns the same text.
    pub health: String,
    /// The dates to circle this month, earliest first: every lunation and eclipse of the month, plus the headline movements the reading is built on, which are the sign changes of the slower planets and every station with the direction it turns. Each is placed in the whole-sign house it reaches for this sign. Every row is an instant the ephemeris gives, checkable against NASA JPL Horizons or the US Naval Observatory, and every row that is not a lunation or an eclipse is also a row of events\[\], so the list cannot contradict the reading beside it.
    #[serde(rename = "keyDates")]
    pub key_dates: Vec<GetMonthlyHoroscopeResponseKeyDatesItem>,
    /// Monthly love and relationship forecast, read into the whole-sign houses of this sign. The same ranked events that drive column, filtered to romance and partnership, plus the standing placements that reach it. Every event named here is in the events array, so a piece can be fact-checked before it runs; this section reads an event through whichever of its houses carries romance and partnership, which for an aspect between two houses can be the other one from the house the events array leads with, and both are whole-sign houses of the bodies involved counted from this sign. Typically 120 to 200 words. Render it alone for a single-topic page, or alongside the other five sections for a general reading; column is the same material woven into one piece instead of split by topic. Deterministic: the same sign and period always returns the same text.
    pub love: String,
    /// Lucky color for the month, drawn from the three colors of the sign element and selected by the planet governing the reading.
    #[serde(rename = "luckyColor")]
    pub lucky_color: String,
    /// Four lucky numbers for the month, each 1 to 9 and all distinct, from the traditional planetary number correspondence applied to the four planets that govern this sign this month.
    #[serde(rename = "luckyNumbers")]
    pub lucky_numbers: Vec<f64>,
    /// Month of this forecast (YYYY-MM).
    pub month: String,
    /// The single most relevant event of the period, whichever life area it touches, read into the whole-sign houses of this sign. The same event that leads column, at lede length rather than developed into a full movement, and checkable against the events array. Typically 55 to 100 words. Join it with love, career, health and finance for a general reading built from the six sections. Deterministic: the same sign and period always returns the same text.
    pub overview: String,
    /// Zodiac sign for this horoscope.
    pub sign: String,
    /// The month read one calendar week at a time, off the same ranked events as column and events\[\]: the life area each week turns on, and the one thing that area asks for. Two weeks may land in the same area, because two events of a month often do; the sentence beside it is always different. Use it for the week strip of a monthly page.
    #[serde(rename = "weekByWeek")]
    pub week_by_week: Vec<GetMonthlyHoroscopeResponseWeekByWeekItem>,
}
/// One entry of `weekByWeek`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyHoroscopeResponseWeekByWeekItem {
    /// What that house asks for, as one sentence in the requested language. No two weeks of one month repeat a sentence.
    pub advice: String,
    /// The life area the week turns on, in the requested language: the theme of the whole-sign house holding the strongest event the reading names inside that week, or of the strongest standing placement where the week holds no dated event. Same values as the life areas of the yearly key periods.
    pub focus: String,
    /// Position of the week inside the month, 1 first. The rows are calendar weeks, Monday to Sunday, clipped to the month at each end, so a month carries four, five or six of them. Row N is therefore the same week the weekly forecast covers, which is what lets a monthly page link straight into it.
    pub week: f64,
}
/// One entry of `keyDates`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyHoroscopeResponseKeyDatesItem {
    /// UTC date of the event (YYYY-MM-DD). The exact instant, to the second, is on the matching row of events\[\].
    pub date: String,
    /// The event as one sentence in the requested language, placed in the whole-sign house it reaches for this sign.
    pub event: String,
}
/// One entry of `events`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyHoroscopeResponseEventsItem {
    /// Angle formed, on aspect events only: conjunction, sextile, square, trine, opposition, semi-sextile, quincunx, semi-square, or sesquiquadrate.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub aspect: Option<String>,
    /// Exact instant the event perfects, UTC, to the second. Verifiable against NASA JPL Horizons for a position event and against the US Naval Observatory for a lunar phase or eclipse.
    pub at: String,
    /// Bodies involved, canonical English regardless of the requested language so the value stays safe to switch on. Two entries for an aspect, faster body first. One entry for an ingress, a station, a lunar phase, or an eclipse.
    pub bodies: Vec<String>,
    /// Whole-sign house the event falls in, counted from the queried sign, 1 to 12. This is what turns one global sky event into a statement about this reader.
    pub house: i64,
    /// Sign the event falls in, lowercase, where it has exactly one. Absent for an aspect whose two bodies stand in different signs.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sign: Option<String>,
    /// End of the window this event holds open, UTC, given only where a bounded window is a real fact about it: the orb span of an aspect, the sign span of an ingress or a season, the retrograde span of a station. Absent for a lunar phase or an eclipse, which are instants and not spans.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub through: Option<String>,
    /// Kind of event. aspect is an exact angle between two moving bodies, sign-ingress a body entering a new sign, retrograde-station a body turning retrograde or direct, lunar-phase one of the four quarters, eclipse a solar or lunar eclipse, and solar-season the Sun entering a sign.
    pub r#type: GetMonthlyHoroscopeResponseEventsItemType,
}
string_enum! {
    /// Kind of event. aspect is an exact angle between two moving bodies, sign-ingress a body entering a new sign, retrograde-station a body turning retrograde or direct, lunar-phase one of the four quarters, eclipse a solar or lunar eclipse, and solar-season the Sun entering a sign.
    GetMonthlyHoroscopeResponseEventsItemType {
        Aspect = "aspect",
        SignIngress = "sign-ingress",
        RetrogradeStation = "retrograde-station",
        LunarPhase = "lunar-phase",
        Eclipse = "eclipse",
        SolarSeason = "solar-season",
    }
}
/// Path and query parameters of `getMonthlyHoroscope`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyHoroscopeParams {
    /// Any date inside the target month, in YYYY-MM-DD format. The forecast covers the whole calendar month containing it. Defaults to the current period in the timezone parameter.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetMonthlyHoroscopeParamsLang>,
    /// Zodiac sign, case-insensitive (e.g., aries, Aries, ARIES all work).
    pub sign: GetMonthlyHoroscopeParamsSign,
    /// Selects which period counts as current when date is omitted. Defaults to UTC, so the forecast rolls over at 00:00 UTC on the 1st. Pass the timezone of the end user to roll over on their local clock instead. Ignored when date is set. Accepts an IANA name (e.g. "America/New_York"), decimal hours (e.g. 5.5 for IST), or a fixed UTC offset (e.g. "-05:00").
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
}
string_enum! {
    /// Zodiac sign, case-insensitive (e.g., aries, Aries, ARIES all work).
    GetMonthlyHoroscopeParamsSign {
        Aries = "aries",
        Taurus = "taurus",
        Gemini = "gemini",
        Cancer = "cancer",
        Leo = "leo",
        Virgo = "virgo",
        Libra = "libra",
        Scorpio = "scorpio",
        Sagittarius = "sagittarius",
        Capricorn = "capricorn",
        Aquarius = "aquarius",
        Pisces = "pisces",
    }
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetMonthlyHoroscopeParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getMonthlyFlyingStars`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyFlyingStarsResponse {
    /// Flying star number, 1 to 9. The number IS the identifier of the star: 8 is always the Eight White Earth star whichever plate it appears on.
    #[serde(rename = "centerStar")]
    pub center_star: f64,
    /// Solar month of the plate, 1 to 12, where 1 is the month that begins at Li Chun in early February. Echoes the month requested, or the solar month in progress when it was omitted.
    pub month: f64,
    /// All nine palaces of the monthly plate, centre first and then along the Lo Shu path.
    pub palaces: Vec<GetMonthlyFlyingStarsResponsePalacesItem>,
    /// Solar year of the plate. Echoes the year requested, or the solar year in progress when it was omitted.
    pub year: f64,
    /// Earthly Branch of the solar year, which decides where the monthly sequence starts. Rat, Horse, Rabbit and Rooster years open on 8; Dragon, Dog, Ox and Goat years on 5; Tiger, Monkey, Snake and Pig years on 2.
    #[serde(rename = "yearBranch")]
    pub year_branch: String,
}
/// One entry of `palaces`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyFlyingStarsResponsePalacesItem {
    /// Five phase of this entry: Wood, Fire, Earth, Metal or Water. Always English so it stays safe to compare against and to key styling on. The full cycles live on the Chinese astrology elements endpoint.
    pub element: String,
    /// Five phase of this entry: Wood, Fire, Earth, Metal or Water. Always English so it stays safe to compare against and to key styling on. The full cycles live on the Chinese astrology elements endpoint.
    pub enhancer: String,
    /// What the star does in the sector it has flown to this period.
    pub meaning: String,
    /// Display name of the star in this palace. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Star name in the requested language, for display only. Present only when lang is set to a language other than English.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// The untimely reading of the star, auspicious or inauspicious.
    pub nature: String,
    /// Palace of the Lo Shu grid: one of the eight compass sectors, or Center. Always English, safe to compare against and to key a grid cell on.
    pub palace: String,
    /// Five phase of this entry: Wood, Fire, Earth, Metal or Water. Always English so it stays safe to compare against and to key styling on. The full cycles live on the Chinese astrology elements endpoint.
    pub remedy: String,
    /// Flying star number, 1 to 9. The number IS the identifier of the star: 8 is always the Eight White Earth star whichever plate it appears on.
    pub star: f64,
}
/// Path and query parameters of `getMonthlyFlyingStars`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetMonthlyFlyingStarsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetMonthlyFlyingStarsParamsLang>,
    /// Solar month, 1 to 12, where 1 begins at Li Chun in early February. This is NOT the calendar month: solar month 1 covers roughly 4 February to 5 March. Defaults to the solar month in progress.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub month: Option<i64>,
    /// Solar year, 1900 to 2100. Defaults to the solar year in progress, which changes at Li Chun rather than on 1 January.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetMonthlyFlyingStarsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getMonthlyEphemeris`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyEphemerisResponse {
    /// Daily planetary position entries for the entire month.
    pub days: Vec<GetMonthlyEphemerisResponseDaysItem>,
    /// Month of the ephemeris. Echoes the month that was requested, or the current UTC month when it was omitted.
    pub month: f64,
    /// Year of the ephemeris. Echoes the year that was requested, or the current UTC year when it was omitted.
    pub year: f64,
}
/// One entry of `days`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyEphemerisResponseDaysItem {
    /// Date in YYYY-MM-DD format.
    pub date: String,
    /// Sidereal positions of all 9 Vedic planets on this date at noon UTC.
    pub positions: Vec<GetMonthlyEphemerisResponseDaysItemPositionsItem>,
}
/// One entry of `positions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyEphemerisResponseDaysItemPositionsItem {
    /// Degrees traversed within the current sign (0-30). Useful for precise transit tracking.
    #[serde(rename = "degreeInSign")]
    pub degree_in_sign: f64,
    /// Whether the planet is in retrograde motion (vakri) on this date.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Sidereal ecliptic longitude in degrees (0-360) using Lahiri ayanamsa.
    pub longitude: f64,
    /// Planet name, one of the Navagraha (Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn, Rahu, Ketu). Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use planetLocalized for anything a reader sees.
    pub planet: String,
    /// Planet name in the requested language, for display. Present only when lang is set to a language other than English, since in English it would repeat planet exactly. Rahu and Ketu are rendered as the lunar nodes they are, so Spanish returns Nodo Norte and Nodo Sur while Hindi returns their Sanskrit names.
    #[serde(rename = "planetLocalized", skip_serializing_if = "Option::is_none")]
    pub planet_localized: Option<String>,
    /// Zodiac sign (rashi) the planet occupies on this date. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use signLocalized for anything a reader sees.
    pub sign: String,
    /// Zodiac sign name in the requested language, for display. Present only when lang is set to a language other than English, since in English it would repeat sign exactly.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
}
/// Request body of `getMonthlyEphemeris`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetMonthlyEphemerisRequest {
    /// Coordinate system for longitude output. "sidereal" (Nirayana) uses Lahiri ayanamsa, the standard for Vedic astrology. "tropical" (Sayana) uses raw ecliptic longitude matching Western astrology. Defaults to "sidereal".
    #[serde(rename = "coordinateSystem", skip_serializing_if = "Option::is_none")]
    pub coordinate_system: Option<GetMonthlyEphemerisRequestCoordinateSystem>,
    /// Month number (1-12) for ephemeris. Defaults to the current month (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub month: Option<i64>,
    /// Year for monthly ephemeris (1551 to 2649). Defaults to the current year (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i64>,
}
string_enum! {
    /// Coordinate system for longitude output. "sidereal" (Nirayana) uses Lahiri ayanamsa, the standard for Vedic astrology. "tropical" (Sayana) uses raw ecliptic longitude matching Western astrology. Defaults to "sidereal".
    GetMonthlyEphemerisRequestCoordinateSystem {
        Sidereal = "sidereal",
        Tropical = "tropical",
    }
}
/// Path and query parameters of `getMonthlyEphemeris`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetMonthlyEphemerisParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetMonthlyEphemerisParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetMonthlyEphemerisParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getMonthlyDeclinationParallels`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyDeclinationParallelsResponse {
    /// Every declination contact in the month, in chronological order across all body pairs.
    pub events: Vec<GetMonthlyDeclinationParallelsResponseEventsItem>,
    /// Month of the calendar. Echoes the month requested, or the current UTC month when it was omitted.
    pub month: f64,
    /// Orb in degrees that was applied. Echoes the request.
    pub orb: f64,
    /// Timezone the event dates and times are reported in. Echoes the request.
    pub timezone: f64,
    /// Year of the calendar. Echoes the year requested, or the current UTC year when it was omitted.
    pub year: f64,
}
/// One entry of `events`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyDeclinationParallelsResponseEventsItem {
    /// Date the contact is closest to exact, in the requested timezone (YYYY-MM-DD).
    pub date: String,
    /// Combined timestamp of closest approach, in the requested timezone.
    pub datetime: String,
    /// Geocentric declination of the first body at the reported instant, in degrees. Positive is north of the celestial equator, negative south.
    pub declination1: f64,
    /// Geocentric declination of the second body at the reported instant, in degrees.
    pub declination2: f64,
    /// Distance from exact in degrees at the reported instant. Effectively zero for a contact that perfects inside the month, and larger only where the pair turns before reaching exact.
    pub orb: f64,
    /// First body in the contact. Always canonical English whatever the lang parameter says, so it stays safe to compare against in code. Use planet1Localized for anything a reader sees.
    pub planet1: String,
    /// First body in the requested language. Present only when lang is supplied.
    #[serde(rename = "planet1Localized", skip_serializing_if = "Option::is_none")]
    pub planet1_localized: Option<String>,
    /// Second body in the contact. Always canonical English.
    pub planet2: String,
    /// Second body in the requested language. Present only when lang is supplied.
    #[serde(rename = "planet2Localized", skip_serializing_if = "Option::is_none")]
    pub planet2_localized: Option<String>,
    /// Time the contact is closest to exact, in the requested timezone (HH:MM).
    pub time: String,
    /// parallel means both bodies stand at the same declination, the same distance north or south of the celestial equator, and reads much like a conjunction. contraparallel means equal and opposite declinations, one as far north as the other is south, and reads much like an opposition. Neither depends on how far apart the two bodies are along the zodiac, which is what makes them worth tracking alongside ordinary aspects.
    pub r#type: GetMonthlyDeclinationParallelsResponseEventsItemType,
}
string_enum! {
    /// parallel means both bodies stand at the same declination, the same distance north or south of the celestial equator, and reads much like a conjunction. contraparallel means equal and opposite declinations, one as far north as the other is south, and reads much like an opposition. Neither depends on how far apart the two bodies are along the zodiac, which is what makes them worth tracking alongside ordinary aspects.
    GetMonthlyDeclinationParallelsResponseEventsItemType {
        Parallel = "parallel",
        Contraparallel = "contraparallel",
    }
}
/// Request body of `getMonthlyDeclinationParallels`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetMonthlyDeclinationParallelsRequest {
    /// Month number (1-12). Defaults to the current month (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub month: Option<i64>,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<GetMonthlyDeclinationParallelsRequestNodeType>,
    /// How far from exact still counts, in degrees. The traditional orb for a declination contact is tighter than for a zodiacal aspect because declination changes slowly. Defaults to 1.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub orb: Option<f64>,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved once, at the start of the window, and that offset applies to every time in the response. Event dates and times are reported in this zone, which is what makes a published calendar read correctly for its audience. Defaults to 0 (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetMonthlyDeclinationParallelsRequestTimezone>,
    /// Year for the declination calendar (1551 to 2649). Defaults to the current year (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i64>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved once, at the start of the window, and that offset applies to every time in the response. Event dates and times are reported in this zone, which is what makes a published calendar read correctly for its audience. Defaults to 0 (UTC).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetMonthlyDeclinationParallelsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    GetMonthlyDeclinationParallelsRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Path and query parameters of `getMonthlyDeclinationParallels`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetMonthlyDeclinationParallelsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetMonthlyDeclinationParallelsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetMonthlyDeclinationParallelsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getMonthlyAspects`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyAspectsResponse {
    /// All planetary aspect events detected during the month, sorted chronologically by closest approach date.
    pub events: Vec<GetMonthlyAspectsResponseEventsItem>,
    /// Month of the aspect analysis. Echoes the month that was requested, or the current UTC month when it was omitted.
    pub month: f64,
    /// Timezone offset from UTC in hours that the event dates and times are reported in. Echoes the requested timezone.
    pub timezone: f64,
    /// Year of the aspect analysis. Echoes the year that was requested, or the current UTC year when it was omitted.
    pub year: f64,
}
/// One entry of `events`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyAspectsResponseEventsItem {
    /// Aspect type. major: conjunction (0 deg), opposition (180 deg), trine (120 deg), square (90 deg), sextile (60 deg). Minor: vigintile (18 deg), semi-sextile (30 deg), undecile (32.73 deg), semi-quintile (36 deg), novile (40 deg), semi-square (45 deg), septile (51.43 deg), quintile (72 deg), binovile (80 deg), centile (100 deg), biseptile (102.86 deg), tredecile (108 deg), sesqui-square (135 deg), bi-quintile (144 deg), quincunx (150 deg), triseptile (154.29 deg), quadranovile (160 deg).
    pub aspect: String,
    /// Date when the aspect is closest to exact (YYYY-MM-DD). Adjusted to requested timezone.
    pub date: String,
    /// Full datetime when aspect is closest to exact. Adjusted to requested timezone.
    pub datetime: String,
    /// Actual angular distance between the two planets in degrees at closest approach.
    pub distance: f64,
    /// Angular distance from exact aspect in degrees at closest approach. Smaller orb indicates a more powerful aspect.
    pub orb: f64,
    /// First planet forming the aspect. One of the Navagraha, Sun through Ketu. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use planet1Localized for anything a reader sees.
    pub planet1: String,
    /// First planet name in the requested language, for display. Present only when lang is set to a language other than English, since in English it would repeat planet1 exactly.
    #[serde(rename = "planet1Localized", skip_serializing_if = "Option::is_none")]
    pub planet1_localized: Option<String>,
    /// Sidereal longitude of the first planet at time of aspect (Lahiri ayanamsa).
    #[serde(rename = "planet1Longitude")]
    pub planet1_longitude: f64,
    /// Second planet forming the aspect. Always English, whatever the lang parameter says. Use planet2Localized for anything a reader sees.
    pub planet2: String,
    /// Second planet name in the requested language, for display. Present only when lang is set to a language other than English.
    #[serde(rename = "planet2Localized", skip_serializing_if = "Option::is_none")]
    pub planet2_localized: Option<String>,
    /// Sidereal longitude of the second planet at time of aspect.
    #[serde(rename = "planet2Longitude")]
    pub planet2_longitude: f64,
    /// Time when the aspect is closest to exact (HH:MM, 24-hour). Adjusted to requested timezone.
    pub time: String,
}
/// Request body of `getMonthlyAspects`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetMonthlyAspectsRequest {
    /// Coordinate system for longitude output. "sidereal" (Nirayana) uses Lahiri ayanamsa, the standard for Vedic astrology. "tropical" (Sayana) uses raw ecliptic longitude matching Western astrology. Defaults to "sidereal".
    #[serde(rename = "coordinateSystem", skip_serializing_if = "Option::is_none")]
    pub coordinate_system: Option<GetMonthlyAspectsRequestCoordinateSystem>,
    /// Month number (1-12). Defaults to the current month (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub month: Option<i64>,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved once, at the start of the window, and that offset applies to every time in the response. Output times are converted to this timezone. Defaults to 0 (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetMonthlyAspectsRequestTimezone>,
    /// Year for monthly analysis (1551 to 2649). Defaults to the current year (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i64>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved once, at the start of the window, and that offset applies to every time in the response. Output times are converted to this timezone. Defaults to 0 (UTC).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetMonthlyAspectsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Coordinate system for longitude output. "sidereal" (Nirayana) uses Lahiri ayanamsa, the standard for Vedic astrology. "tropical" (Sayana) uses raw ecliptic longitude matching Western astrology. Defaults to "sidereal".
    GetMonthlyAspectsRequestCoordinateSystem {
        Sidereal = "sidereal",
        Tropical = "tropical",
    }
}
/// Path and query parameters of `getMonthlyAspects`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetMonthlyAspectsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetMonthlyAspectsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetMonthlyAspectsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getMonthlyAlmanac`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyAlmanacResponse {
    /// Every day of the month, in order.
    pub days: Vec<GetMonthlyAlmanacResponseDaysItem>,
    /// Month returned, 1 to 12. Echoes the month requested, or the current UTC month when it was omitted.
    pub month: f64,
    /// The `solarTerms` field.
    #[serde(rename = "solarTerms")]
    pub solar_terms: Vec<GetMonthlyAlmanacResponseSolarTermsItem>,
    /// Number of days in the month.
    pub total: f64,
    /// Year of the month returned. Echoes the year requested, or the current UTC year when it was omitted.
    pub year: f64,
}
/// One entry of `solarTerms`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyAlmanacResponseSolarTermsItem {
    /// Date the term falls on at the reference meridian.
    pub date: String,
    /// Solar term identifier in kebab case pinyin.
    pub id: String,
    /// The exact instant of the term, in UTC.
    #[serde(rename = "instantUtc")]
    pub instant_utc: String,
    /// Display name of the term.
    pub name: String,
    /// Either minor or major. A minor term inside the month is where the month pillar changes and where the day officer repeats for a day.
    pub r#type: String,
}
/// One entry of `days`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyAlmanacResponseDaysItem {
    /// Activity identifiers, always English kebab case so they stay safe to compare against in code. Use the /calendar/auspicious-days endpoint to search a date range for one of them.
    pub avoids: Vec<String>,
    /// The zodiac animal the day clashes with, which is the animal six branches away from the day branch. Anyone born in that animal year traditionally avoids the day for anything important.
    #[serde(rename = "clashAnimal")]
    pub clash_animal: String,
    /// Display name of the clashing animal in the requested language. Absent when lang is en, so an English response is unchanged.
    #[serde(rename = "clashAnimalLocalized", skip_serializing_if = "Option::is_none")]
    pub clash_animal_localized: Option<String>,
    /// The Gregorian date of the day, at the reference meridian.
    pub date: String,
    /// The `dayOfficer` field.
    #[serde(rename = "dayOfficer")]
    pub day_officer: GetMonthlyAlmanacResponseDaysItemDayOfficer,
    /// The `dayPillar` field.
    #[serde(rename = "dayPillar")]
    pub day_pillar: GetMonthlyAlmanacResponseDaysItemDayPillar,
    /// Activity identifiers, always English kebab case so they stay safe to compare against in code. Use the /calendar/auspicious-days endpoint to search a date range for one of them.
    pub favours: Vec<String>,
    /// The `lunar` field.
    pub lunar: GetMonthlyAlmanacResponseDaysItemLunar,
    /// The `mansion` field.
    pub mansion: GetMonthlyAlmanacResponseDaysItemMansion,
    /// Sexagenary month pillar of the day, and the pillar the day officer is counted from. Attributed by whole days like the year pillar, so the day a minor solar term falls on belongs to the new month even when the term arrives late in the evening. This is what an almanac prints, and it is not the same as the month pillar of a birth moment inside that day.
    #[serde(rename = "monthPillar")]
    pub month_pillar: GetMonthlyAlmanacResponseDaysItemMonthPillar,
    /// Sexagenary year pillar of the day. Attributed by whole days, so the day Li Chun falls on belongs to the new year for its whole length. A BaZi chart built from a birth TIME uses the term instant instead, so a birth in the hours before the term on that same day carries the previous year pillar.
    #[serde(rename = "yearPillar")]
    pub year_pillar: GetMonthlyAlmanacResponseDaysItemYearPillar,
}
/// Sexagenary year pillar of the day. Attributed by whole days, so the day Li Chun falls on belongs to the new year for its whole length. A BaZi chart built from a birth TIME uses the term instant instead, so a birth in the hours before the term on that same day carries the previous year pillar.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyAlmanacResponseDaysItemYearPillar {
    /// Earthly Branch of the pillar, one of zi chou yin mao chen si wu wei shen you xu hai.
    pub branch: String,
    /// The pillar in Chinese characters. A data field, identical in every language.
    pub chinese: String,
    /// Pillar identifier as stem-branch, e.g. jia-zi. Always English pinyin, whatever the lang parameter says, so it stays safe to compare against in code.
    pub id: String,
    /// Na Yin sound element of the pillar. It is a property of the pair, not of the stem, so it often names a different phase from the stem itself.
    #[serde(rename = "naYin")]
    pub na_yin: String,
    /// Five phase the Na Yin resolves to. Always English, so it stays safe to compare against in code.
    #[serde(rename = "naYinElement")]
    pub na_yin_element: String,
    /// Position in the sixty year cycle, 1 to 60. jia-zi is 1 and gui-hai is 60.
    pub number: f64,
    /// Heavenly Stem of the pillar, one of jia yi bing ding wu ji geng xin ren gui.
    pub stem: String,
}
/// Sexagenary month pillar of the day, and the pillar the day officer is counted from. Attributed by whole days like the year pillar, so the day a minor solar term falls on belongs to the new month even when the term arrives late in the evening. This is what an almanac prints, and it is not the same as the month pillar of a birth moment inside that day.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyAlmanacResponseDaysItemMonthPillar {
    /// Earthly Branch of the pillar, one of zi chou yin mao chen si wu wei shen you xu hai.
    pub branch: String,
    /// The pillar in Chinese characters. A data field, identical in every language.
    pub chinese: String,
    /// Pillar identifier as stem-branch, e.g. jia-zi. Always English pinyin, whatever the lang parameter says, so it stays safe to compare against in code.
    pub id: String,
    /// Na Yin sound element of the pillar. It is a property of the pair, not of the stem, so it often names a different phase from the stem itself.
    #[serde(rename = "naYin")]
    pub na_yin: String,
    /// Five phase the Na Yin resolves to. Always English, so it stays safe to compare against in code.
    #[serde(rename = "naYinElement")]
    pub na_yin_element: String,
    /// Position in the sixty year cycle, 1 to 60. jia-zi is 1 and gui-hai is 60.
    pub number: f64,
    /// Heavenly Stem of the pillar, one of jia yi bing ding wu ji geng xin ren gui.
    pub stem: String,
}
/// The `mansion` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyAlmanacResponseDaysItemMansion {
    /// Animal emblem of the mansion, the third character of its full Chinese name. English and canonical, identical in every language, matching how clashAnimal behaves on the same response. The translation is in animalLocalized.
    pub animal: String,
    /// Animal emblem in the requested language. Absent when lang is en, and absent when a language has no entry, so a caller falls back to animal.
    #[serde(rename = "animalLocalized", skip_serializing_if = "Option::is_none")]
    pub animal_localized: Option<String>,
    /// The mansion in Chinese. A data field, identical in every language.
    pub chinese: String,
    /// English display name of the mansion. Canonical, identical in every language. The translation is in nameLocalized. Note the mansion has no string id: number is the stable 1 to 28 key, because five of the 28 share a pinyin spelling.
    pub name: String,
    /// Display name of the mansion in the requested language. Absent when lang is en, and absent when a language has no entry for this mansion, so a caller falls back to name rather than rendering a blank.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Mansion number, 1 to 28, counted from the Horn. This is the identifier: three mansions share the pinyin wei and two share bi, so there is no unique pinyin key.
    pub number: f64,
    /// One of the four palaces, seven mansions each: azure-dragon, black-tortoise, white-tiger, vermilion-bird. Always English, so it stays safe to compare against in code.
    pub palace: String,
    /// Tone marked pinyin for the character.
    pub pinyin: String,
    /// The luminary the mansion belongs to, one of Wood Metal Earth Sun Moon Fire Water. Twenty eight mansions over seven luminaries is four weeks exactly, which is why a mansion always falls on the same weekday.
    pub planet: String,
}
/// The `lunar` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyAlmanacResponseDaysItemLunar {
    /// The Gregorian date this lunar day covers, evaluated at the reference meridian.
    pub date: String,
    /// Day of the lunar month, 1 to 30. A lunar month never has 31 days.
    pub day: f64,
    /// True when this is the leap repetition of the month number rather than the first pass through it.
    #[serde(rename = "isLeapMonth")]
    pub is_leap_month: bool,
    /// Lunar month, 1 to 12. A leap month repeats the number of the month it follows.
    pub month: f64,
    /// Days in this lunar month, 29 for a short month or 30 for a long one. It is the interval between two new moons, so it varies month to month.
    #[serde(rename = "monthLength")]
    pub month_length: f64,
    /// Lunisolar year. It advances on the first day of month 1, not at Li Chun, so it can lag the Gregorian year by up to seven weeks.
    pub year: f64,
}
/// The `dayPillar` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyAlmanacResponseDaysItemDayPillar {
    /// Earthly Branch of the pillar, one of zi chou yin mao chen si wu wei shen you xu hai.
    pub branch: String,
    /// The pillar in Chinese characters. A data field, identical in every language.
    pub chinese: String,
    /// Pillar identifier as stem-branch, e.g. jia-zi. Always English pinyin, whatever the lang parameter says, so it stays safe to compare against in code.
    pub id: String,
    /// Na Yin sound element of the pillar. It is a property of the pair, not of the stem, so it often names a different phase from the stem itself.
    #[serde(rename = "naYin")]
    pub na_yin: String,
    /// Five phase the Na Yin resolves to. Always English, so it stays safe to compare against in code.
    #[serde(rename = "naYinElement")]
    pub na_yin_element: String,
    /// Position in the sixty year cycle, 1 to 60. jia-zi is 1 and gui-hai is 60.
    pub number: f64,
    /// Heavenly Stem of the pillar, one of jia yi bing ding wu ji geng xin ren gui.
    pub stem: String,
}
/// The `dayOfficer` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMonthlyAlmanacResponseDaysItemDayOfficer {
    /// The officer in Chinese. A data field, identical in every language.
    pub chinese: String,
    /// Day officer identifier, one of jian chu man ping ding zhi po wei cheng shou kai bi. Always English pinyin, so it stays safe to compare against in code.
    pub id: String,
    /// What the officer means, in the terms a date choice uses it in.
    pub meaning: String,
    /// English display name of the officer. Canonical, identical in every language, so it stays safe to compare against in code. The translation is in nameLocalized.
    pub name: String,
    /// Display name of the officer in the requested language. Absent when lang is en, so an English response is unchanged.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone marked pinyin for the character.
    pub pinyin: String,
    /// Whether the officer falls on the auspicious or the inauspicious side of the coarse yellow and black split. Read favours and avoids for what the day actually rules on.
    pub quality: String,
}
/// Path and query parameters of `getMonthlyAlmanac`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetMonthlyAlmanacParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetMonthlyAlmanacParamsLang>,
    /// Gregorian month, 1 to 12. Defaults to the current UTC month when omitted, together with year.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub month: Option<i64>,
    /// Gregorian year, 1900 to 2100. Defaults to the current UTC year when omitted, together with month.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetMonthlyAlmanacParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getMayanDaySign`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMayanDaySignResponse {
    /// Where the same temperament costs the sign something. Each one is the shadow of a strength above rather than an unrelated flaw.
    pub challenges: Vec<String>,
    /// Colour paired with the direction: red for east, white for north, black for west, yellow for south. Always English so it stays safe to key a palette off.
    pub color: String,
    /// The conventions this profile was served under.
    pub conventions: GetMayanDaySignResponseConventions,
    /// World direction this sign belongs to under the requested scheme: east, north, west or south. The twenty signs divide evenly into four groups of five, so exactly five signs share each quarter.
    pub direction: String,
    /// The world direction in prose, followed by a line naming which of the two published readings produced it. The two sit one quarter turn apart on all twenty signs.
    #[serde(rename = "directionReading")]
    pub direction_reading: String,
    /// What the sign is about, as a clause rather than a sentence, because it is spliced into composed prose elsewhere in the API. Translated in place.
    pub essence: String,
    /// The short day-name association, translated in place because it is a common noun rather than a name. Two published readings of the twenty signs disagree on six of them, so the alternate reading ships beside this one rather than one being resolved away.
    pub gloss: String,
    /// The glyph-table reading of the same sign, translated in place. On the six signs where the two readings disagree this is the one the composed prose follows, so a reading that seems to ignore the gloss above is doing so deliberately.
    #[serde(rename = "glossAlternate")]
    pub gloss_alternate: String,
    /// The one thing worth doing differently under this sign.
    pub guidance: String,
    /// Machine identifier of the day sign, always lowercase ASCII Yucatec whatever the lang parameter says, so it stays safe to compare against in code and to use as a path parameter. The twenty ids run imix, ik, akbal, kan, chikchan, kimi, manik, lamat, muluk, ok, chuwen, eb, ben, ix, men, kib, kaban, etznab, kawak, ajaw.
    pub id: String,
    /// The sign in one composed sentence: both names, what it is about and the glyph reading behind it.
    pub keynote: String,
    /// The sixteenth century Yucatec spelling of the same sign, which is the form most printed reference tables and older books use.
    #[serde(rename = "nameClassic")]
    pub name_classic: String,
    /// The Kʼicheʼ name from the living highland daykeeping tradition, which is the vocabulary a nawal reading in Guatemala uses. A parallel naming tradition rather than a translation, so it is identical under every lang.
    #[serde(rename = "nameKiche")]
    pub name_kiche: String,
    /// Display name in the standard Maya orthography, where an ejective is written with a modifier letter rather than a typewriter quote. A proper noun carried as data, identical under every lang.
    #[serde(rename = "nameYucatec")]
    pub name_yucatec: String,
    /// Place in the twenty sign sequence, 1 to 20, counting Imix as 1. The sequence never varies and is what every other cycle in the domain is indexed against.
    pub position: f64,
    /// What the sign does well, as full sentences rather than keywords.
    pub strengths: Vec<String>,
    /// The thirteen day period this sign opens. Composed from the sign rather than stored, so the two can never disagree.
    pub trecena: GetMayanDaySignResponseTrecena,
}
/// The thirteen day period this sign opens. Composed from the sign rather than stored, so the two can never disagree.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMayanDaySignResponseTrecena {
    /// The trecena this sign opens, 1 to 20. Every sign opens exactly one trecena, because 13 and 20 share no factor.
    pub number: f64,
    /// The composed reading of the thirteen day period this sign opens.
    pub reading: String,
}
/// The conventions this profile was served under.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMayanDaySignResponseConventions {
    /// The direction reading actually applied. The two readings sit one quarter turn apart, so a direction stored without this value is ambiguous.
    #[serde(rename = "directionScheme")]
    pub direction_scheme: String,
}
/// Path and query parameters of `getMayanDaySign`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMayanDaySignParams {
    /// Which reading of the world direction and colour to serve for a day sign. The two published assignments differ by exactly one quarter turn on all twenty signs, so neither is a rounding of the other and a silent pick would be a school choice. "madrid-codex" is the codex reading and the default; "landa" is the sixteenth century assignment recorded beside it.
    #[serde(rename = "directionScheme", skip_serializing_if = "Option::is_none")]
    pub direction_scheme: Option<GetMayanDaySignParamsDirectionScheme>,
    /// Day sign id, case-insensitive and punctuation-insensitive. One of imix, ik, akbal, kan, chikchan, kimi, manik, lamat, muluk, ok, chuwen, eb, ben, ix, men, kib, kaban, etznab, kawak, ajaw.
    pub id: GetMayanDaySignParamsId,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetMayanDaySignParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetMayanDaySignParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Day sign id, case-insensitive and punctuation-insensitive. One of imix, ik, akbal, kan, chikchan, kimi, manik, lamat, muluk, ok, chuwen, eb, ben, ix, men, kib, kaban, etznab, kawak, ajaw.
    GetMayanDaySignParamsId {
        Imix = "imix",
        Ik = "ik",
        Akbal = "akbal",
        Kan = "kan",
        Chikchan = "chikchan",
        Kimi = "kimi",
        Manik = "manik",
        Lamat = "lamat",
        Muluk = "muluk",
        Ok = "ok",
        Chuwen = "chuwen",
        Eb = "eb",
        Ben = "ben",
        Ix = "ix",
        Men = "men",
        Kib = "kib",
        Kaban = "kaban",
        Etznab = "etznab",
        Kawak = "kawak",
        Ajaw = "ajaw",
    }
}
string_enum! {
    /// Which reading of the world direction and colour to serve for a day sign. The two published assignments differ by exactly one quarter turn on all twenty signs, so neither is a rounding of the other and a silent pick would be a school choice. "madrid-codex" is the codex reading and the default; "landa" is the sixteenth century assignment recorded beside it.
    GetMayanDaySignParamsDirectionScheme {
        MadridCodex = "madrid-codex",
        Landa = "landa",
    }
}
/// Response body of `getMajorDashas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMajorDashasResponse {
    /// Ayanamsa actually applied, in degrees. The precession offset subtracted from the tropical (sayana) longitude to get the sidereal (nirayana) one. Lahiri sits near 23 deg 43 min for a 1990 birth, KP-Newcomb near 23 deg 38 min.
    pub ayanamsa: f64,
    /// Ayanamsa system used, echoing the request field. One of "lahiri", "kp-newcomb", "kp-old" or "custom". Echoed so a client can confirm which frame produced these dates without re-deriving it. When it reads "custom" the ayanamsa field above carries the exact value you supplied.
    #[serde(rename = "ayanamsaType")]
    pub ayanamsa_type: GetMajorDashasResponseAyanamsaType,
    /// Remaining balance of the first Mahadasha at birth. Based on Moon degree within the birth nakshatra. partial dasha already elapsed before birth.
    #[serde(rename = "birthDashaBalance")]
    pub birth_dasha_balance: GetMajorDashasResponseBirthDashaBalance,
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<GetMajorDashasResponseFocus>,
    /// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
    #[serde(rename = "houseThemes", skip_serializing_if = "Option::is_none")]
    pub house_themes: Option<GetMajorDashasResponseHouseThemes>,
    /// Complete sequence of all 9 Mahadasha periods spanning 120 years from birth. Follows the Vimshottari order: Ketu(7), Venus(20), Sun(6), Moon(10), Mars(7), Rahu(18), Jupiter(16), Saturn(19), Mercury(17).
    pub mahadashas: Vec<GetMajorDashasResponseMahadashasItem>,
    /// Sidereal (nirayana) longitude of the birth Moon in degrees, 0 to 360, measured in the ayanamsa frame reported below. This single value determines the birth nakshatra and therefore every dasha start and end date in this response. Compare it against a reference chart to reconcile any date difference at its source.
    #[serde(rename = "moonLongitude")]
    pub moon_longitude: f64,
    /// Birth Moon nakshatra number (1-27) that determines the Vimshottari starting point.
    #[serde(rename = "moonNakshatra")]
    pub moon_nakshatra: i64,
    /// Dasha lord of the birth nakshatra, rules the first Mahadasha.
    #[serde(rename = "nakshatraLord")]
    pub nakshatra_lord: GetMajorDashasResponseNakshatraLord,
    /// Birth Moon nakshatra name, one of 27 Vedic lunar mansions.
    #[serde(rename = "nakshatraName")]
    pub nakshatra_name: String,
    /// Total Vimshottari cycle length in years (always 120).
    #[serde(rename = "totalYears")]
    pub total_years: f64,
}
string_enum! {
    /// Dasha lord of the birth nakshatra, rules the first Mahadasha.
    GetMajorDashasResponseNakshatraLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Mahadasha (major planetary period) in the 120-year Vimshottari dasha cycle. Start and end dates are determined by Moon nakshatra at birth.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMajorDashasResponseMahadashasItem {
    /// Duration of this dasha period in years. Mahadasha durations range from 6 years (Sun) to 20 years (Venus).
    #[serde(rename = "durationYears")]
    pub duration_years: f64,
    /// End datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Vedic interpretation of the planetary period describing themes, karmic lessons, and life areas affected by this graha.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interpretation: Option<String>,
    /// Theoretical start of this period, present ONLY when the birth date truncated it. The Vimshottari cycle is already running when a native is born, so the period in force at birth began earlier: startDate is clipped to the birth moment while this field keeps the real start. Its presence is also why the first period of a chart can contain fewer than 9 sub-periods, the earlier ones having finished before birth. Absent on every period that runs its full length.
    #[serde(rename = "nominalStartDate", skip_serializing_if = "Option::is_none")]
    pub nominal_start_date: Option<String>,
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    pub planet: GetMajorDashasResponseMahadashasItemPlanet,
    /// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub significators: Option<GetMajorDashasResponseMahadashasItemSignificators>,
    /// Start datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "startDate")]
    pub start_date: String,
}
/// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMajorDashasResponseMahadashasItemSignificators {
    /// House 1-12 this lord occupies in the Placidus birth chart. Its own Level 2 signification, repeated here because the occupied house is the first thing a KP reading looks at.
    pub house: i64,
    /// Every house this lord signifies, deduplicated and ordered strongest tier first. Where a house is reached at more than one level it is listed once, at its strongest. This is the flat "houses signified" column of a KP dasha table.
    #[serde(rename = "signifiedHouses")]
    pub signified_houses: Vec<i64>,
    /// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
    pub signifies: GetMajorDashasResponseMahadashasItemSignificatorsSignifies,
    /// Lord of the nakshatra this planet sits in, one of the 9 grahas. In KP the star lord outranks the planet itself: a period lord mainly delivers the houses its star lord occupies and owns, which is why those appear at L1 and L3 rather than the planet own house.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
    pub strength: GetMajorDashasResponseMahadashasItemSignificatorsStrength,
    /// Subset of signifiedHouses reached at grade A or B (levels L1 and L2). These are the houses a KP reading acts on for this period; the rest are supporting connections.
    #[serde(rename = "strongHouses")]
    pub strong_houses: Vec<i64>,
    /// KP sub lord of this planet, the 1 of 249 subdivision its longitude falls in, one of the 9 grahas. The star lord says WHAT results the period gives, the sub lord says WHETHER they materialize, so KP judgement checks both.
    #[serde(rename = "subLord", skip_serializing_if = "Option::is_none")]
    pub sub_lord: Option<String>,
}
/// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMajorDashasResponseMahadashasItemSignificatorsStrength {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    pub grade: GetMajorDashasResponseMahadashasItemSignificatorsStrengthGrade,
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    pub label: GetMajorDashasResponseMahadashasItemSignificatorsStrengthLabel,
    /// Mean KP percentage weight across signifiedHouses, each house counted at its strongest level (A 100, B 75, C 50, D 25). A mean rather than a total, so signifying many houses weakly does not outrank signifying two houses at grade A.
    pub score: f64,
}
string_enum! {
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    GetMajorDashasResponseMahadashasItemSignificatorsStrengthLabel {
        VeryStrong = "very-strong",
        Strong = "strong",
        Moderate = "moderate",
        Weak = "weak",
    }
}
string_enum! {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    GetMajorDashasResponseMahadashasItemSignificatorsStrengthGrade {
        A = "A",
        B = "B",
        C = "C",
        D = "D",
    }
}
/// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMajorDashasResponseMahadashasItemSignificatorsSignifies {
    /// Level 1, the strongest signification (grade A). Houses influenced because this planet sits in the nakshatra (star) of a planet occupying those houses. For Rahu and Ketu, also includes the L1 houses of their agent planets (conjoined, aspecting, sign lord).
    #[serde(rename = "L1")]
    pub l1: Vec<i64>,
    /// Level 2 (grade B). The house this planet physically occupies. For Rahu and Ketu, also includes houses occupied by their agent planets.
    #[serde(rename = "L2")]
    pub l2: Vec<i64>,
    /// Level 3 (grade C). Houses influenced because this planet sits in the nakshatra of the sign lord (owner) of those houses. For Rahu and Ketu, also includes the L3 houses of their agent planets.
    #[serde(rename = "L3")]
    pub l3: Vec<i64>,
    /// Level 4, the weakest signification (grade D). Houses this planet rules by zodiac sign ownership, up to 2 for Sun through Saturn and 3 where a sign is intercepted. Rahu and Ketu own no sign, so their L4 comes entirely from their agent planets.
    #[serde(rename = "L4")]
    pub l4: Vec<i64>,
}
string_enum! {
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    GetMajorDashasResponseMahadashasItemPlanet {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMajorDashasResponseHouseThemes {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, Vec<String>>,
}
string_enum! {
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    GetMajorDashasResponseFocus {
        General = "general",
        Finance = "finance",
    }
}
/// Remaining balance of the first Mahadasha at birth. Based on Moon degree within the birth nakshatra. partial dasha already elapsed before birth.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMajorDashasResponseBirthDashaBalance {
    /// Additional days remaining beyond full months.
    pub days: f64,
    /// Additional months remaining beyond full years.
    pub months: f64,
    /// Total remaining days in this dasha period. Useful for progress calculations.
    #[serde(rename = "totalDays")]
    pub total_days: f64,
    /// Full years remaining in this Vimshottari dasha period.
    pub years: f64,
}
string_enum! {
    /// Ayanamsa system used, echoing the request field. One of "lahiri", "kp-newcomb", "kp-old" or "custom". Echoed so a client can confirm which frame produced these dates without re-deriving it. When it reads "custom" the ayanamsa field above carries the exact value you supplied.
    GetMajorDashasResponseAyanamsaType {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Request body of `getMajorDashas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetMajorDashasRequest {
    /// Ayanamsa system used to place the birth Moon in its nakshatra, which sets every dasha start and end date. "lahiri" uses Lahiri/Chitrapaksha, the traditional Vedic standard, and is the default. "kp-newcomb" uses the KP-Newcomb dynamic formula, matching Krishnamurti Paddhati software. "kp-old" uses the Krishnamurti original table from KP Reader-1. "raman" uses the B.V. Raman ayanamsa, the second frame traditional Indian software commonly offers beside Lahiri. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. Switching frames shifts every dasha boundary by weeks, so pick the one your reference software uses.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<GetMajorDashasRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Lunar node type for Rahu and Ketu, used ONLY when "significators" is true. Dasha dates themselves come from the Moon and never move with this field. "mean" uses the smooth mean node (traditional default). "true" uses the osculating node, which swings up to 1.5 degrees either side of mean over a 173-day cycle and can therefore change which house or star a node falls in. Defaults to "mean".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<GetMajorDashasRequestNodeType>,
    /// Set true to attach the KP significators of each period lord: its star lord, sub lord, occupied house, the houses it signifies at levels L1 to L4, and a strength grade. Off by default, so responses stay exactly as they are for clients that only need dates. Requires the birth latitude and longitude, since significators are read off a Placidus house chart, and uses the same ayanamsa frame selected above.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub significators: Option<bool>,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetMajorDashasRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetMajorDashasRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node type for Rahu and Ketu, used ONLY when "significators" is true. Dasha dates themselves come from the Moon and never move with this field. "mean" uses the smooth mean node (traditional default). "true" uses the osculating node, which swings up to 1.5 degrees either side of mean over a 173-day cycle and can therefore change which house or star a node falls in. Defaults to "mean".
    GetMajorDashasRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// Ayanamsa system used to place the birth Moon in its nakshatra, which sets every dasha start and end date. "lahiri" uses Lahiri/Chitrapaksha, the traditional Vedic standard, and is the default. "kp-newcomb" uses the KP-Newcomb dynamic formula, matching Krishnamurti Paddhati software. "kp-old" uses the Krishnamurti original table from KP Reader-1. "raman" uses the B.V. Raman ayanamsa, the second frame traditional Indian software commonly offers beside Lahiri. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. Switching frames shifts every dasha boundary by weeks, so pick the one your reference software uses.
    GetMajorDashasRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Path and query parameters of `getMajorDashas`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetMajorDashasParams {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<GetMajorDashasParamsFocus>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetMajorDashasParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetMajorDashasParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    GetMajorDashasParamsFocus {
        General = "general",
        Finance = "finance",
    }
}
/// Response body of `getLunarAspects`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetLunarAspectsResponse {
    /// All Moon aspect events during the month, sorted chronologically. Moon completes one full cycle in approximately 27 days.
    pub events: Vec<GetLunarAspectsResponseEventsItem>,
    /// Month of the lunar aspect analysis. Echoes the month that was requested, or the current UTC month when it was omitted.
    pub month: f64,
    /// Timezone offset from UTC in hours that the event dates and times are reported in. Echoes the requested timezone.
    pub timezone: f64,
    /// Year of the lunar aspect analysis. Echoes the year that was requested, or the current UTC year when it was omitted.
    pub year: f64,
}
/// One entry of `events`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetLunarAspectsResponseEventsItem {
    /// Aspect type. major: conjunction, opposition, trine, square, sextile. Minor: vigintile, semi-sextile, undecile, semi-quintile, novile, semi-square, septile, quintile, binovile, centile, biseptile, tredecile, sesqui-square, bi-quintile, quincunx, triseptile, quadranovile.
    pub aspect: String,
    /// Date of closest approach for this lunar aspect (YYYY-MM-DD). Adjusted to requested timezone.
    pub date: String,
    /// Full datetime of closest approach. Adjusted to requested timezone.
    pub datetime: String,
    /// Actual angular distance between Moon and the aspected planet in degrees.
    pub distance: f64,
    /// Sidereal longitude of the Moon at the time of aspect (Lahiri ayanamsa).
    #[serde(rename = "moonLongitude")]
    pub moon_longitude: f64,
    /// Angular distance from exact lunar aspect in degrees. Smaller orb = stronger Moon influence.
    pub orb: f64,
    /// Planet that the Moon forms an aspect with. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use planetLocalized for anything a reader sees.
    pub planet: String,
    /// Planet name in the requested language, for display. Present only when lang is set to a language other than English, since in English it would repeat planet exactly.
    #[serde(rename = "planetLocalized", skip_serializing_if = "Option::is_none")]
    pub planet_localized: Option<String>,
    /// Sidereal longitude of the aspected planet at the time of aspect.
    #[serde(rename = "planetLongitude")]
    pub planet_longitude: f64,
    /// Time of closest approach for this lunar aspect (HH:MM, 24-hour). Adjusted to requested timezone.
    pub time: String,
}
/// Request body of `getLunarAspects`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetLunarAspectsRequest {
    /// Coordinate system for longitude output. "sidereal" (Nirayana) uses Lahiri ayanamsa, the standard for Vedic astrology. "tropical" (Sayana) uses raw ecliptic longitude matching Western astrology. Defaults to "sidereal".
    #[serde(rename = "coordinateSystem", skip_serializing_if = "Option::is_none")]
    pub coordinate_system: Option<GetLunarAspectsRequestCoordinateSystem>,
    /// Month number (1-12). Defaults to the current month (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub month: Option<i64>,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved once, at the start of the window, and that offset applies to every time in the response. Output times are converted to this timezone. Defaults to 0 (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetLunarAspectsRequestTimezone>,
    /// Year for monthly analysis (1551 to 2649). Defaults to the current year (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i64>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved once, at the start of the window, and that offset applies to every time in the response. Output times are converted to this timezone. Defaults to 0 (UTC).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetLunarAspectsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Coordinate system for longitude output. "sidereal" (Nirayana) uses Lahiri ayanamsa, the standard for Vedic astrology. "tropical" (Sayana) uses raw ecliptic longitude matching Western astrology. Defaults to "sidereal".
    GetLunarAspectsRequestCoordinateSystem {
        Sidereal = "sidereal",
        Tropical = "tropical",
    }
}
/// Path and query parameters of `getLunarAspects`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetLunarAspectsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetLunarAspectsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetLunarAspectsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getKuaNumber`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetKuaNumberResponse {
    /// Life group, east or west. Always English, safe to compare against and to key styling on.
    pub group: String,
    /// Kua number, 1 to 9.
    pub number: f64,
    /// All eight sectors classified for this Kua, in compass order from North.
    pub sectors: Vec<GetKuaNumberResponseSectorsItem>,
    /// The `trigram` field.
    pub trigram: GetKuaNumberResponseTrigram,
}
/// The `trigram` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetKuaNumberResponseTrigram {
    /// Three lines bottom to top, 1 for yang and 0 for yin. The Eight Mansions classification of any sector is decided by which of these three lines differ from your own trigram.
    pub binary: String,
    /// Chinese character for the trigram. Data, identical in every language.
    pub chinese: String,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against in code and against the same value on the I-Ching trigram endpoints.
    pub direction: String,
    /// Compass sector in the requested language, for display only, the same word the composed readings use. Present only when lang is set to a language other than English. Never compare against this value.
    #[serde(rename = "directionLocalized", skip_serializing_if = "Option::is_none")]
    pub direction_localized: Option<String>,
    /// Five phase of this entry: Wood, Fire, Earth, Metal or Water. Always English so it stays safe to compare against and to key styling on. The full cycles live on the Chinese astrology elements endpoint.
    pub element: String,
    /// Five phase name in the requested language, for display only. Present only when lang is set to a language other than English. Never compare against this value.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// English name of the trigram, byte identical to the English value the I-Ching trigram endpoints publish for this number. Always English here, whatever the lang parameter says, so it stays safe to compare against. Use nameLocalized for anything a reader sees.
    pub english: String,
    /// Family role of the trigram. Read alongside an affliction to know which member of the household a sector points at. Always English, and it carries no localized sibling: no vocabulary this package ships names the eight family roles.
    #[serde(rename = "familyMember")]
    pub family_member: String,
    /// Trigram name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat english exactly. Never compare against this value.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Trigram number, 1 to 8, the same identifier the I-Ching trigram endpoints use. It is a lookup key, not a ranking.
    pub number: f64,
    /// Tone-marked pinyin for the trigram. Data, identical in every language.
    pub pinyin: String,
    /// Unicode trigram symbol, for rendering a Bagua diagram without an icon set.
    pub symbol: String,
}
/// One entry of `sectors`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetKuaNumberResponseSectorsItem {
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against in code and against the same value on the I-Ching trigram endpoints.
    pub direction: String,
    /// The life domain this sector governs, in a few words, written in the requested language.
    pub domain: String,
    /// Whether the sector helps or harms: auspicious or inauspicious.
    pub nature: String,
    /// Order within its nature, 1 to 4. Among auspicious sectors 1 is the strongest; among inauspicious sectors 1 is the mildest and 4 the most serious, which is what tells you which affliction to accept when no favourable sector is reachable.
    pub rank: f64,
    /// Eight Mansions star for this sector, one of sheng-chi, tian-yi, yan-nian, fu-wei, huo-hai, wu-gui, liu-sha, jue-ming. Always English, safe to compare against and to key styling on.
    pub star: String,
    /// Display name of the star. Always English, whatever the lang parameter says. Use starNameLocalized for anything a reader sees.
    #[serde(rename = "starName")]
    pub star_name: String,
    /// Star name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat starName exactly. Never compare against this value.
    #[serde(rename = "starNameLocalized", skip_serializing_if = "Option::is_none")]
    pub star_name_localized: Option<String>,
}
/// Path and query parameters of `getKuaNumber`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetKuaNumberParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetKuaNumberParamsLang>,
    /// Kua number, 1 to 9.
    pub number: i64,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetKuaNumberParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Request body of `getKpRulingPlanets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetKpRulingPlanetsRequest {
    /// Birth date (YYYY-MM-DD) to calculate significators. If provided with birthTime, response includes which houses each ruling planet signifies.
    #[serde(rename = "birthDate", skip_serializing_if = "Option::is_none")]
    pub birth_date: Option<String>,
    /// Birth time (HH:MM:SS) for significator calculation. Required if birthDate is provided.
    #[serde(rename = "birthTime", skip_serializing_if = "Option::is_none")]
    pub birth_time: Option<String>,
    /// ISO 8601 datetime (YYYY-MM-DDTHH:MM:SS) for ruling planets. Defaults to current time. Interpreted as local time when a non-zero timezone is provided (a trailing Z is accepted but ignored); with timezone 0 it is UTC.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub datetime: Option<String>,
    /// Observer latitude in decimal degrees
    pub latitude: f64,
    /// Observer longitude in decimal degrees
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the Rahu and Ketu positions. Mean is the traditional Vedic default and what printed panchangs use; the choice can move a KP sub-lord in narrow boundary cases, where a span can be as small as 0.5 degrees. Defaults to "mean".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<GetKpRulingPlanetsRequestNodeType>,
    /// Timezone: IANA name (e.g. "America/New_York", "Europe/London") OR decimal hours from UTC. IANA resolved to the DST-correct offset based on birthDate or datetime. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetKpRulingPlanetsRequestTimezone>,
}
/// Timezone: IANA name (e.g. "America/New_York", "Europe/London") OR decimal hours from UTC. IANA resolved to the DST-correct offset based on birthDate or datetime. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetKpRulingPlanetsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the Rahu and Ketu positions. Mean is the traditional Vedic default and what printed panchangs use; the choice can move a KP sub-lord in narrow boundary cases, where a span can be as small as 0.5 degrees. Defaults to "mean".
    GetKpRulingPlanetsRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Path and query parameters of `getKpRulingPlanets`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetKpRulingPlanetsParams {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<GetKpRulingPlanetsParamsFocus>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetKpRulingPlanetsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetKpRulingPlanetsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    GetKpRulingPlanetsParamsFocus {
        General = "general",
        Finance = "finance",
    }
}
/// Request body of `getKpRulingInterval`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetKpRulingIntervalRequest {
    /// Ayanamsa system for sidereal conversion. "kp-newcomb" uses the KP-Newcomb dynamic formula, the most common choice for KP astrology. "kp-old" uses the Krishnamurti original table from KP Reader-1 with constant precession rate. "lahiri" uses Lahiri/Chitrapaksha ayanamsa, matching most traditional Vedic software. "raman" uses the B.V. Raman ayanamsa from Hindu Predictive Astrology, a recognised traditional school that sits about 1.45 degrees below Lahiri. Defaults to "kp-newcomb".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<GetKpRulingIntervalRequestAyanamsa>,
    /// End of the interval range in ISO 8601 (YYYY-MM-DDTHH:MM:SS). Interpreted as local time when a non-zero timezone is provided (a trailing Z is accepted but ignored); with timezone 0 it is UTC.
    #[serde(rename = "endDatetime")]
    pub end_datetime: String,
    /// Interval between calculations in minutes (1-1440). Use 1-5 for birth time rectification.
    #[serde(rename = "intervalMinutes")]
    pub interval_minutes: i64,
    /// Observer latitude in decimal degrees
    pub latitude: f64,
    /// Observer longitude in decimal degrees
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the Rahu and Ketu positions. Mean is the traditional Vedic default and what printed panchangs use; the choice can move a KP sub-lord in narrow boundary cases, where a span can be as small as 0.5 degrees. Defaults to "mean".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<GetKpRulingIntervalRequestNodeType>,
    /// Start of the interval range in ISO 8601 (YYYY-MM-DDTHH:MM:SS). Interpreted as local time when a non-zero timezone is provided (a trailing Z is accepted but ignored); with timezone 0 it is UTC.
    #[serde(rename = "startDatetime")]
    pub start_datetime: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved once, at the start of the window, and that offset applies to every time in the response. When non-zero, all datetimes are treated as local time in this timezone (Z suffix is ignored). Output times are also converted to this timezone. Defaults to 5.5 (IST).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetKpRulingIntervalRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved once, at the start of the window, and that offset applies to every time in the response. When non-zero, all datetimes are treated as local time in this timezone (Z suffix is ignored). Output times are also converted to this timezone. Defaults to 5.5 (IST).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetKpRulingIntervalRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the Rahu and Ketu positions. Mean is the traditional Vedic default and what printed panchangs use; the choice can move a KP sub-lord in narrow boundary cases, where a span can be as small as 0.5 degrees. Defaults to "mean".
    GetKpRulingIntervalRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// Ayanamsa system for sidereal conversion. "kp-newcomb" uses the KP-Newcomb dynamic formula, the most common choice for KP astrology. "kp-old" uses the Krishnamurti original table from KP Reader-1 with constant precession rate. "lahiri" uses Lahiri/Chitrapaksha ayanamsa, matching most traditional Vedic software. "raman" uses the B.V. Raman ayanamsa from Hindu Predictive Astrology, a recognised traditional school that sits about 1.45 degrees below Lahiri. Defaults to "kp-newcomb".
    GetKpRulingIntervalRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
    }
}
/// Path and query parameters of `getKpRulingInterval`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetKpRulingIntervalParams {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<GetKpRulingIntervalParamsFocus>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetKpRulingIntervalParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetKpRulingIntervalParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    GetKpRulingIntervalParamsFocus {
        General = "general",
        Finance = "finance",
    }
}
/// Path and query parameters of `getKpCusps`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetKpCuspsParams {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<GetKpCuspsParamsFocus>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetKpCuspsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetKpCuspsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    GetKpCuspsParamsFocus {
        General = "general",
        Finance = "finance",
    }
}
/// Response body of `getHora`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetHoraResponse {
    /// Date for which hora periods were calculated.
    pub date: String,
    /// 12 daytime hora periods from sunrise to sunset. Duration varies by season.
    #[serde(rename = "dayHoras")]
    pub day_horas: Vec<GetHoraResponseDayHorasItem>,
    /// 12 nighttime hora periods from sunset to next sunrise. Duration varies by season.
    #[serde(rename = "nightHoras")]
    pub night_horas: Vec<GetHoraResponseNightHorasItem>,
}
/// One entry of `nightHoras`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetHoraResponseNightHorasItem {
    /// End time of the hora period in ISO 8601 format.
    pub end: String,
    /// Hora period number within the day or night segment (1-12).
    pub number: f64,
    /// Ruling planet of this hora period. Follows the Chaldean planetary order: Sun, Venus, Mercury, Moon, Saturn, Jupiter, Mars.
    pub planet: String,
    /// Start time of the hora period in ISO 8601 format.
    pub start: String,
}
/// One entry of `dayHoras`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetHoraResponseDayHorasItem {
    /// End time of the hora period in ISO 8601 format.
    pub end: String,
    /// Hora period number within the day or night segment (1-12).
    pub number: f64,
    /// Ruling planet of this hora period. Follows the Chaldean planetary order: Sun, Venus, Mercury, Moon, Saturn, Jupiter, Mars.
    pub planet: String,
    /// Start time of the hora period in ISO 8601 format.
    pub start: String,
}
/// Request body of `getHora`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetHoraRequest {
    /// Date in YYYY-MM-DD format. A single-digit month or day is accepted and zero-padded (2026-3-5 becomes 2026-03-05). Impossible calendar dates are rejected. Calculations that read planetary positions support 1550-01-02 to 2650-01-22; outside that span they answer 400 with code date_out_of_range, and a calculation that reads a window around the date (a sunrise search, a run of days) may answer the same 400 for a date within a few days of either end.
    pub date: String,
    /// Observer latitude in decimal degrees. Determines sunrise and sunset times which define day/night boundaries for muhurta calculations.
    pub latitude: f64,
    /// Observer longitude in decimal degrees. Affects local time calculations for sunrise, sunset, and muhurta period boundaries.
    pub longitude: f64,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Used for accurate sunrise/sunset calculation and output time formatting. Essential for correct Hora periods outside IST. Defaults to 5.5 (IST).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetHoraRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Used for accurate sunrise/sunset calculation and output time formatting. Essential for correct Hora periods outside IST. Defaults to 5.5 (IST).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetHoraRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
/// Path and query parameters of `getHexagram`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetHexagramParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetHexagramParamsLang>,
    /// Hexagram number in King Wen sequence (1-64).
    pub number: i64,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetHexagramParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getHebrewLetter`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetHebrewLetterResponse {
    /// The `attribution` field.
    pub attribution: GetHebrewLetterResponseAttribution,
    /// What the class means, in the requested language.
    #[serde(rename = "classReading")]
    pub class_reading: String,
    /// The word final glyph, or null for the seventeen letters that have none. Five letters change shape at the end of a word and score differently there under one reading of mispar gadol.
    pub r#final: Option<String>,
    /// Value in final position under the finals-500-900 reading of mispar gadol, or null where the letter has no final form.
    #[serde(rename = "finalValue")]
    pub final_value: Option<f64>,
    /// Machine identifier of the letter, always English romanization so it stays safe to compare against in code.
    pub id: String,
    /// The base glyph. Data, identical in every language.
    pub letter: String,
    /// Sefer Yetzirah class: mother, double or simple. Three mothers take an element, seven doubles take a planet, twelve simples take a sign, and the three counts are the structure of the whole letter tradition.
    #[serde(rename = "letterClass")]
    pub letter_class: String,
    /// What the letter name means as an ordinary word, in the requested language. The names are object names, which is what the shapes were drawn from.
    pub meaning: String,
    /// Display name of the letter, in the requested language.
    pub name: String,
    /// Position in the alphabet, 1 to 22. A property of the letter, not a cipher reading.
    pub ordinal: f64,
    /// The path this letter sits on, numbered 11 to 32 to continue the ten sephirot into the thirty two Paths of Wisdom. Never null in practice: all 22 letters carry a path.
    pub path: Option<f64>,
    /// Latin transcription of the glyph, from the one mechanical letter map this API uses in both directions. A label, never a pronunciation claim.
    pub romanization: String,
    /// The `trump` field.
    pub trump: GetHebrewLetterResponseTrump,
    /// Value under the standard reading. The 22 letters cover 1 to 9, 10 to 90 and 100 to 400.
    pub value: f64,
}
/// The `trump` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetHebrewLetterResponseTrump {
    /// Identifier of the tarot trump on this letter path. It resolves in the Tarot API on the same key, so a caller can follow it straight to the card.
    pub id: String,
    /// Display name of the trump.
    pub name: String,
    /// The trump number as the deck prints it, in Roman numerals.
    pub number: String,
}
/// The `attribution` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetHebrewLetterResponseAttribution {
    /// What the attribution names: element, planet or sign. Always English.
    pub kind: String,
    /// The element, planet or sign under the requested reading. Always English, so it stays safe to compare against in code.
    pub value: String,
}
/// Path and query parameters of `getHebrewLetter`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetHebrewLetterParams {
    /// Letter identifier, one of alef, bet, gimel, dalet, he, vav, zayin, chet, tet, yod, kaf, lamed, mem, nun, samekh, ayin, pe, tzadi, qof, resh, shin, tav. Matching folds case and punctuation.
    pub id: GetHebrewLetterParamsId,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetHebrewLetterParamsLang>,
    /// Which reading assigns the element, planet or sign to each letter. The seven double letters are the contested column and the four readings genuinely disagree on them; the twelve simple letters run in natural zodiacal order in all four. The golden-dawn member does NOT exchange He and Tzade, which is a later change from a different author.
    #[serde(rename = "letterAttribution", skip_serializing_if = "Option::is_none")]
    pub letter_attribution: Option<GetHebrewLetterParamsLetterAttribution>,
}
string_enum! {
    /// Which reading assigns the element, planet or sign to each letter. The seven double letters are the contested column and the four readings genuinely disagree on them; the twelve simple letters run in natural zodiacal order in all four. The golden-dawn member does NOT exchange He and Tzade, which is a later change from a different author.
    GetHebrewLetterParamsLetterAttribution {
        SeferYetzirahGra = "sefer-yetzirah-gra",
        SeferYetzirahShort = "sefer-yetzirah-short",
        SeferYetzirahSaadia = "sefer-yetzirah-saadia",
        GoldenDawn = "golden-dawn",
    }
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetHebrewLetterParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Letter identifier, one of alef, bet, gimel, dalet, he, vav, zayin, chet, tet, yod, kaf, lamed, mem, nun, samekh, ayin, pe, tzadi, qof, resh, shin, tav. Matching folds case and punctuation.
    GetHebrewLetterParamsId {
        Alef = "alef",
        Bet = "bet",
        Gimel = "gimel",
        Dalet = "dalet",
        He = "he",
        Vav = "vav",
        Zayin = "zayin",
        Chet = "chet",
        Tet = "tet",
        Yod = "yod",
        Kaf = "kaf",
        Lamed = "lamed",
        Mem = "mem",
        Nun = "nun",
        Samekh = "samekh",
        Ayin = "ayin",
        Pe = "pe",
        Tzadi = "tzadi",
        Qof = "qof",
        Resh = "resh",
        Shin = "shin",
        Tav = "tav",
    }
}
/// Path and query parameters of `getHaabMonth`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetHaabMonthParams {
    /// Haab period id, case-insensitive and punctuation-insensitive. One of pop, wo, sip, sotz, sek, xul, yaxkin, mol, chen, yax, sak, keh, mak, kankin, muwan, pax, kayab, kumku, wayeb.
    pub id: GetHaabMonthParamsId,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetHaabMonthParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetHaabMonthParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Haab period id, case-insensitive and punctuation-insensitive. One of pop, wo, sip, sotz, sek, xul, yaxkin, mol, chen, yax, sak, keh, mak, kankin, muwan, pax, kayab, kumku, wayeb.
    GetHaabMonthParamsId {
        Pop = "pop",
        Wo = "wo",
        Sip = "sip",
        Sotz = "sotz",
        Sek = "sek",
        Xul = "xul",
        Yaxkin = "yaxkin",
        Mol = "mol",
        Chen = "chen",
        Yax = "yax",
        Sak = "sak",
        Keh = "keh",
        Mak = "mak",
        Kankin = "kankin",
        Muwan = "muwan",
        Pax = "pax",
        Kayab = "kayab",
        Kumku = "kumku",
        Wayeb = "wayeb",
    }
}
/// Response body of `getGate`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetGateResponse {
    /// Center the gate sits in.
    pub center: String,
    /// Display name of the center. Always English, whatever the lang parameter says. Use centerNameLocalized for anything a reader sees.
    #[serde(rename = "centerName")]
    pub center_name: String,
    /// Center name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "centerNameLocalized", skip_serializing_if = "Option::is_none")]
    pub center_name_localized: Option<String>,
    /// Gates that form a channel with this gate, with the channel name for each.
    #[serde(rename = "channelPartners")]
    pub channel_partners: Vec<GetGateResponseChannelPartnersItem>,
    /// The I-Ching hexagram that shares this gate number.
    #[serde(rename = "ichingHexagram")]
    pub iching_hexagram: GetGateResponseIchingHexagram,
    /// Human Design keynote name of the gate. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Gate keynote name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Gate number from 1 to 64.
    pub number: f64,
}
/// The I-Ching hexagram that shares this gate number.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetGateResponseIchingHexagram {
    /// Hexagram name.
    pub english: String,
    /// I-Ching hexagram number.
    pub number: f64,
}
/// One entry of `channelPartners`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetGateResponseChannelPartnersItem {
    /// Name of the shared channel. Always English, whatever the lang parameter says. Use channelLocalized for anything a reader sees.
    pub channel: String,
    /// Channel name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "channelLocalized", skip_serializing_if = "Option::is_none")]
    pub channel_localized: Option<String>,
    /// Partner gate number.
    pub gate: f64,
}
/// Path and query parameters of `getGate`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetGateParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetGateParamsLang>,
    /// Gate number from 1 to 64.
    pub number: i64,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetGateParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getForecast`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetForecastResponse {
    /// Birth date used for this calculation.
    #[serde(rename = "birthDate")]
    pub birth_date: String,
    /// Array of daily readings, one per day in the forecast range.
    pub days: Vec<GetForecastResponseDaysItem>,
    /// Last day of the forecast range.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// First day of the forecast range.
    #[serde(rename = "startDate")]
    pub start_date: String,
    /// The `summary` field.
    pub summary: GetForecastResponseSummary,
    /// Number of days in the forecast range.
    #[serde(rename = "totalDays")]
    pub total_days: f64,
}
/// The `summary` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetForecastResponseSummary {
    /// Average energy rating (1-10) across the entire forecast period.
    #[serde(rename = "averageEnergy")]
    pub average_energy: f64,
    /// Date with the highest average primary cycle values in the range. Best day for demanding activities.
    #[serde(rename = "bestDay")]
    pub best_day: String,
    /// Total number of days where at least one primary cycle crosses zero in the range.
    #[serde(rename = "criticalDayCount")]
    pub critical_day_count: f64,
    /// Overview guidance for the entire forecast period based on average energy and cycle patterns.
    #[serde(rename = "periodAdvice")]
    pub period_advice: String,
    /// Date with the lowest average primary cycle values in the range. Best scheduled as a rest day.
    #[serde(rename = "worstDay")]
    pub worst_day: String,
}
/// One entry of `days`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetForecastResponseDaysItem {
    /// Which primary cycles are critical on this day. Empty array if none.
    #[serde(rename = "criticalCycles")]
    pub critical_cycles: Vec<String>,
    /// Date of this daily reading (YYYY-MM-DD).
    pub date: String,
    /// Days from birth date to this date.
    #[serde(rename = "daysSinceBirth")]
    pub days_since_birth: f64,
    /// Emotional cycle value (-100 to 100).
    pub emotional: f64,
    /// Energy rating for this day (1-10).
    #[serde(rename = "energyRating")]
    pub energy_rating: f64,
    /// Intellectual cycle value (-100 to 100).
    pub intellectual: f64,
    /// Intuitive cycle value (-100 to 100).
    pub intuitive: f64,
    /// True if any primary cycle crosses zero on this day.
    #[serde(rename = "isCritical")]
    pub is_critical: bool,
    /// Physical cycle value (-100 to 100).
    pub physical: f64,
}
/// Path and query parameters of `getForecast`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetForecastParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetForecastParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetForecastParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getFieldLabels`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetFieldLabelsResponse {
    /// Label per selectable option, keyed `{fieldName}.{value}` so the same value can read differently under different fields. For example `nodeType.mean`, `houseSystem.whole-sign` and `id.rat`. An id shared by collections with different display names is omitted. Split on the first dot: the field name is before it, and everything after it is the value you send back unchanged.
    pub enums: GetFieldLabelsResponseEnums,
    /// Label per request field or parameter name. Keys are the wire names used in request bodies, query parameters and path parameters, such as `birthDate`, `timezone` or `houseSystem`.
    pub fields: GetFieldLabelsResponseFields,
    /// Language these labels resolved to. Echoes the `lang` query parameter, or `en` when it is omitted.
    pub lang: GetFieldLabelsResponseLang,
}
string_enum! {
    /// Language these labels resolved to. Echoes the `lang` query parameter, or `en` when it is omitted.
    GetFieldLabelsResponseLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Label per request field or parameter name. Keys are the wire names used in request bodies, query parameters and path parameters, such as `birthDate`, `timezone` or `houseSystem`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetFieldLabelsResponseFields {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, String>,
}
/// Label per selectable option, keyed `{fieldName}.{value}` so the same value can read differently under different fields. For example `nodeType.mean`, `houseSystem.whole-sign` and `id.rat`. An id shared by collections with different display names is omitted. Split on the first dot: the field name is before it, and everything after it is the value you send back unchanged.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetFieldLabelsResponseEnums {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, String>,
}
/// Path and query parameters of `getFieldLabels`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetFieldLabelsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetFieldLabelsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetFieldLabelsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getEclipticCrossings`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetEclipticCrossingsResponse {
    /// All ecliptic crossing events for visible planets during the year, sorted chronologically.
    pub events: Vec<GetEclipticCrossingsResponseEventsItem>,
    /// Timezone offset from UTC in hours that the event dates and times are reported in. Echoes the requested timezone.
    pub timezone: f64,
    /// Year scanned for ecliptic crossings.
    pub year: f64,
}
/// One entry of `events`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetEclipticCrossingsResponseEventsItem {
    /// Date of the ecliptic crossing (YYYY-MM-DD). Adjusted to requested timezone.
    pub date: String,
    /// Full datetime of the ecliptic crossing. Adjusted to requested timezone.
    pub datetime: String,
    /// Ascending = planet moves from south to north of the ecliptic. Descending = north to south.
    pub direction: GetEclipticCrossingsResponseEventsItemDirection,
    /// Longitude of the planet at the moment of crossing, in the requested coordinateSystem: sidereal (Lahiri ayanamsa) by default, tropical when asked.
    pub longitude: f64,
    /// Planet crossing the ecliptic plane. Sun is excluded (always on the ecliptic by definition). Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use planetLocalized for anything a reader sees.
    pub planet: String,
    /// Planet name in the requested language, for display. Present only when lang is set to a language other than English, since in English it would repeat planet exactly.
    #[serde(rename = "planetLocalized", skip_serializing_if = "Option::is_none")]
    pub planet_localized: Option<String>,
    /// Zodiac sign the planet occupies at the crossing, read in the same coordinateSystem as longitude: the rashi under sidereal, the tropical sign under tropical. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use signLocalized for anything a reader sees.
    pub sign: String,
    /// Zodiac sign name in the requested language, for display. Present only when lang is set to a language other than English, since in English it would repeat sign exactly.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
    /// Time of the ecliptic crossing (HH:MM, 24-hour). Adjusted to requested timezone.
    pub time: String,
}
string_enum! {
    /// Ascending = planet moves from south to north of the ecliptic. Descending = north to south.
    GetEclipticCrossingsResponseEventsItemDirection {
        Ascending = "ascending",
        Descending = "descending",
    }
}
/// Request body of `getEclipticCrossings`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetEclipticCrossingsRequest {
    /// Coordinate system for longitude output. "sidereal" (Nirayana) uses Lahiri ayanamsa, the standard for Vedic astrology. "tropical" (Sayana) uses raw ecliptic longitude matching Western astrology. Defaults to "sidereal".
    #[serde(rename = "coordinateSystem", skip_serializing_if = "Option::is_none")]
    pub coordinate_system: Option<GetEclipticCrossingsRequestCoordinateSystem>,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved once, at the start of the window, and that offset applies to every time in the response. Output times are converted to this timezone. Defaults to 0 (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetEclipticCrossingsRequestTimezone>,
    /// Year to scan for ecliptic crossings (1551 to 2649).
    pub year: i64,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved once, at the start of the window, and that offset applies to every time in the response. Output times are converted to this timezone. Defaults to 0 (UTC).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetEclipticCrossingsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Coordinate system for longitude output. "sidereal" (Nirayana) uses Lahiri ayanamsa, the standard for Vedic astrology. "tropical" (Sayana) uses raw ecliptic longitude matching Western astrology. Defaults to "sidereal".
    GetEclipticCrossingsRequestCoordinateSystem {
        Sidereal = "sidereal",
        Tropical = "tropical",
    }
}
/// Path and query parameters of `getEclipticCrossings`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetEclipticCrossingsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetEclipticCrossingsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetEclipticCrossingsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getDosha`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDoshaResponse {
    /// One dosha with its qualities, seats, pentad and states.
    pub dosha: GetDoshaResponseDosha,
    /// Scope of the response.
    pub meta: GetDoshaResponseMeta,
    /// Every work behind this response, once each.
    pub sources: Vec<GetDoshaResponseSourcesItem>,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDoshaResponseSourcesItem {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// Scope of the response.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDoshaResponseMeta {
    /// The scope of everything in this response, in the requested language. Present on every response from this API, and intended to be shown to the reader rather than stripped.
    pub disclaimer: String,
}
/// One dosha with its qualities, seats, pentad and states.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDoshaResponseDosha {
    /// Other names the primary texts use for the same dosha. Data rather than translations, and useful when reading a verse that names one of them instead.
    #[serde(rename = "alsoCalled")]
    pub also_called: Vec<String>,
    /// The same name in Devanagari. Data, identical in every language.
    pub devanagari: String,
    /// The single mahabhuta the classical verses give this dosha. Classically each dosha gets one element, not a pair.
    pub element: String,
    /// What the dosha does when it is even. For vata the text states this for the dosha as a whole; for the other two it states it only through the five sub-doshas, and those are what appear here.
    pub functions: Vec<String>,
    /// The dosha as a Sanskrit identifier: vata, pitta or kapha. Never translated in any language, because a caller switches on it, and a translated dosha name is a different concept rather than the same one in another language.
    pub id: String,
    /// The two-element pairing in general modern circulation. It carries no classical citation in this API, which is why it travels in its own field instead of inside the cited one.
    #[serde(rename = "modernElementPair")]
    pub modern_element_pair: String,
    /// The qualities the frame chapter gives this dosha, each as its Sanskrit word and its gloss. The three sets overlap, so the twenty gunas are not partitioned three ways between them.
    pub qualities: Vec<String>,
    /// Identifiers from the twenty gunas for the qualities the guna verse names with the SAME Sanskrit word, so this joins straight to the qualities endpoint. Where the dosha chapter uses a synonym, or a word the guna verse does not carry, the entry is absent rather than mapped by resemblance.
    #[serde(rename = "qualityGunas")]
    pub quality_gunas: Vec<String>,
    /// The same name in the standard diacritic transliteration.
    #[serde(rename = "sanskritName")]
    pub sanskrit_name: String,
    /// Where the dosha sits, in the requested language.
    pub seats: Vec<String>,
    /// How the second primary text reads the same list. The two are recorded side by side and never merged, because the special seat of pitta genuinely differs between them.
    #[serde(rename = "seatsVariant")]
    pub seats_variant: String,
    /// Where one claim in this response comes from.
    pub source: GetDoshaResponseDoshaSource,
    /// The seat the chapter singles out above the others.
    #[serde(rename = "specialSeat")]
    pub special_seat: String,
    /// The three states, as positions and qualities.
    pub states: GetDoshaResponseDoshaStates,
    /// The five sub-doshas, each with its seat and its work. The five vata NAMES are carried by two texts; every seat and function of the fifteen rests on one chapter alone.
    #[serde(rename = "subDoshas")]
    pub sub_doshas: Vec<GetDoshaResponseDoshaSubDoshasItem>,
}
/// One of the five sub-doshas.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDoshaResponseDoshaSubDoshasItem {
    /// The same name in Devanagari. Data rather than a translation, so it is identical under every language.
    pub devanagari: String,
    /// What the sub-dosha does, in the requested language.
    pub function: String,
    /// Stable identifier for the sub-dosha. Always English-safe and lowercase, and never translated, so it is safe to compare against.
    pub id: String,
    /// Where the sub-dosha moves, where the chapter states one. Present on the five vatas and absent elsewhere, because the chapter gives a range of movement only for those.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub moves: Option<String>,
    /// The same name in the standard diacritic transliteration.
    #[serde(rename = "sanskritName")]
    pub sanskrit_name: String,
    /// Where the sub-dosha sits, in the requested language.
    pub seat: String,
    /// Where one claim in this response comes from.
    pub source: GetDoshaResponseDoshaSubDoshasItemSource,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDoshaResponseDoshaSubDoshasItemSource {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// The three states, as positions and qualities.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDoshaResponseDoshaStates {
    /// The first state of the seasonal cycle, described the same way.
    pub accumulating: String,
    /// The second state of the seasonal cycle, described the same way.
    pub aggravated: String,
    /// The even state, described as a position and a quality rather than as an absence of complaints.
    pub balanced: String,
    /// The qualities that bring the dosha back to even, which is the like-increases-like rule applied in reverse.
    #[serde(rename = "settlesWith")]
    pub settles_with: String,
    /// Where one claim in this response comes from.
    pub source: GetDoshaResponseDoshaStatesSource,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDoshaResponseDoshaStatesSource {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDoshaResponseDoshaSource {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// Path and query parameters of `getDosha`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDoshaParams {
    /// Dosha identifier, case-insensitive. One of vata, pitta or kapha.
    pub id: GetDoshaParamsId,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetDoshaParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetDoshaParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Dosha identifier, case-insensitive. One of vata, pitta or kapha.
    GetDoshaParamsId {
        Vata = "vata",
        Pitta = "pitta",
        Kapha = "kapha",
    }
}
/// Response body of `getDinacharyaSchedule`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDinacharyaScheduleResponse {
    /// The same six blocks under the other convention, so a caller can show one and reconcile against the other without a second call.
    #[serde(rename = "alternatePeriods")]
    pub alternate_periods: Vec<GetDinacharyaScheduleResponseAlternatePeriodsItem>,
    /// The pre-dawn window, as a fixed offset from sunrise. It is not scaled to the length of the night, and calculators that scale it are following a reading the commentary rejects.
    #[serde(rename = "brahmaMuhurta")]
    pub brahma_muhurta: GetDinacharyaScheduleResponseBrahmaMuhurta,
    /// The conventions this schedule was produced under.
    pub conventions: GetDinacharyaScheduleResponseConventions,
    /// The local date this schedule is for, echoing the request.
    pub date: String,
    /// The six blocks under the convention that was requested, in chronological order.
    #[serde(rename = "doshaPeriods")]
    pub dosha_periods: Vec<GetDinacharyaScheduleResponseDoshaPeriodsItem>,
    /// Scope of the response.
    pub meta: GetDinacharyaScheduleResponseMeta,
    /// The following sunrise, as an ISO 8601 instant in UTC. It closes the night, so the three night blocks are cut between this and the sunset above.
    #[serde(rename = "nextSunrise")]
    pub next_sunrise: String,
    /// The daily sequence the chapter gives, in its own order.
    pub routine: Vec<GetDinacharyaScheduleResponseRoutineItem>,
    /// Every work behind this response, once each.
    pub sources: Vec<GetDinacharyaScheduleResponseSourcesItem>,
    /// The day in prose, composed and translated in place.
    pub summary: String,
    /// Sunrise at this place on this date, as an ISO 8601 instant in UTC. The day begins here, which is why every block below is measured from it rather than from midnight.
    pub sunrise: String,
    /// Sunset at this place on this date, as an ISO 8601 instant in UTC.
    pub sunset: String,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDinacharyaScheduleResponseSourcesItem {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// One step of the daily routine.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDinacharyaScheduleResponseRoutineItem {
    /// What the step is, written from the source and translated in place. The chapter also names specific substances and gives lists of who should abstain; neither is carried here.
    pub guidance: String,
    /// Stable identifier for the step. Always English and lowercase, so it is safe to compare against and to key a translation off.
    pub id: String,
    /// Position in the sequence the chapter gives, starting at 1.
    pub order: f64,
    /// The step under its Sanskrit name, in the standard diacritic transliteration. Data rather than a translation, so it is identical under every language.
    #[serde(rename = "sanskritName")]
    pub sanskrit_name: String,
    /// Where one claim in this response comes from.
    pub source: GetDinacharyaScheduleResponseRoutineItemSource,
    /// Where the step sits in the sequence. Only the first step carries a real offset, because the chapter orders the day rather than scheduling it; the clock for this place is in the fields above.
    pub timing: String,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDinacharyaScheduleResponseRoutineItemSource {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// Scope of the response.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDinacharyaScheduleResponseMeta {
    /// The scope of everything in this response, in the requested language. Present on every response from this API, and intended to be shown to the reader rather than stripped.
    pub disclaimer: String,
}
/// One of the six dosha periods.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDinacharyaScheduleResponseDoshaPeriodsItem {
    /// The humour this block belongs to, as the Sanskrit identifier. Never translated, so it stays safe to compare against and to use as a style key.
    pub dosha: String,
    /// When the block closes, as an ISO 8601 instant in UTC.
    pub end: String,
    /// Whether the block sits in the day or the night. Always English, so it stays safe to switch on.
    pub span: String,
    /// When the block opens, as an ISO 8601 instant in UTC.
    pub start: String,
    /// Which third of its half the block is, 1 for the first, 2 for the middle and 3 for the last. Present only on the sunrise-anchored division, because the clock grid divides no actual day and has no thirds to report.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub third: Option<f64>,
}
/// The conventions this schedule was produced under.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDinacharyaScheduleResponseConventions {
    /// Which division the doshaPeriods array holds. Echoes the request; the other one is in alternatePeriods.
    #[serde(rename = "doshaClock")]
    pub dosha_clock: String,
}
/// The pre-dawn window, as a fixed offset from sunrise. It is not scaled to the length of the night, and calculators that scale it are following a reading the commentary rejects.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDinacharyaScheduleResponseBrahmaMuhurta {
    /// When the window closes, 48 minutes before sunrise.
    pub end: String,
    /// Length of one muhurta in minutes. Thirty of them make one day AND night together, not thirty in the daylight alone, and reading it the other way doubles every number here.
    #[serde(rename = "muhurtaMinutes")]
    pub muhurta_minutes: f64,
    /// Muhurtas in one full day and night. Two texts state this and agree exactly on it while differing on the smaller units.
    #[serde(rename = "muhurtasPerAhoratra")]
    pub muhurtas_per_ahoratra: f64,
    /// Where one claim in this response comes from.
    pub source: GetDinacharyaScheduleResponseBrahmaMuhurtaSource,
    /// When the window opens, 96 minutes before sunrise.
    pub start: String,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDinacharyaScheduleResponseBrahmaMuhurtaSource {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// One of the six dosha periods.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDinacharyaScheduleResponseAlternatePeriodsItem {
    /// The humour this block belongs to, as the Sanskrit identifier. Never translated, so it stays safe to compare against and to use as a style key.
    pub dosha: String,
    /// When the block closes, as an ISO 8601 instant in UTC.
    pub end: String,
    /// Whether the block sits in the day or the night. Always English, so it stays safe to switch on.
    pub span: String,
    /// When the block opens, as an ISO 8601 instant in UTC.
    pub start: String,
    /// Which third of its half the block is, 1 for the first, 2 for the middle and 3 for the last. Present only on the sunrise-anchored division, because the clock grid divides no actual day and has no thirds to report.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub third: Option<f64>,
}
/// Path and query parameters of `getDinacharyaSchedule`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetDinacharyaScheduleParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetDinacharyaScheduleParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetDinacharyaScheduleParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getDikpalaDirection`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDikpalaDirectionResponse {
    /// The devatas of the squares this direction covers, in the same order as the squares list.
    pub devatas: Vec<GetDikpalaDirectionResponseDevatasItem>,
    /// The lord of this quarter of the horizon, per Brihat Samhita 54.3. A Sanskrit proper noun: romanised with the diacritics the transliteration carries in every language, and written in Devanagari as the Sanskrit text prints it when lang is hi. Compare on id, never on this. These are NOT the 45 mandala devatas and the two sets must not be merged: Agni is the north-east mandala square and the south-east dikpala.
    pub dikpala: String,
    /// The element conventionally assigned to this quarter: fire, earth, air or water. Present only on the four intercardinal quarters, because the cardinal ones carry none in this scheme, and it is labelled convention because the Brihat Samhita assigns no element to any direction at all.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub element: Option<String>,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against and against the same value on the feng shui and I Ching endpoints.
    pub id: String,
    /// Whether this is one of the four cardinal directions or one of the four intercardinal quarters. Always English.
    pub kind: String,
    /// What Brihat Samhita 53.118 puts on this side, in the chapter own terms. Present on the four intercardinal quarters, which are the only ones that verse places anything on.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub places: Option<String>,
    /// The verses behind each part of this entry, and the convention label on the element where no verse gives one.
    pub sources: Vec<GetDikpalaDirectionResponseSourcesItem>,
    /// The squares of the 81 pada grid this direction covers. For a cardinal direction those are its eight perimeter squares in the order the verses enumerate them; for an intercardinal quarter they are the corner square and the four single pada squares gathered around it.
    pub squares: Vec<f64>,
    /// What the chapter says about standing water here, which it gives for all eight directions.
    pub water: GetDikpalaDirectionResponseWater,
}
/// What the chapter says about standing water here, which it gives for all eight directions.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDikpalaDirectionResponseWater {
    /// Whether that effect is a gain or a harm. Only the north and the north-east are gains. Always English.
    pub auspiciousness: String,
    /// What 53.119 says follows from standing water in this quarter, as original prose.
    pub effect: String,
}
/// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDikpalaDirectionResponseSourcesItem {
    /// Why a convention rule says what it says. Present only when text is convention, and it names the tradition the rule comes from rather than a verse.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub basis: Option<String>,
    /// Chapter of the primary text. Absent on a convention, which has no chapter to cite.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chapter: Option<f64>,
    /// Whether the cited edition is in the public domain. True on the 1884 Brihat Samhita edition, whose verses are quoted. False on the 1933 Manasara edition behind the Ayadi formulas, from which only the multipliers, divisors and names are taken, never a sentence.
    #[serde(rename = "publicDomain", skip_serializing_if = "Option::is_none")]
    pub public_domain: Option<bool>,
    /// The primary text this verdict rests on, or the literal value convention where no verse states the rule. Always English, safe to compare against.
    pub text: String,
    /// Translator of the edition the verse was read in. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation: Option<String>,
    /// Verse or verse range inside the chapter. Absent on a convention. A range is written with a hyphen, as in 115-117.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub verse: Option<String>,
    /// Publication year of that edition. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<f64>,
}
/// One entry of `devatas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDikpalaDirectionResponseDevatasItem {
    /// Identifier of the devata holding it. Always English transliteration, safe to compare against and to look up on the devatas endpoint.
    pub id: String,
    /// Display name of the devata. A Sanskrit proper noun: romanised with the diacritics the transliteration carries in every language, and written in Devanagari as the Sanskrit text prints it when lang is hi.
    pub name: String,
    /// Square number in the 81 pada grid.
    pub square: f64,
}
/// Path and query parameters of `getDikpalaDirection`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDikpalaDirectionParams {
    /// Direction id, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Case and punctuation are folded.
    pub id: GetDikpalaDirectionParamsId,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetDikpalaDirectionParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetDikpalaDirectionParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Direction id, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Case and punctuation are folded.
    GetDikpalaDirectionParamsId {
        North = "North",
        Northeast = "Northeast",
        East = "East",
        Southeast = "Southeast",
        South = "South",
        Southwest = "Southwest",
        West = "West",
        Northwest = "Northwest",
    }
}
/// Response body of `getDevata`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDevataResponse {
    /// The same squares as row and column pairs, which is what you draw with. The corners of the grid are 1 north-east, 9 south-east, 73 north-west and 81 south-west.
    pub cells: Vec<GetDevataResponseCellsItem>,
    /// Which ring of the mandala the devata belongs to: perimeter for the outer 32, innerRing for the eight around Brahma, innerCorner for the four on the inner diagonals, center for Brahma alone. 32 plus 8 plus 4 plus 1 is 45. Always English.
    pub class: GetDevataResponseClass,
    /// The entrance pada this devata governs, 1 to 32. Present only on the outer 32, since only a perimeter square can hold a main door.
    #[serde(rename = "entrancePada", skip_serializing_if = "Option::is_none")]
    pub entrance_pada: Option<f64>,
    /// How many squares the devata holds under 53.49 to 50: padika for one, dvipada for two, tripada for three. Absent for Brahma, whom those verses leave outside the scheme while enumerating 44 devatas.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub group: Option<String>,
    /// Identifier of the devata, lower case transliteration. Always English, safe to compare against. Indra appears twice in the chapter, on the east perimeter and on the inner ring, so those two carry the ids indra-outer and indra-inner, which are ours: no source read for this package prints a distinguishing name for either.
    pub id: String,
    /// Display name of the devata. A Sanskrit proper noun: romanised with the diacritics the transliteration carries in every language, and written in Devanagari as the Sanskrit text prints it when lang is hi. Compare on id, never on this.
    pub name: String,
    /// Where the sources disagree or contradict themselves about this row, and where Brahma sits outside the pada-count scheme. Present on the six rows that carry a recorded divergence: the two Indras, the north-east and south-east corner devatas where the Manasara differs from the Brihat Samhita, Prthvidhara, whom the chapter places on two different squares in two different verses, and Brahma. Original prose, translated in place when lang is set.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// How many squares the devata holds: one, two or three for the 44 enumerated devatas, and nine for Brahma.
    #[serde(rename = "padaCount")]
    pub pada_count: f64,
    /// Which quarter of the mandala the devata occupies, where it sits in one. Absent for a devata spread along a side rather than gathered in a corner.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub quadrant: Option<String>,
    /// What the devata holds, as a sentence composed from the sourced structure. There is deliberately no meaning field: no source read for this package gives a devata a meaning, and inventing one would be unsourced content on a route that sells a citation per verdict. Translated in place when lang is set.
    pub role: String,
    /// Which side of the perimeter the devata sits on. Present only on the outer 32, which are the ones the verses enumerate side by side.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub side: Option<String>,
    /// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
    pub source: GetDevataResponseSource,
    /// Which of the 81 squares the devata holds. The verses name one square per devata and fix the pada count of each, and the remaining squares follow from that count: a dvipada takes its named square plus the one a step inward, a tripada the three cell cardinal run of the second ring.
    pub squares: Vec<f64>,
    /// Which verses of chapter 53 place this devata and fix its pada count, so a report can print the citation.
    pub verses: Vec<String>,
}
/// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDevataResponseSource {
    /// Why a convention rule says what it says. Present only when text is convention, and it names the tradition the rule comes from rather than a verse.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub basis: Option<String>,
    /// Chapter of the primary text. Absent on a convention, which has no chapter to cite.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chapter: Option<f64>,
    /// Whether the cited edition is in the public domain. True on the 1884 Brihat Samhita edition, whose verses are quoted. False on the 1933 Manasara edition behind the Ayadi formulas, from which only the multipliers, divisors and names are taken, never a sentence.
    #[serde(rename = "publicDomain", skip_serializing_if = "Option::is_none")]
    pub public_domain: Option<bool>,
    /// The primary text this verdict rests on, or the literal value convention where no verse states the rule. Always English, safe to compare against.
    pub text: String,
    /// Translator of the edition the verse was read in. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation: Option<String>,
    /// Verse or verse range inside the chapter. Absent on a convention. A range is written with a hyphen, as in 115-117.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub verse: Option<String>,
    /// Publication year of that edition. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<f64>,
}
string_enum! {
    /// Which ring of the mandala the devata belongs to: perimeter for the outer 32, innerRing for the eight around Brahma, innerCorner for the four on the inner diagonals, center for Brahma alone. 32 plus 8 plus 4 plus 1 is 45. Always English.
    GetDevataResponseClass {
        Perimeter = "perimeter",
        InnerRing = "innerRing",
        InnerCorner = "innerCorner",
        Center = "center",
    }
}
/// One entry of `cells`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDevataResponseCellsItem {
    /// Column of the grid, 1 at the western edge and 9 at the eastern one.
    #[serde(rename = "columnFromWest")]
    pub column_from_west: f64,
    /// Row of the grid, 1 at the northern edge and 9 at the southern one.
    #[serde(rename = "rowFromNorth")]
    pub row_from_north: f64,
}
/// Path and query parameters of `getDevata`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDevataParams {
    /// Devata id, lower case transliteration. The two Indras are indra-outer for the east perimeter square and indra-inner for the inner ring one. Case and punctuation are folded.
    pub id: GetDevataParamsId,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetDevataParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetDevataParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Devata id, lower case transliteration. The two Indras are indra-outer for the east perimeter square and indra-inner for the inner ring one. Case and punctuation are folded.
    GetDevataParamsId {
        Agni = "agni",
        Parjanya = "parjanya",
        Jayanta = "jayanta",
        IndraOuter = "indra-outer",
        Surya = "surya",
        Satya = "satya",
        Bhrisa = "bhrisa",
        Antariksha = "antariksha",
        Vayu = "vayu",
        Pusha = "pusha",
        Vitatha = "vitatha",
        Brihatkshata = "brihatkshata",
        Yama = "yama",
        Gandharva = "gandharva",
        Bhringaraja = "bhringaraja",
        Mriga = "mriga",
        Pitri = "pitri",
        Dauvarika = "dauvarika",
        Sugriva = "sugriva",
        Kusumadanta = "kusumadanta",
        Varuna = "varuna",
        Asura = "asura",
        Sosha = "sosha",
        Papayakshma = "papayakshma",
        Roga = "roga",
        Ahi = "ahi",
        Mukhya = "mukhya",
        Bhallata = "bhallata",
        Soma = "soma",
        Bhujaga = "bhujaga",
        Aditi = "aditi",
        Diti = "diti",
        Aryaman = "aryaman",
        Savita = "savita",
        Vivasvan = "vivasvan",
        IndraInner = "indra-inner",
        Mitra = "mitra",
        Rajayakshma = "rajayakshma",
        Prthvidhara = "prthvidhara",
        Apavatsa = "apavatsa",
        Apa = "apa",
        Savitra = "savitra",
        Jaya = "jaya",
        Rudra = "rudra",
        Brahma = "brahma",
    }
}
/// Response body of `getDetailedPanchang`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponse {
    /// Abhijit Muhurta (Abhijit Muhurat), the most auspicious ~48-minute window around solar noon, the 8th of 15 day muhurtas. Ideal for starting new ventures, signing contracts, and performing rituals when no other shubh muhurat is available. Null on Wednesdays because Abhijit coincides with Dur Muhurta on that weekday per Muhurta Chintamani.
    #[serde(rename = "abhijitMuhurta")]
    pub abhijit_muhurta: Option<GetDetailedPanchangResponseAbhijitMuhurta>,
    /// Amrit Kalam (Amrit Ghati, Amrita Yoga), the most auspicious ~96-minute period based on Moon transit through specific ghati fractions within the current nakshatra. Each of the 27 nakshatras has a fixed Amrit window. Activities initiated during Amrit Kalam are believed to yield excellent, lasting results. Highly recommended for muhurta selection when other auspicious yogas are absent. Usually 1-2 periods per panchang day.
    #[serde(rename = "amritKalam")]
    pub amrit_kalam: Vec<GetDetailedPanchangResponseAmritKalamItem>,
    /// Bhadra (Vishti Karana), the 7th movable karana, avoided for all auspicious activities. Bhadra recurs roughly every 3 to 5 days and lasts about half a tithi. active is true whenever a Bhadra is attributed to this date; startsAt and endsAt give the window, which may end on the next calendar day.
    pub bhadra: GetDetailedPanchangResponseBhadra,
    /// Brahma Muhurta, sacred pre-dawn period approximately 96 minutes before sunrise (14th of 15 night muhurtas). Considered the best time for meditation, mantra japa, Vedic study, and spiritual sadhana. Referenced in Ashtanga Hridaya and Dharmashastra texts.
    #[serde(rename = "brahmaMuhurta")]
    pub brahma_muhurta: GetDetailedPanchangResponseBrahmaMuhurta,
    /// Chandrabalam (Moon strength). indicates auspiciousness of Moon transit for each birth rashi. Essential for muhurta selection in Vedic electional astrology.
    pub chandrabalam: GetDetailedPanchangResponseChandrabalam,
    /// Date for which panchang is calculated.
    pub date: String,
    /// Dur Muhurta (Dur Muhurtam), inauspicious muhurta periods determined by the weekday. The daytime is divided into 15 muhurtas from sunrise to sunset. Specific muhurta numbers are inauspicious each weekday per Muhurta Chintamani. Each period lasts ~48 minutes. Most days have 2 Dur Muhurtas, Wednesday and Sunday have 1. Avoid initiating important activities during these periods.
    #[serde(rename = "durMuhurta")]
    pub dur_muhurta: Vec<GetDetailedPanchangResponseDurMuhurtaItem>,
    /// Godhuli Muhurta (cow dust time), 12 minutes before sunset to 12 minutes after sunset. Universally auspicious for any activity, especially marriages and grihapravesha. No blemish from tithi, vara, nakshatra, karana, or yoga applies during Godhuli. Null only in polar regions where sun does not set.
    #[serde(rename = "godhuliMuhurta")]
    pub godhuli_muhurta: Option<GetDetailedPanchangResponseGodhuliMuhurta>,
    /// Gulika Kaal, inauspicious period ruled by Saturn son Gulika. Considered harmful for initiating work.
    pub gulika: GetDetailedPanchangResponseGulika,
    /// Current planetary hora. Used for electional astrology and muhurta selection.
    pub hora: GetDetailedPanchangResponseHora,
    /// Karana (half-tithi) information. Fourth panchang element, changes twice per tithi.
    pub karana: GetDetailedPanchangResponseKarana,
    /// Location coordinates used for all time-based calculations.
    pub location: GetDetailedPanchangResponseLocation,
    /// Moon sign (Chandra Rashi) at sunrise. Central to Vedic astrology. determines daily emotional tone, Chandrabalam, and Tarabalam.
    #[serde(rename = "moonSign")]
    pub moon_sign: GetDetailedPanchangResponseMoonSign,
    /// Moonrise time in the requested timezone. Can be null if Moon does not rise on this date.
    pub moonrise: Option<String>,
    /// Moonset time in the requested timezone. Can be null if Moon does not set on this date.
    pub moonset: Option<String>,
    /// Nakshatra (lunar mansion) information with interpretations
    pub nakshatra: GetDetailedPanchangResponseNakshatra,
    /// Nishita Muhurta (Nishith Kaal), the 8th of 15 night muhurtas from sunset to next sunrise, occurring around midnight. Sacred period for worship of Lord Shiva, especially on Maha Shivaratri. Also significant for Janmashtami midnight celebrations and tantric sadhana.
    #[serde(rename = "nishitaMuhurta")]
    pub nishita_muhurta: GetDetailedPanchangResponseNishitaMuhurta,
    /// Panchaka, the inauspicious ~5-day window while the Moon transits the last five nakshatras (Dhanishta 3rd pada through Revati, 300 to 360 degrees sidereal). The dosha type depends on the weekday it begins; startsAt and endsAt report the period in force at sunrise or beginning later this day. Avoid major activities during Panchaka.
    pub panchaka: GetDetailedPanchangResponsePanchaka,
    /// Pratah Sandhya, morning twilight junction period for Sandhyavandanam prayer. Spans 3 night ghatis before sunrise to sunrise. Duration varies by location and season based on ratrimana (night duration). One of the three daily Sandhya prayer times prescribed in Dharmashastra.
    #[serde(rename = "pratahSandhya")]
    pub pratah_sandhya: Option<GetDetailedPanchangResponsePratahSandhya>,
    /// Rahu Kaal, inauspicious period ruled by Rahu. Avoid starting new ventures. Calculated from sunrise duration divided into 8 parts.
    #[serde(rename = "rahuKaal")]
    pub rahu_kaal: GetDetailedPanchangResponseRahuKaal,
    /// Sayahna Sandhya, evening twilight junction period for Sandhyavandanam prayer. Spans sunset to 3 night ghatis after sunset. Duration varies by location and season based on ratrimana (night duration). One of the three daily Sandhya prayer times prescribed in Dharmashastra.
    #[serde(rename = "sayahnaSandhya")]
    pub sayahna_sandhya: Option<GetDetailedPanchangResponseSayahnaSandhya>,
    /// Sun nakshatra at sunrise. The Sun spends approximately 13-14 days in each nakshatra. Used for Surya-based muhurta and festival calculations.
    #[serde(rename = "sunNakshatra")]
    pub sun_nakshatra: GetDetailedPanchangResponseSunNakshatra,
    /// Sun sign (Surya Rashi) at sunrise. Determines the solar month (Saura Masa) in the Hindu calendar. Changes approximately once a month (Sankranti).
    #[serde(rename = "sunSign")]
    pub sun_sign: GetDetailedPanchangResponseSunSign,
    /// Local sunrise in the requested timezone as YYYY-MM-DDTHH:MM:SS, with no zone suffix. Marks the start of the Hindu day.
    pub sunrise: String,
    /// Local sunset in the requested timezone as YYYY-MM-DDTHH:MM:SS, with no zone suffix. Marks the transition to night muhurtas.
    pub sunset: String,
    /// Tarabalam (Star strength). based on the 9-Tara nakshatra cycle. Determines favorability of Moon nakshatra transit relative to each of the 27 birth nakshatras.
    pub tarabalam: GetDetailedPanchangResponseTarabalam,
    /// Lunar day (tithi) information with interpretations. Central panchang element for determining auspicious timings.
    pub tithi: GetDetailedPanchangResponseTithi,
    /// Panchang element transition times: when each element (tithi, yoga, karana, nakshatra, Moon sign) changes, found to the second. Essential for precise muhurta determination and panchang calendars.
    pub transitions: GetDetailedPanchangResponseTransitions,
    /// Vara (weekday) information based on Hindu sunrise calendar.
    pub vara: GetDetailedPanchangResponseVara,
    /// Varjyam (Thyajyam, Vishghati, Nakshatra Thyajyam), inauspicious ~96-minute period based on Moon transit through specific ghati fractions within the current nakshatra. Each of the 27 nakshatras has a fixed Varjyam window measured in ghatikas (1 ghati = 24 minutes). Avoid starting new ventures, travel, or auspicious ceremonies during Varjyam. Usually 1-2 periods per panchang day.
    pub varjyam: Vec<GetDetailedPanchangResponseVarjyamItem>,
    /// Vijaya Muhurta (Vijay Muhurat), the 11th of 15 day muhurtas between sunrise and sunset. Auspicious for journeys, legal proceedings, competitions, warfare, and any activity requiring victory or success. Used in electional astrology (muhurta shastra) for timing important undertakings.
    #[serde(rename = "vijayaMuhurta")]
    pub vijaya_muhurta: GetDetailedPanchangResponseVijayaMuhurta,
    /// Yamaganda, inauspicious period ruled by Yama (lord of death). Avoid important activities.
    pub yamaganda: GetDetailedPanchangResponseYamaganda,
    /// Nitya Yoga information. Yoga is the third panchang element, derived from combined Sun-Moon longitude.
    pub yoga: GetDetailedPanchangResponseYoga,
}
/// Nitya Yoga information. Yoga is the third panchang element, derived from combined Sun-Moon longitude.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseYoga {
    /// Characteristics and auspiciousness of this yoga for activity planning.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub characteristics: Option<String>,
    /// Sanskrit name of the Nitya Yoga. One of 27 yogas formed by combined Sun-Moon motion, each with distinct auspiciousness.
    pub name: String,
    /// Nitya Yoga index (1-27). Calculated from the sum of Sun and Moon sidereal longitudes divided by 13 degrees 20 minutes.
    pub number: i64,
}
/// Yamaganda, inauspicious period ruled by Yama (lord of death). Avoid important activities.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseYamaganda {
    /// Period end time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub end: String,
    /// Period start time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub start: String,
}
/// Vijaya Muhurta (Vijay Muhurat), the 11th of 15 day muhurtas between sunrise and sunset. Auspicious for journeys, legal proceedings, competitions, warfare, and any activity requiring victory or success. Used in electional astrology (muhurta shastra) for timing important undertakings.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseVijayaMuhurta {
    /// Period end time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub end: String,
    /// Period start time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub start: String,
}
/// One entry of `varjyam`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseVarjyamItem {
    /// Period end time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub end: String,
    /// Period start time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub start: String,
}
/// Vara (weekday) information based on Hindu sunrise calendar.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseVara {
    /// Ruling planet of the day (Vara lord). Influences day-level auspiciousness.
    pub lord: String,
    /// Weekday name in English. Vara begins at local sunrise, not at midnight, so a time before sunrise belongs to the previous vara.
    pub name: String,
    /// Vara name transliterated from Sanskrit: Ravivara, Somavara, Mangalavara, Budhavara, Guruvara, Shukravara, Shanivara. Use this rather than name for a Jyotish-facing reading, since it is the form the classical texts use and it does not change with the lang parameter.
    #[serde(rename = "sanskritName")]
    pub sanskrit_name: String,
}
/// Panchang element transition times: when each element (tithi, yoga, karana, nakshatra, Moon sign) changes, found to the second. Essential for precise muhurta determination and panchang calendars.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseTransitions {
    /// Karana (half-tithi) transition. karanas change twice per tithi. Important for muhurta timing.
    pub karana: GetDetailedPanchangResponseTransitionsKarana,
    /// Moon sign (Chandra rashi) transition, when Moon changes zodiac sign. Affects Chandrabalam, Tarabalam, and daily horoscope predictions.
    #[serde(rename = "moonSign")]
    pub moon_sign: GetDetailedPanchangResponseTransitionsMoonSign,
    /// Nakshatra (lunar mansion) transition timing: when Moon moves to the next nakshatra. Critical for muhurta and Tarabalam calculations.
    pub nakshatra: GetDetailedPanchangResponseTransitionsNakshatra,
    /// Tithi (lunar day) transition timing: when the current tithi ends and the next one begins.
    pub tithi: GetDetailedPanchangResponseTransitionsTithi,
    /// Nitya Yoga transition timing: when the current yoga period ends. Based on combined Sun-Moon motion.
    pub yoga: GetDetailedPanchangResponseTransitionsYoga,
}
/// Nitya Yoga transition timing: when the current yoga period ends. Based on combined Sun-Moon motion.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseTransitionsYoga {
    /// Local time in the requested timezone (ISO 8601, no offset suffix) when the current yoga ends.
    #[serde(rename = "endsAt")]
    pub ends_at: String,
    /// Name of the next yoga.
    pub next: String,
}
/// Tithi (lunar day) transition timing: when the current tithi ends and the next one begins.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseTransitionsTithi {
    /// Local time in the requested timezone (ISO 8601, no offset suffix) when the current tithi ends. Precise to ~1 minute via binary search.
    #[serde(rename = "endsAt")]
    pub ends_at: String,
    /// Name of the next tithi that begins after the transition.
    pub next: String,
}
/// Nakshatra (lunar mansion) transition timing: when Moon moves to the next nakshatra. Critical for muhurta and Tarabalam calculations.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseTransitionsNakshatra {
    /// Local time in the requested timezone (ISO 8601, no offset suffix) when the Moon leaves the current nakshatra.
    #[serde(rename = "endsAt")]
    pub ends_at: String,
    /// Name of the next nakshatra the Moon will enter.
    pub next: String,
    /// Pada (quarter, 1-4) of the next nakshatra. Each nakshatra has 4 padas spanning 3 degrees 20 minutes each.
    #[serde(rename = "nextPada")]
    pub next_pada: f64,
}
/// Moon sign (Chandra rashi) transition, when Moon changes zodiac sign. Affects Chandrabalam, Tarabalam, and daily horoscope predictions.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseTransitionsMoonSign {
    /// Local time in the requested timezone (ISO 8601, no offset suffix) when Moon enters the next rashi. Moon changes sign approximately every 2.25 days.
    #[serde(rename = "changesAt")]
    pub changes_at: String,
    /// Current Moon rashi (zodiac sign).
    pub current: String,
    /// Next rashi the Moon will enter.
    pub next: String,
}
/// Karana (half-tithi) transition. karanas change twice per tithi. Important for muhurta timing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseTransitionsKarana {
    /// Local time in the requested timezone (ISO 8601, no offset suffix) when the current karana ends.
    #[serde(rename = "endsAt")]
    pub ends_at: String,
    /// Name of the next karana (half-tithi).
    pub next: String,
}
/// Lunar day (tithi) information with interpretations. Central panchang element for determining auspicious timings.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseTithi {
    /// Presiding deity of this tithi from Vedic tradition.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deity: Option<String>,
    /// Elemental quality of this tithi (Fire, Earth, Air, Water, Ether).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub element: Option<String>,
    /// Sanskrit name of the tithi (lunar day). One of 30 tithis in the lunar month cycle.
    pub name: String,
    /// Tithi number (1-30). 1-15 are Shukla Paksha (waxing), 16-30 are Krishna Paksha (waning). Purnima is 15, Amavasya is 30.
    pub number: i64,
    /// Lunar fortnight: Shukla (waxing, bright half) or Krishna (waning, dark half).
    pub paksha: GetDetailedPanchangResponseTithiPaksha,
    /// Percentage of the current tithi elapsed (0-100). Useful for determining tithi strength and transition proximity.
    pub percent: f64,
    /// Planetary ruler of this tithi. Influences the day energy and activities.
    #[serde(rename = "rulingPlanet", skip_serializing_if = "Option::is_none")]
    pub ruling_planet: Option<String>,
}
string_enum! {
    /// Lunar fortnight: Shukla (waxing, bright half) or Krishna (waning, dark half).
    GetDetailedPanchangResponseTithiPaksha {
        Shukla = "Shukla",
        Krishna = "Krishna",
    }
}
/// Tarabalam (Star strength). based on the 9-Tara nakshatra cycle. Determines favorability of Moon nakshatra transit relative to each of the 27 birth nakshatras.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseTarabalam {
    /// Birth nakshatras with favorable Tarabalam based on Moon nakshatra transit. Derived from the 9-Tara system. taras Sampat, Kshema, Sadhaka, Mitra, and Parama Mitra are favorable.
    #[serde(rename = "favorableNakshatras")]
    pub favorable_nakshatras: Vec<String>,
    /// Birth nakshatras with unfavorable Tarabalam (Vipat, Pratyari, Vadha taras). Natives of these birth nakshatras should exercise caution.
    #[serde(rename = "unfavorableNakshatras")]
    pub unfavorable_nakshatras: Vec<String>,
}
/// Sun sign (Surya Rashi) at sunrise. Determines the solar month (Saura Masa) in the Hindu calendar. Changes approximately once a month (Sankranti).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseSunSign {
    /// Sun rashi (sidereal zodiac sign) at sunrise.
    pub name: String,
    /// Sanskrit name of the Sun rashi.
    #[serde(rename = "sanskritName")]
    pub sanskrit_name: String,
}
/// Sun nakshatra at sunrise. The Sun spends approximately 13-14 days in each nakshatra. Used for Surya-based muhurta and festival calculations.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseSunNakshatra {
    /// Ruling planet (lord) of the Sun nakshatra.
    pub lord: String,
    /// Name of the nakshatra the Sun occupies.
    pub name: String,
    /// Sun nakshatra number (1-27).
    pub number: i64,
    /// Pada (quarter) of the Sun nakshatra.
    pub pada: i64,
}
/// Sayahna Sandhya, evening twilight junction period for Sandhyavandanam prayer. Spans sunset to 3 night ghatis after sunset. Duration varies by location and season based on ratrimana (night duration). One of the three daily Sandhya prayer times prescribed in Dharmashastra.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseSayahnaSandhya {
    /// Period end time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub end: String,
    /// Period start time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub start: String,
}
/// Rahu Kaal, inauspicious period ruled by Rahu. Avoid starting new ventures. Calculated from sunrise duration divided into 8 parts.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseRahuKaal {
    /// Period end time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub end: String,
    /// Period start time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub start: String,
}
/// Pratah Sandhya, morning twilight junction period for Sandhyavandanam prayer. Spans 3 night ghatis before sunrise to sunrise. Duration varies by location and season based on ratrimana (night duration). One of the three daily Sandhya prayer times prescribed in Dharmashastra.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponsePratahSandhya {
    /// Period end time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub end: String,
    /// Period start time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub start: String,
}
/// Panchaka, the inauspicious ~5-day window while the Moon transits the last five nakshatras (Dhanishta 3rd pada through Revati, 300 to 360 degrees sidereal). The dosha type depends on the weekday it begins; startsAt and endsAt report the period in force at sunrise or beginning later this day. Avoid major activities during Panchaka.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponsePanchaka {
    /// True when Panchaka is in effect on this date, whether it is already running at sunrise or begins later in the day, in which case startsAt and endsAt give the window. False only when no Panchaka touches this date.
    pub active: bool,
    /// When the Panchaka period ends (Moon exits Revati at 360 degrees), about five days after it starts. Null when no Panchaka. In requested timezone.
    #[serde(rename = "endsAt")]
    pub ends_at: Option<String>,
    /// When the Panchaka period starts (Moon enters 300 degrees, Dhanishta 3rd pada). May predate this date when Panchaka is already running. Null when no Panchaka is in force or begins on this date. In requested timezone.
    #[serde(rename = "startsAt")]
    pub starts_at: Option<String>,
    /// Panchaka dosha, set by the weekday the period BEGINS (not the nakshatra): Roga (Sunday, disease), Raja (Monday, government), Agni (Tuesday, fire), Chora (Friday, theft), Mrityu (Saturday, death). Null when Panchaka begins on Wednesday or Thursday (no dosha) or when no Panchaka touches this date.
    pub r#type: Option<String>,
}
/// Nishita Muhurta (Nishith Kaal), the 8th of 15 night muhurtas from sunset to next sunrise, occurring around midnight. Sacred period for worship of Lord Shiva, especially on Maha Shivaratri. Also significant for Janmashtami midnight celebrations and tantric sadhana.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseNishitaMuhurta {
    /// Period end time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub end: String,
    /// Period start time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub start: String,
}
/// Nakshatra (lunar mansion) information with interpretations
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseNakshatra {
    /// Personality traits and behavioral tendencies when the Moon occupies this nakshatra. Useful for daily panchang readings.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub characteristics: Option<String>,
    /// Presiding deity of this nakshatra from Vedic mythology. Influences spiritual qualities and karmic themes.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deity: Option<String>,
    /// Planetary ruler of this nakshatra. Determines Vimshottari dasha lord and influences nakshatra characteristics.
    pub lord: String,
    /// Sanskrit name of the nakshatra (lunar mansion). One of 27 nakshatras spanning the zodiac belt.
    pub name: String,
    /// Nakshatra index (1-27) in the zodiac sequence starting from Ashwini. Each nakshatra spans 13 degrees 20 minutes.
    pub number: i64,
    /// Pada (quarter, 1-4) of the nakshatra. Each nakshatra has 4 padas spanning 3 degrees 20 minutes each. Determines the navamsha sign and fine-tunes nakshatra predictions.
    pub pada: i64,
    /// Traditional symbol representing this nakshatra. Reflects core energy and life themes.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub symbol: Option<String>,
}
/// Moon sign (Chandra Rashi) at sunrise. Central to Vedic astrology. determines daily emotional tone, Chandrabalam, and Tarabalam.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseMoonSign {
    /// Moon rashi (sidereal zodiac sign) at sunrise.
    pub name: String,
    /// Sanskrit name of the Moon rashi.
    #[serde(rename = "sanskritName")]
    pub sanskrit_name: String,
}
/// Location coordinates used for all time-based calculations.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseLocation {
    /// Observer latitude used for sunrise/sunset calculation.
    pub latitude: f64,
    /// Observer longitude used for sunrise/sunset calculation.
    pub longitude: f64,
    /// Timezone offset from UTC in hours.
    pub timezone: f64,
}
/// Karana (half-tithi) information. Fourth panchang element, changes twice per tithi.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseKarana {
    /// Activity suitability and characteristics of this karana for muhurta selection.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub characteristics: Option<String>,
    /// Sanskrit name of the karana. 7 movable karanas (Bava through Naga) repeat 8 times, plus 4 fixed karanas.
    pub name: String,
    /// Karana index. There are 11 karanas total (4 fixed + 7 movable) cycling through 60 half-tithis per lunar month.
    pub number: i64,
    /// Karana type: Movable (repeating, generally auspicious) or Fixed (occur once per month).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}
/// Current planetary hora. Used for electional astrology and muhurta selection.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseHora {
    /// Planet ruling the current hora (planetary hour). Each hora lasts ~1 hour.
    pub current: String,
    /// End time of the current hora, as local civil time in the requested timezone offset. Day horas and night horas have different lengths, so a hora is only approximately 60 minutes.
    pub end: String,
    /// Hora number within the day sequence (1-24).
    pub number: f64,
    /// Start time of the current hora, as local civil time in the requested timezone offset. The first hora of any day begins at local sunrise, so this equals the sunrise field when the hora number is 1.
    pub start: String,
}
/// Gulika Kaal, inauspicious period ruled by Saturn son Gulika. Considered harmful for initiating work.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseGulika {
    /// Period end time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub end: String,
    /// Period start time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub start: String,
}
/// Godhuli Muhurta (cow dust time), 12 minutes before sunset to 12 minutes after sunset. Universally auspicious for any activity, especially marriages and grihapravesha. No blemish from tithi, vara, nakshatra, karana, or yoga applies during Godhuli. Null only in polar regions where sun does not set.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseGodhuliMuhurta {
    /// Period end time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub end: String,
    /// Period start time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub start: String,
}
/// One entry of `durMuhurta`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseDurMuhurtaItem {
    /// Period end time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub end: String,
    /// Period start time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub start: String,
}
/// Chandrabalam (Moon strength). indicates auspiciousness of Moon transit for each birth rashi. Essential for muhurta selection in Vedic electional astrology.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseChandrabalam {
    /// Rashi for which Moon is in Ashtama (8th house) position. highly inauspicious. Natives of this rashi should avoid important activities.
    #[serde(rename = "ashtamaChandraRashi")]
    pub ashtama_chandra_rashi: String,
    /// Rashis (zodiac signs) for which Moon transit is favorable today. Chandrabalam is positive when Moon transits 1st, 3rd, 6th, 7th, 10th, or 11th house from birth rashi.
    #[serde(rename = "favorableRashis")]
    pub favorable_rashis: Vec<String>,
}
/// Brahma Muhurta, sacred pre-dawn period approximately 96 minutes before sunrise (14th of 15 night muhurtas). Considered the best time for meditation, mantra japa, Vedic study, and spiritual sadhana. Referenced in Ashtanga Hridaya and Dharmashastra texts.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseBrahmaMuhurta {
    /// Period end time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub end: String,
    /// Period start time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub start: String,
}
/// Bhadra (Vishti Karana), the 7th movable karana, avoided for all auspicious activities. Bhadra recurs roughly every 3 to 5 days and lasts about half a tithi. active is true whenever a Bhadra is attributed to this date; startsAt and endsAt give the window, which may end on the next calendar day.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseBhadra {
    /// True when a Bhadra (Vishti Karana) occurs on this date, in which case startsAt and endsAt give its window. False only when no Bhadra begins on this date.
    pub active: bool,
    /// When the Bhadra (Vishti) period that begins on this date ends. May fall on the next calendar day. Null when no Bhadra begins on this date. In requested timezone.
    #[serde(rename = "endsAt")]
    pub ends_at: Option<String>,
    /// When the Bhadra (Vishti) period that begins on this date starts. Null when no Bhadra begins on this date. In requested timezone.
    #[serde(rename = "startsAt")]
    pub starts_at: Option<String>,
}
/// One entry of `amritKalam`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseAmritKalamItem {
    /// Period end time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub end: String,
    /// Period start time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub start: String,
}
/// Abhijit Muhurta (Abhijit Muhurat), the most auspicious ~48-minute window around solar noon, the 8th of 15 day muhurtas. Ideal for starting new ventures, signing contracts, and performing rituals when no other shubh muhurat is available. Null on Wednesdays because Abhijit coincides with Dur Muhurta on that weekday per Muhurta Chintamani.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangResponseAbhijitMuhurta {
    /// Period end time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub end: String,
    /// Period start time in ISO 8601 format. Timezone-adjusted based on the input timezone offset.
    pub start: String,
}
/// Request body of `getDetailedPanchang`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDetailedPanchangRequest {
    /// Date in YYYY-MM-DD format. A single-digit month or day is accepted and zero-padded (2026-3-5 becomes 2026-03-05). Impossible calendar dates are rejected. Calculations that read planetary positions support 1550-01-02 to 2650-01-22; outside that span they answer 400 with code date_out_of_range, and a calculation that reads a window around the date (a sunrise search, a run of days) may answer the same 400 for a date within a few days of either end.
    pub date: String,
    /// Observer latitude in decimal degrees. Determines sunrise and sunset times which define day/night boundaries for muhurta calculations.
    pub latitude: f64,
    /// Observer longitude in decimal degrees. Affects local time calculations for sunrise, sunset, and muhurta period boundaries.
    pub longitude: f64,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Send the timezone that matches the coordinates: sunrise, sunset and every muhurta boundary are found by searching forward from local midnight, so the default anchors the search to an Indian day. Omitting it for a location outside IST returns a correctly ordered set of periods for the wrong window, shifted by the difference between 5.5 and the real offset. Defaults to 5.5 (IST).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetDetailedPanchangRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Send the timezone that matches the coordinates: sunrise, sunset and every muhurta boundary are found by searching forward from local midnight, so the default anchors the search to an Indian day. Omitting it for a location outside IST returns a correctly ordered set of periods for the wrong window, shifted by the difference between 5.5 and the real offset. Defaults to 5.5 (IST).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetDetailedPanchangRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
/// Path and query parameters of `getDetailedPanchang`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetDetailedPanchangParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetDetailedPanchangParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetDetailedPanchangParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getDailyZodiacReading`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyZodiacReadingResponse {
    /// The one thing worth doing differently today, drawn from the relation and from this sign own habitual weak point.
    pub advice: String,
    /// The sign this reading was requested for.
    pub animal: GetDailyZodiacReadingResponseAnimal,
    /// True when the year animal is the same as the requested sign, the return of your own branch that comes round every twelve years. The tradition treats a Ben Ming Nian as a year to be deliberate in rather than one to fear, because the sign own qualities run at full strength and that cuts both ways.
    #[serde(rename = "benMingNian")]
    pub ben_ming_nian: bool,
    /// Work guidance for the day. Clash and harm days carry the traditional cautions about signings and launches.
    pub career: String,
    /// Date of this reading in YYYY-MM-DD format. Echoes the date requested, or the current day in the timezone parameter when it was omitted.
    pub date: String,
    /// The sexagenary pillar of this calendar day, evaluated at the reference meridian for the Chinese calendar.
    #[serde(rename = "dayPillar")]
    pub day_pillar: GetDailyZodiacReadingResponseDayPillar,
    /// Overall energy for this sign on this day, 1 to 10. Derived from the branch relation plus how the day phase treats the sign phase on the generating and controlling cycles, so a favourable relation in a draining phase lands lower than a favourable relation in a supporting one. Built for content widgets and visual indicators.
    #[serde(rename = "energyRating")]
    pub energy_rating: f64,
    /// Relationship guidance for the day, specific to the branch relation.
    pub love: String,
    /// What the day does to this sign, from the branch relation and the phase of the day stem.
    pub overview: String,
    /// How the day branch stands to the sign branch. One of secret-friend, trine, same, neutral, harm or clash. Exactly one applies, because no two of the conditions can hold at once. Always English so it stays safe to switch on, and the same vocabulary /zodiac/compatibility returns.
    pub relationship: String,
    /// The sexagenary year this date falls in, resolved on the LUNAR NEW YEAR rule to match the folk zodiac this route family answers. The Four Pillars routes use the classical Li Chun rule and can name a different year for dates in early February.
    pub year: GetDailyZodiacReadingResponseYear,
}
/// The sexagenary year this date falls in, resolved on the LUNAR NEW YEAR rule to match the folk zodiac this route family answers. The Four Pillars routes use the classical Li Chun rule and can name a different year for dates in early February.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyZodiacReadingResponseYear {
    /// Animal of the year in force. Always English so it stays safe to compare against.
    pub animal: String,
    /// Animal name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "animalLocalized", skip_serializing_if = "Option::is_none")]
    pub animal_localized: Option<String>,
    /// One line on the year relationship, or on the Ben Ming Nian year when the year animal matches the sign.
    pub note: String,
    /// Sexagenary year pillar in force on this date, resolved on the lunar new year rule.
    pub pillar: String,
    /// How the year branch stands to the requested sign, from the same six-value vocabulary as the daily relationship. This is the slower background the day sits inside.
    pub relationship: String,
}
/// The sexagenary pillar of this calendar day, evaluated at the reference meridian for the Chinese calendar.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyZodiacReadingResponseDayPillar {
    /// The animal the day branch carries, which the tradition calls the day animal. This is what the requested sign is being read against.
    pub animal: String,
    /// Earthly Branch of the day, as its pinyin identifier.
    pub branch: String,
    /// Five Element phase of the day Heavenly Stem. Together with the sign own phase this sets the energy rating, through the classical generating and controlling cycles.
    pub element: String,
    /// Sexagenary day pillar id, Heavenly Stem then Earthly Branch. Always English pinyin.
    pub id: String,
    /// Position of this pillar in the sixty-day sexagenary cycle, 1 to 60, where jia-zi is 1. The day cycle runs unbroken and is independent of the lunar and solar calendars.
    pub number: f64,
    /// Heavenly Stem of the day, as its pinyin identifier.
    pub stem: String,
}
/// The sign this reading was requested for.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyZodiacReadingResponseAnimal {
    /// Earthly Branch this animal names, as its pinyin identifier.
    pub branch: String,
    /// Traditional hanzi character for the animal. Identical under every lang.
    pub chinese: String,
    /// Fixed Five Element phase of the sign own branch. Always English so it stays safe to compare against.
    pub element: String,
    /// Five Element phase name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Machine identifier of the sign this reading is for. Always English and lowercase, so it stays safe to compare against in code.
    pub id: String,
    /// Display name of the sign in English. Always English; use nameLocalized for anything a reader sees.
    pub name: String,
    /// Animal name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone-marked pinyin for the animal name.
    pub pinyin: String,
    /// Yin or yang polarity of the branch.
    pub polarity: String,
}
/// Path and query parameters of `getDailyZodiacReading`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyZodiacReadingParams {
    /// Reading date in YYYY-MM-DD format. Past and future dates are both supported, for editorial scheduling and backfill. Defaults to the current day in the timezone parameter.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Animal id, case-insensitive. One of rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, pig.
    pub id: GetDailyZodiacReadingParamsId,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetDailyZodiacReadingParamsLang>,
    /// Selects which day counts as current when date is omitted. Defaults to UTC, so the reading rolls over at 00:00 UTC each day. Pass the timezone of the end user to roll over on their local clock instead. Ignored when date is set. Accepts an IANA name (e.g. "America/New_York"), decimal hours (e.g. 5.5 for IST), or a fixed UTC offset (e.g. "-05:00").
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetDailyZodiacReadingParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Animal id, case-insensitive. One of rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, pig.
    GetDailyZodiacReadingParamsId {
        Rat = "rat",
        Ox = "ox",
        Tiger = "tiger",
        Rabbit = "rabbit",
        Dragon = "dragon",
        Snake = "snake",
        Horse = "horse",
        Goat = "goat",
        Monkey = "monkey",
        Rooster = "rooster",
        Dog = "dog",
        Pig = "pig",
    }
}
/// Response body of `getDailySephirah`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailySephirahResponse {
    /// The date this answer is for. Echoes the request or the resolved date.
    pub date: String,
    /// Day of the count, 1 to 49. Absent when the count is not running.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub day: Option<f64>,
    /// Which day inside that week, 1 to 7. Absent outside the count.
    #[serde(rename = "dayInWeek", skip_serializing_if = "Option::is_none")]
    pub day_in_week: Option<f64>,
    /// The sephirah of the DAY inside the week, which is the inner half of the label and is named first. Absent outside the count.
    #[serde(rename = "daySephirah", skip_serializing_if = "Option::is_none")]
    pub day_sephirah: Option<GetDailySephirahResponseDaySephirah>,
    /// The Hebrew month and day of this Omer day. Day 1 is 16 Nisan, the second day of Passover, on the reckoning this API uses. Absent outside the count.
    #[serde(rename = "hebrewDate", skip_serializing_if = "Option::is_none")]
    pub hebrew_date: Option<String>,
    /// The label as the printed text carries it, inner then outer. Absent outside the count.
    #[serde(rename = "hebrewLabel", skip_serializing_if = "Option::is_none")]
    pub hebrew_label: Option<String>,
    /// Whether the count is running on this date. False outside the forty nine days, and the fields below the count are then absent.
    #[serde(rename = "inOmer")]
    pub in_omer: bool,
    /// The date the count next opens. Present only when the count is not running, so a caller can branch on presence.
    #[serde(rename = "nextStart", skip_serializing_if = "Option::is_none")]
    pub next_start: Option<String>,
    /// The composed reading for the day, in the requested language.
    pub reading: String,
    /// Which of the seven weeks the day falls in. Absent outside the count.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub week: Option<f64>,
    /// The sephirah of the WEEK, which is the outer half of the label. Absent outside the count.
    #[serde(rename = "weekSephirah", skip_serializing_if = "Option::is_none")]
    pub week_sephirah: Option<GetDailySephirahResponseWeekSephirah>,
}
/// The sephirah of the WEEK, which is the outer half of the label. Absent outside the count.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailySephirahResponseWeekSephirah {
    /// The English gloss of the name, in the requested language.
    pub english: String,
    /// The name in Hebrew, unpointed. Data, identical in every language.
    pub hebrew: String,
    /// Machine identifier of the sephirah, always English so it stays safe to compare against in code.
    pub id: String,
    /// Latin transcription of the Hebrew, from the one mechanical letter map.
    pub romanization: String,
}
/// The sephirah of the DAY inside the week, which is the inner half of the label and is named first. Absent outside the count.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailySephirahResponseDaySephirah {
    /// The English gloss of the name, in the requested language.
    pub english: String,
    /// The name in Hebrew, unpointed. Data, identical in every language.
    pub hebrew: String,
    /// Machine identifier of the sephirah, always English so it stays safe to compare against in code.
    pub id: String,
    /// Latin transcription of the Hebrew, from the one mechanical letter map.
    pub romanization: String,
}
/// Path and query parameters of `getDailySephirah`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetDailySephirahParams {
    /// Set true when the moment falls after nightfall, which advances the Hebrew date by one day because the Hebrew day begins in the evening. It is a caller assertion rather than a computation, since sunset depends on a place and this route takes none.
    #[serde(rename = "afterSunset", skip_serializing_if = "Option::is_none")]
    pub after_sunset: Option<String>,
    /// Date in YYYY-MM-DD. Defaults to the current UTC date when omitted, so a caller that wants a fixed answer should send one.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetDailySephirahParamsLang>,
    /// IANA name or decimal offset, used only to decide which calendar date it is where the caller is when date is omitted. It does not move the count, which is a calendar count rather than a clock one.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetDailySephirahParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getDailyNumber`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyNumberResponse {
    /// Concise daily guidance message combining the number archetype with practical advice for the day.
    #[serde(rename = "dailyMessage")]
    pub daily_message: String,
    /// Date this daily number is for (YYYY-MM-DD, UTC).
    pub date: String,
    /// The `meaning` field.
    pub meaning: GetDailyNumberResponseMeaning,
    /// Daily numerology number (1-9, 11, 22, 33). Represents the dominant energy and theme for this day.
    pub number: f64,
    /// Computed seed used for this reading. Same seed always produces the same number.
    pub seed: String,
    /// Whether this is a single-digit number (1-9) or a Master Number (11, 22, 33). Master Number days carry amplified spiritual significance.
    pub r#type: GetDailyNumberResponseType,
}
string_enum! {
    /// Whether this is a single-digit number (1-9) or a Master Number (11, 22, 33). Master Number days carry amplified spiritual significance.
    GetDailyNumberResponseType {
        Single = "single",
        Master = "master",
    }
}
/// The `meaning` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyNumberResponseMeaning {
    /// Professional guidance tuned to the daily energy. Suggests optimal work strategies, meeting approaches, and productivity focus areas.
    pub career: String,
    /// Shadow patterns to watch for today. Awareness of these helps navigate the day with intention and balance.
    pub challenges: Vec<String>,
    /// Core interpretation of the number of the day: its personality resonance, life themes and how it colors the day. Together with the strengths, challenges, career, relationships and spirituality fields it makes a full reading.
    pub description: String,
    /// Defining traits and energetic themes active today. Useful for daily affirmations, journaling prompts, and focus areas.
    pub keywords: Vec<String>,
    /// Relationship dynamics influenced by the daily number. Covers communication style, social energy, and partnership awareness for the day.
    pub relationships: String,
    /// Spiritual theme of the day. Suggests meditation focus, contemplative practices, and the deeper lesson available today.
    pub spirituality: String,
    /// Qualities that are amplified and accessible today. Lean into these for maximum alignment with the daily energy.
    pub strengths: Vec<String>,
    /// Numerology archetype for this number. Captures the core energy of the day in a single phrase.
    pub title: String,
}
/// Path and query parameters of `getDailyNumber`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetDailyNumberParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetDailyNumberParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetDailyNumberParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getDailyMayanReading`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyMayanReadingResponse {
    /// The conventions this reading was computed under, echoed so the result is self describing.
    pub conventions: GetDailyMayanReadingResponseConventions,
    /// Date of this reading. Echoes the date requested, or the current day in UTC when it was omitted.
    pub date: String,
    /// Machine identifier of the Tzolkin day sign, always lowercase ASCII Yucatec whatever the lang parameter says, so it stays safe to compare against in code. The twenty ids run imix, ik, akbal, kan, chikchan, kimi, manik, lamat, muluk, ok, chuwen, eb, ben, ix, men, kib, kaban, etznab, kawak, ajaw.
    #[serde(rename = "daySign")]
    pub day_sign: String,
    /// The sixteenth century Yucatec spelling of the same sign, which is the form most printed reference tables and older sources use. Useful for matching a name a reader copied out of a book.
    #[serde(rename = "daySignClassic")]
    pub day_sign_classic: String,
    /// The Kʼicheʼ name of the same day from the living highland daykeeping tradition, which is the vocabulary a nawal reading in Guatemala uses. A parallel naming tradition rather than a translation, so it is identical under every lang.
    #[serde(rename = "daySignKiche")]
    pub day_sign_kiche: String,
    /// Display name of the day sign in the standard Maya orthography, where the ejective is written with a modifier letter rather than a typewriter quote. A proper noun carried as data, so it is identical under every lang.
    #[serde(rename = "daySignName")]
    pub day_sign_name: String,
    /// The Tzolkin coefficient, 1 to 13. This is the classical day number that runs alongside the twenty signs; it is not a rank and a 13 is not better than a 1. Nine of the thirteen carry a recorded character, which is returned separately.
    pub number: f64,
    /// What the day carries, placing it inside its trecena as well as naming it. Composed per request, so it stays consistent with the reading below rather than being a second opinion.
    pub overview: String,
    /// The composed nawal reading for the day sign in force.
    pub reading: GetDailyMayanReadingResponseReading,
    /// The thirteen day period this day belongs to. The trecena is the unit a daykeeper reads a run of days in, and the sign it opens on is what gives the whole period its character.
    pub trecena: GetDailyMayanReadingResponseTrecena,
}
/// The thirteen day period this day belongs to. The trecena is the unit a daykeeper reads a run of days in, and the sign it opens on is what gives the whole period its character.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyMayanReadingResponseTrecena {
    /// Position of this day inside its trecena, 1 to 13. Always equal to the coefficient, because a trecena is exactly one run of the coefficient.
    #[serde(rename = "dayOfTrecena")]
    pub day_of_trecena: f64,
    /// Which of the twenty thirteen day periods this day falls in, 1 to 20. Trecena 1 opens on 1 Imix.
    pub number: f64,
    /// Machine identifier of the day sign the trecena opens on, which the tradition reads as colouring all thirteen of its days.
    #[serde(rename = "rulingSign")]
    pub ruling_sign: String,
    /// Display name of the sign the trecena opens on. A proper noun carried as data.
    #[serde(rename = "rulingSignName")]
    pub ruling_sign_name: String,
}
/// The composed nawal reading for the day sign in force.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyMayanReadingResponseReading {
    /// Where the same temperament costs the sign something. Each one is the shadow of a strength above rather than an unrelated flaw.
    pub challenges: Vec<String>,
    /// The one thing worth doing differently under this sign.
    pub guidance: String,
    /// The sign in one composed sentence: its name in both naming traditions, what it is about, and the glyph reading behind it. Composed per request from the sign components rather than stored whole, which is why it stays consistent with every other reading in the response.
    pub keynote: String,
    /// Machine identifier of the recorded character of the coefficient: gentle, indifferent or violent. ABSENT for coefficients 4, 5, 6 and 10, which have no recorded character in any consulted source. Always English so it stays safe to switch on.
    #[serde(rename = "numberBand", skip_serializing_if = "Option::is_none")]
    pub number_band: Option<String>,
    /// What the coefficient contributes. Nine of the thirteen carry a recorded character, banded as gentle, indifferent or violent; the other four carry none and this field says so rather than inventing one. The band ids are the source vocabulary, so violent names the days reserved for strong ceremony and defence and is not a warning.
    #[serde(rename = "numberReading")]
    pub number_reading: String,
    /// What the sign does well, as full sentences rather than keywords.
    pub strengths: Vec<String>,
}
/// The conventions this reading was computed under, echoed so the result is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyMayanReadingResponseConventions {
    /// The correlation constant actually applied, whether it was requested or defaulted. Store this beside any Maya date you persist: the same civil date resolves to a different Long Count under each constant, and a date with no correlation recorded cannot be reproduced.
    pub correlation: String,
}
/// Path and query parameters of `getDailyMayanReading`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetDailyMayanReadingParams {
    /// Which correlation constant ties the day count to a civil date. This is the single choice that shifts every value in the response, so it is a parameter rather than a hidden default, and the resolved value comes back under conventions. "gmt-584283" is the commonly accepted constant and the default, and it is the one the major institutional converter runs on. "martinez-hernandez-584281" sits two days earlier, "astronomical-584285" two days later, and "martin-skidmore-584286" three days later, each shifting the Long Count by exactly its difference in days. Four of the eight published constants are offered: the other four sit tens of thousands of days away and are of historical interest only. The 584281 constant is the Martínez Hernández correlation, after Juan Martínez Hernández.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub correlation: Option<GetDailyMayanReadingParamsCorrelation>,
    /// Date in YYYY-MM-DD format, in the PROLEPTIC GREGORIAN calendar, extended backwards unchanged through the 1582 reform. Years 1 to 4000 are accepted. A reference converter that switches to the Julian calendar below the reform will disagree with a date before 15 October 1582 by ten or eleven days; that is a difference of input convention rather than of arithmetic, and passing the Julian equivalent to such a tool reproduces these values exactly. A single-digit month or day is accepted and zero padded. Defaults to the current day in UTC.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetDailyMayanReadingParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetDailyMayanReadingParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Which correlation constant ties the day count to a civil date. This is the single choice that shifts every value in the response, so it is a parameter rather than a hidden default, and the resolved value comes back under conventions. "gmt-584283" is the commonly accepted constant and the default, and it is the one the major institutional converter runs on. "martinez-hernandez-584281" sits two days earlier, "astronomical-584285" two days later, and "martin-skidmore-584286" three days later, each shifting the Long Count by exactly its difference in days. Four of the eight published constants are offered: the other four sit tens of thousands of days away and are of historical interest only. The 584281 constant is the Martínez Hernández correlation, after Juan Martínez Hernández.
    GetDailyMayanReadingParamsCorrelation {
        Gmt584283 = "gmt-584283",
        MartinezHernandez584281 = "martinez-hernandez-584281",
        Astronomical584285 = "astronomical-584285",
        MartinSkidmore584286 = "martin-skidmore-584286",
    }
}
/// Response body of `getDailyHoroscope`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyHoroscopeResponse {
    /// Active planetary transits affecting this sign today, with house activations. Each transit shows the planet, its current sign, and which house it activates for the queried sign. The sign and the house phrase translate with the lang parameter; the planet name stays canonical English so a caller can match on it whatever the language.
    #[serde(rename = "activeTransits")]
    pub active_transits: Vec<String>,
    /// The single actionable takeaway from the leading event of the period, read into the whole-sign houses of this sign and checkable against the events array. Drawn from the same event as overview, kept to a short, actionable pair of sentences rather than grown to match the other sections. Deterministic: the same sign and period always returns the same text.
    pub advice: String,
    /// Career and professional outlook, read into the whole-sign houses of this sign. The same ranked events that drive column, filtered to career, work and reputation, plus the standing placements that reach it. Every event named here is in the events array, so a piece can be fact-checked before it runs; this section reads an event through whichever of its houses carries career, work and reputation, which for an aspect between two houses can be the other one from the house the events array leads with, and both are whole-sign houses of the bodies involved counted from this sign. Typically 50 to 90 words. Render it alone for a single-topic page, or alongside the other five sections for a general reading; column is the same material woven into one piece instead of split by topic. Deterministic: the same sign and period always returns the same text.
    pub career: String,
    /// The full column for this period, ready to run as one piece, with paragraphs separated by a blank line. Names the events driving it and the dates they fall on, read into the whole-sign houses of this sign. Typically 120 to 180 words. The six section fields read the same ranked events filtered to their own life area, each composed as a column of its own rather than an excerpt of this one, so render either shape and never both. Deterministic: the same sign and period always returns the same column.
    pub column: String,
    /// Most compatible zodiac signs for this sign. Trine partners (same element) followed by a sextile partner (complementary element). Use for compatibility widgets, dating app onboarding, and horoscope cards.
    #[serde(rename = "compatibleSigns")]
    pub compatible_signs: Vec<String>,
    /// Date of this daily horoscope (YYYY-MM-DD).
    pub date: String,
    /// Overall energy for this sign today (1-10). Derived from how many aspects are in force between the planets, how tight they are, whether they are harmonious or challenging, and which houses they fall in for this sign, so a busy day rates higher than a quiet one and a harmonious day higher than a hostile one of the same weight. Useful for content widgets and visual indicators.
    #[serde(rename = "energyRating")]
    pub energy_rating: f64,
    /// The dated astronomical events this reading is built on, earliest first. Every field in every row can be checked against an independent authority, so a column can be fact-checked before it is published. Empty on a period in which nothing exact happens, where the reading falls back to the standing positions instead.
    pub events: Vec<GetDailyHoroscopeResponseEventsItem>,
    /// Financial outlook and money-related guidance, read into the whole-sign houses of this sign. The same ranked events that drive column, filtered to finance, plus the standing placements that reach it. Every event named here is in the events array, so a piece can be fact-checked before it runs; this section reads an event through whichever of its houses carries finance, which for an aspect between two houses can be the other one from the house the events array leads with, and both are whole-sign houses of the bodies involved counted from this sign. Typically 50 to 90 words. Render it alone for a single-topic page, or alongside the other five sections for a general reading; column is the same material woven into one piece instead of split by topic. Deterministic: the same sign and period always returns the same text.
    pub finance: String,
    /// Health, energy, and wellness guidance, read into the whole-sign houses of this sign. The same ranked events that drive column, filtered to health, plus the standing placements that reach it. Every event named here is in the events array, so a piece can be fact-checked before it runs; this section reads an event through whichever of its houses carries health, which for an aspect between two houses can be the other one from the house the events array leads with, and both are whole-sign houses of the bodies involved counted from this sign. Typically 50 to 90 words. Render it alone for a single-topic page, or alongside the other five sections for a general reading; column is the same material woven into one piece instead of split by topic. Deterministic: the same sign and period always returns the same text.
    pub health: String,
    /// Love and relationship forecast, read into the whole-sign houses of this sign. The same ranked events that drive column, filtered to romance and partnership, plus the standing placements that reach it. Every event named here is in the events array, so a piece can be fact-checked before it runs; this section reads an event through whichever of its houses carries romance and partnership, which for an aspect between two houses can be the other one from the house the events array leads with, and both are whole-sign houses of the bodies involved counted from this sign. Typically 50 to 90 words. Render it alone for a single-topic page, or alongside the other five sections for a general reading; column is the same material woven into one piece instead of split by topic. Deterministic: the same sign and period always returns the same text.
    pub love: String,
    /// Lucky color for the day, drawn from the three colors of the sign element and selected by the planet governing the reading.
    #[serde(rename = "luckyColor")]
    pub lucky_color: String,
    /// Lucky number for the day, 1 to 9, from the traditional planetary number correspondence applied to the planet that governs this sign today. Not a random draw and not a function of the date.
    #[serde(rename = "luckyNumber")]
    pub lucky_number: f64,
    /// Display name of the current lunar phase, one of the eight standard phases from New Moon through Waning Crescent. Translates in place with the lang parameter, like the moonSign beside it, so render it directly.
    #[serde(rename = "moonPhase")]
    pub moon_phase: String,
    /// Current Moon sign. Changes every 2-3 days, sets the emotional tone for all signs.
    #[serde(rename = "moonSign")]
    pub moon_sign: String,
    /// The single most relevant event of the period, whichever life area it touches, read into the whole-sign houses of this sign. The same event that leads column, at lede length rather than developed into a full movement, and checkable against the events array. Typically 30 to 60 words. Join it with love, career, health and finance for a general reading built from the six sections. Deterministic: the same sign and period always returns the same text.
    pub overview: String,
    /// Zodiac sign for this horoscope.
    pub sign: String,
}
/// One entry of `events`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyHoroscopeResponseEventsItem {
    /// Angle formed, on aspect events only: conjunction, sextile, square, trine, opposition, semi-sextile, quincunx, semi-square, or sesquiquadrate.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub aspect: Option<String>,
    /// Exact instant the event perfects, UTC, to the second. Verifiable against NASA JPL Horizons for a position event and against the US Naval Observatory for a lunar phase or eclipse.
    pub at: String,
    /// Bodies involved, canonical English regardless of the requested language so the value stays safe to switch on. Two entries for an aspect, faster body first. One entry for an ingress, a station, a lunar phase, or an eclipse.
    pub bodies: Vec<String>,
    /// Whole-sign house the event falls in, counted from the queried sign, 1 to 12. This is what turns one global sky event into a statement about this reader.
    pub house: i64,
    /// Sign the event falls in, lowercase, where it has exactly one. Absent for an aspect whose two bodies stand in different signs.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sign: Option<String>,
    /// End of the window this event holds open, UTC, given only where a bounded window is a real fact about it: the orb span of an aspect, the sign span of an ingress or a season, the retrograde span of a station. Absent for a lunar phase or an eclipse, which are instants and not spans.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub through: Option<String>,
    /// Kind of event. aspect is an exact angle between two moving bodies, sign-ingress a body entering a new sign, retrograde-station a body turning retrograde or direct, lunar-phase one of the four quarters, eclipse a solar or lunar eclipse, and solar-season the Sun entering a sign.
    pub r#type: GetDailyHoroscopeResponseEventsItemType,
}
string_enum! {
    /// Kind of event. aspect is an exact angle between two moving bodies, sign-ingress a body entering a new sign, retrograde-station a body turning retrograde or direct, lunar-phase one of the four quarters, eclipse a solar or lunar eclipse, and solar-season the Sun entering a sign.
    GetDailyHoroscopeResponseEventsItemType {
        Aspect = "aspect",
        SignIngress = "sign-ingress",
        RetrogradeStation = "retrograde-station",
        LunarPhase = "lunar-phase",
        Eclipse = "eclipse",
        SolarSeason = "solar-season",
    }
}
/// Path and query parameters of `getDailyHoroscope`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyHoroscopeParams {
    /// Forecast date in YYYY-MM-DD format. Past and future dates are both supported, for editorial scheduling and backfill. Defaults to the current period in the timezone parameter.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetDailyHoroscopeParamsLang>,
    /// Zodiac sign, case-insensitive (e.g., aries, Aries, ARIES all work).
    pub sign: GetDailyHoroscopeParamsSign,
    /// Selects which period counts as current when date is omitted. Defaults to UTC, so the forecast rolls over at 00:00 UTC on each day. Pass the timezone of the end user to roll over on their local clock instead. Ignored when date is set. Accepts an IANA name (e.g. "America/New_York"), decimal hours (e.g. 5.5 for IST), or a fixed UTC offset (e.g. "-05:00").
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
}
string_enum! {
    /// Zodiac sign, case-insensitive (e.g., aries, Aries, ARIES all work).
    GetDailyHoroscopeParamsSign {
        Aries = "aries",
        Taurus = "taurus",
        Gemini = "gemini",
        Cancer = "cancer",
        Leo = "leo",
        Virgo = "virgo",
        Libra = "libra",
        Scorpio = "scorpio",
        Sagittarius = "sagittarius",
        Capricorn = "capricorn",
        Aquarius = "aquarius",
        Pisces = "pisces",
    }
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetDailyHoroscopeParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getDailyHexagram`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyHexagramResponse {
    /// Concise daily message summarizing the hexagram guidance
    #[serde(rename = "dailyMessage")]
    pub daily_message: String,
    /// Date this daily hexagram is for (YYYY-MM-DD, UTC).
    pub date: String,
    /// The `hexagram` field.
    pub hexagram: GetDailyHexagramResponseHexagram,
    /// Computed seed used for this reading. Same seed always produces the same hexagram.
    pub seed: String,
}
/// The `hexagram` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyHexagramResponseHexagram {
    /// Original Chinese name.
    pub chinese: String,
    /// English translation of the hexagram name.
    pub english: String,
    /// The Image (Xiang) text, symbolic guidance derived from the trigram combination describing the ideal action.
    pub image: String,
    /// Modern interpretations across life areas based on ancient I-Ching wisdom.
    pub interpretation: GetDailyHexagramResponseHexagramInterpretation,
    /// The Judgment (Tuan) text, the primary oracle statement of the hexagram offering core guidance.
    pub judgment: String,
    /// Lower trigram (lines 1-3).
    #[serde(rename = "lowerTrigram")]
    pub lower_trigram: String,
    /// Hexagram number in King Wen sequence (1-64).
    pub number: f64,
    /// Pinyin romanization with tone marks.
    pub pinyin: String,
    /// Unicode hexagram symbol for display.
    pub symbol: String,
    /// Upper trigram (lines 4-6).
    #[serde(rename = "upperTrigram")]
    pub upper_trigram: String,
}
/// Modern interpretations across life areas based on ancient I-Ching wisdom.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyHexagramResponseHexagramInterpretation {
    /// Practical wisdom and actionable advice.
    pub advice: String,
    /// Career and professional interpretation.
    pub career: String,
    /// Decision-making guidance for whether to act, wait, or change course.
    pub decision: String,
    /// General life situation interpretation.
    pub general: String,
    /// Love and relationship guidance.
    pub love: String,
}
/// Path and query parameters of `getDailyHexagram`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetDailyHexagramParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetDailyHexagramParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetDailyHexagramParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getDailyDreamSymbol`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyDreamSymbolResponse {
    /// Concise daily message summarizing the dream symbol and its key themes for quick reflection.
    #[serde(rename = "dailyMessage")]
    pub daily_message: String,
    /// Date of the daily dream symbol in YYYY-MM-DD format (UTC). Determines which symbol is selected for seeded readings.
    pub date: String,
    /// Seed used for this daily reading. Same seed on the same date always produces the identical symbol.
    pub seed: String,
    /// The `symbol` field.
    pub symbol: GetDailyDreamSymbolResponseSymbol,
}
/// The `symbol` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyDreamSymbolResponseSymbol {
    /// Unique symbol identifier in kebab-case. Use this to fetch full details via /symbols/{id}.
    pub id: String,
    /// Starting letter (a-z) for alphabetical navigation.
    pub letter: String,
    /// Full psychological dream interpretation explaining the subconscious symbolism, emotional significance, and waking-life connections.
    pub meaning: String,
    /// Display name of the dream symbol.
    pub name: String,
}
/// Path and query parameters of `getDailyCrystal`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetDailyCrystalParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetDailyCrystalParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetDailyCrystalParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getDailyCard`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyCardResponse {
    /// The `card` field.
    pub card: DrawnCard,
    /// Concise daily tarot message summarizing the card, its orientation, key themes, and brief guidance for the day.
    #[serde(rename = "dailyMessage")]
    pub daily_message: String,
    /// Date of the daily tarot reading in YYYY-MM-DD format (UTC). Determines which card is drawn for seeded readings.
    pub date: String,
    /// Seed used for this daily reading. Same seed on the same date always produces the identical card for reproducible daily divination.
    pub seed: String,
}
/// Path and query parameters of `getDailyCard`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetDailyCardParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetDailyCardParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetDailyCardParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getDailyBiorhythm`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyBiorhythmResponse {
    /// Actionable 1-2 sentence guidance for the day.
    pub advice: String,
    /// Concise daily biorhythm message combining energy rating and spotlight cycle.
    #[serde(rename = "dailyMessage")]
    pub daily_message: String,
    /// Date this daily reading is for (YYYY-MM-DD, UTC).
    pub date: String,
    /// Overall energy score from 1 to 10.
    #[serde(rename = "energyRating")]
    pub energy_rating: f64,
    /// Summary phase across every cycle for the day. One of: high_energy, mixed, recovery, critical.
    #[serde(rename = "overallPhase")]
    pub overall_phase: GetDailyBiorhythmResponseOverallPhase,
    /// The `quickRead` field.
    #[serde(rename = "quickRead")]
    pub quick_read: GetDailyBiorhythmResponseQuickRead,
    /// Computed seed used for this reading. Same seed always produces the same reading.
    pub seed: String,
    /// The `spotlight` field.
    pub spotlight: GetDailyBiorhythmResponseSpotlight,
}
/// The `spotlight` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyBiorhythmResponseSpotlight {
    /// Which primary cycle is featured as the daily spotlight. One of: physical, emotional, intellectual.
    pub cycle: GetDailyBiorhythmResponseSpotlightCycle,
    /// Personalized message about the spotlight cycle and what it means for today.
    pub message: String,
    /// Current phase of the spotlight cycle.
    pub phase: GetDailyBiorhythmResponseSpotlightPhase,
    /// Current value of the spotlight cycle (-100 to 100).
    pub value: f64,
}
string_enum! {
    /// Current phase of the spotlight cycle.
    GetDailyBiorhythmResponseSpotlightPhase {
        Peak = "peak",
        High = "high",
        Rising = "rising",
        CriticalAscending = "critical_ascending",
        CriticalDescending = "critical_descending",
        Falling = "falling",
        Low = "low",
        Trough = "trough",
    }
}
string_enum! {
    /// Which primary cycle is featured as the daily spotlight. One of: physical, emotional, intellectual.
    GetDailyBiorhythmResponseSpotlightCycle {
        Physical = "physical",
        Emotional = "emotional",
        Intellectual = "intellectual",
    }
}
/// The `quickRead` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyBiorhythmResponseQuickRead {
    /// Emotional cycle value (-100 to 100).
    pub emotional: f64,
    /// Intellectual cycle value (-100 to 100).
    pub intellectual: f64,
    /// Physical cycle value (-100 to 100).
    pub physical: f64,
}
string_enum! {
    /// Summary phase across every cycle for the day. One of: high_energy, mixed, recovery, critical.
    GetDailyBiorhythmResponseOverallPhase {
        HighEnergy = "high_energy",
        Mixed = "mixed",
        Recovery = "recovery",
        Critical = "critical",
    }
}
/// Path and query parameters of `getDailyBiorhythm`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetDailyBiorhythmParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetDailyBiorhythmParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetDailyBiorhythmParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getDailyAztecReading`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyAztecReadingResponse {
    /// The conventions this reading was computed under, echoed so the result is self describing.
    pub conventions: GetDailyAztecReadingResponseConventions,
    /// Date of this reading. Echoes the date requested, or the current day in UTC when it was omitted.
    pub date: String,
    /// Machine identifier of the tonalpohualli day sign, always lowercase ASCII Nahuatl whatever the lang parameter says, so it stays safe to compare against in code. The twenty ids run cipactli, ehecatl, calli, cuetzpalin, coatl, miquiztli, mazatl, tochtli, atl, itzcuintli, ozomahtli, malinalli, acatl, ocelotl, cuauhtli, cozcacuauhtli, ollin, tecpatl, quiahuitl, xochitl.
    #[serde(rename = "daySign")]
    pub day_sign: String,
    /// Display name in Nahuatl with the vowel length marks the reference tables print. A proper noun carried as data, so it is identical under every lang.
    #[serde(rename = "daySignName")]
    pub day_sign_name: String,
    /// World direction the sign belongs to: east, north, west or south. The twenty run through the four quarters in order, so the direction is a property of the position as much as of the sign.
    pub direction: String,
    /// What the sign name means, translated in place because it is a common noun. Several English renderings are in circulation for some signs and all of them are given rather than one being picked.
    pub gloss: String,
    /// The one thing worth doing differently under this sign.
    pub guidance: String,
    /// The sign in one composed sentence. Composed per request from the sign components rather than stored whole.
    pub keynote: String,
    /// The tonalpohualli coefficient, 1 to 13. Structurally the same count as the Maya coefficient and read the same way: a rank it is not.
    pub number: f64,
    /// What the day carries, placing it inside its trecena as well as naming it. Composed per request, so it stays consistent with the keynote rather than being a second opinion.
    pub overview: String,
    /// A plain statement of what this family covers and what it deliberately leaves out. Present on every response so nobody has to guess whether a missing field is an outage or a decision.
    pub scope: String,
    /// The thirteen day period this day belongs to, named by the sign it opens on. No patron deity is returned: the published patron column carries an unresolved disagreement on two of the twenty rows, and a column that is right for eighteen and guessed for two is worse than none.
    pub trecena: GetDailyAztecReadingResponseTrecena,
}
/// The thirteen day period this day belongs to, named by the sign it opens on. No patron deity is returned: the published patron column carries an unresolved disagreement on two of the twenty rows, and a column that is right for eighteen and guessed for two is worse than none.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyAztecReadingResponseTrecena {
    /// Position of this day inside its trecena, 1 to 13. Always equal to the coefficient.
    #[serde(rename = "dayOfTrecena")]
    pub day_of_trecena: f64,
    /// Which of the twenty thirteen day periods this day falls in, 1 to 20.
    pub number: f64,
    /// Machine identifier of the day sign the trecena opens on.
    #[serde(rename = "startSign")]
    pub start_sign: String,
    /// Display name of the sign the trecena opens on. A proper noun carried as data.
    #[serde(rename = "startSignName")]
    pub start_sign_name: String,
}
/// The conventions this reading was computed under, echoed so the result is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyAztecReadingResponseConventions {
    /// The correlation this count runs on, anchored on the recorded day 1 Coatl at the fall of Tenochtitlan, 13 August 1521 in the Julian calendar and 23 August 1521 in the proleptic Gregorian calendar this API takes. It is echoed rather than requested because it is not a switch: the anchor is a civil date, so no correlation constant enters the arithmetic, and the published alternatives for this calendar move the solar year alignment rather than the day count. The count was verified to run in step with the Maya count under the default constant, on the anchor and on two modern dates.
    pub correlation: String,
}
/// Path and query parameters of `getDailyAztecReading`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetDailyAztecReadingParams {
    /// Date in YYYY-MM-DD format, in the PROLEPTIC GREGORIAN calendar, extended backwards unchanged through the 1582 reform. Years 1 to 4000 are accepted. A reference converter that switches to the Julian calendar below the reform will disagree with a date before 15 October 1582 by ten or eleven days; that is a difference of input convention rather than of arithmetic, and passing the Julian equivalent to such a tool reproduces these values exactly. A single-digit month or day is accepted and zero padded. Defaults to the current day in UTC.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetDailyAztecReadingParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetDailyAztecReadingParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getDailyAyurvedaReading`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyAyurvedaReadingResponse {
    /// The pre-dawn window as a fixed offset from sunrise, not a share of the night.
    #[serde(rename = "brahmaMuhurta")]
    pub brahma_muhurta: GetDailyAyurvedaReadingResponseBrahmaMuhurta,
    /// The conventions this reading was produced under. All four are the defaults, stated rather than assumed.
    pub conventions: GetDailyAyurvedaReadingResponseConventions,
    /// The date of this reading. Echoes the date requested, or the current day in the timezone parameter when it was omitted.
    pub date: String,
    /// Which humours this season moves, and how. A season moves at most three of the nine slots and often fewer.
    #[serde(rename = "doshaCycle")]
    pub dosha_cycle: Vec<GetDailyAyurvedaReadingResponseDoshaCycleItem>,
    /// The six blocks, cut from the actual day and night at this place into thirds.
    #[serde(rename = "doshaPeriods")]
    pub dosha_periods: Vec<GetDailyAyurvedaReadingResponseDoshaPeriodsItem>,
    /// Scope of the response.
    pub meta: GetDailyAyurvedaReadingResponseMeta,
    /// The season this date falls in.
    pub ritu: GetDailyAyurvedaReadingResponseRitu,
    /// Every work behind this response, once each.
    pub sources: Vec<GetDailyAyurvedaReadingResponseSourcesItem>,
    /// The day in prose, composed and translated in place.
    pub summary: String,
    /// Sunrise at this place, as an ISO 8601 instant in UTC.
    pub sunrise: String,
    /// Sunset at this place, as an ISO 8601 instant in UTC.
    pub sunset: String,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyAyurvedaReadingResponseSourcesItem {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// The season this date falls in.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyAyurvedaReadingResponseRitu {
    /// The half-year course of the sun, as a Sanskrit identifier. It names what the sun is doing, so it is the same for every observer on the same day.
    pub ayana: String,
    /// When it closes, as an ISO 8601 instant in UTC.
    pub end: String,
    /// What the season is called in the requested language.
    pub gloss: String,
    /// The season as a Sanskrit identifier. Never translated.
    pub id: String,
    /// Whether the sun is taking or giving across this half of the year, as a Sanskrit identifier.
    pub phase: String,
    /// The season in the standard diacritic transliteration.
    #[serde(rename = "sanskritName")]
    pub sanskrit_name: String,
    /// When the season opened, as an ISO 8601 instant in UTC.
    pub start: String,
    /// Bodily strength in this season: highest, moderate or lowest. Always English so it stays safe to switch on.
    pub strength: String,
    /// The taste that grows in nature across this season, as a Sanskrit identifier. It is what the season brings rather than what to favour in it.
    #[serde(rename = "tasteIncreasing")]
    pub taste_increasing: String,
}
/// Scope of the response.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyAyurvedaReadingResponseMeta {
    /// The scope of everything in this response, in the requested language. Present on every response from this API, and intended to be shown to the reader rather than stripped.
    pub disclaimer: String,
}
/// One of the six dosha periods.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyAyurvedaReadingResponseDoshaPeriodsItem {
    /// The humour this block belongs to, as a Sanskrit identifier.
    pub dosha: String,
    /// When the block closes, as an ISO 8601 instant in UTC.
    pub end: String,
    /// Whether the block sits in the day or the night.
    pub span: String,
    /// When the block opens, as an ISO 8601 instant in UTC.
    pub start: String,
}
/// One humour and where the season puts it.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyAyurvedaReadingResponseDoshaCycleItem {
    /// The humour, as a Sanskrit identifier.
    pub dosha: String,
    /// Where the season puts it: accumulating, aggravated or settling. Always English so it stays safe to switch on.
    pub state: String,
}
/// The conventions this reading was produced under. All four are the defaults, stated rather than assumed.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyAyurvedaReadingResponseConventions {
    /// How the six periods were cut. This route always uses the default; the routine route takes the choice.
    #[serde(rename = "doshaClock")]
    pub dosha_clock: String,
    /// Which half of the world the season name is stated for. This route always uses the default and never infers it from the latitude.
    pub hemisphere: String,
    /// Which zodiac the season boundaries were measured in. This route always uses the default.
    #[serde(rename = "rituZodiac")]
    pub ritu_zodiac: String,
    /// Which six-season division was applied. This route always uses the default; the season route takes the choice.
    #[serde(rename = "ritucharyaScheme")]
    pub ritucharya_scheme: String,
}
/// The pre-dawn window as a fixed offset from sunrise, not a share of the night.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyAyurvedaReadingResponseBrahmaMuhurta {
    /// When the window closes, 48 minutes before sunrise.
    pub end: String,
    /// When the window opens, 96 minutes before sunrise.
    pub start: String,
}
/// Path and query parameters of `getDailyAyurvedaReading`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyAyurvedaReadingParams {
    /// Reading date in YYYY-MM-DD format. Past and future dates are both supported, for editorial scheduling and backfill. Defaults to the current day in the timezone parameter.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetDailyAyurvedaReadingParamsLang>,
    /// Latitude in decimal degrees. It sets how long the day and the night actually are, which is what the dosha periods are cut from.
    pub latitude: f64,
    /// Longitude in decimal degrees. It sets the clock time of sunrise at this place.
    pub longitude: f64,
    /// Selects which day counts as current when date is omitted, and which local day sunrise is computed for. Defaults to UTC, so the reading rolls over at 00:00 UTC. Accepts an IANA name (e.g. "Europe/London"), decimal hours (e.g. 5.5 for IST), or a fixed UTC offset (e.g. "-05:00").
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetDailyAyurvedaReadingParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getDailyAngelNumber`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyAngelNumberResponse {
    /// Three to five specific, actionable steps to take today based on the angel number guidance. Practical spiritual advice for daily life.
    #[serde(rename = "actionSteps")]
    pub action_steps: Vec<String>,
    /// Positive affirmation aligned with the daily angel number. Use for daily affirmation features, meditation guidance, or spiritual journal prompts.
    pub affirmation: String,
    /// Biblical and religious perspective on the daily sequence, framed honestly.
    pub biblical: String,
    /// One to two sentence summary of the divine message for today. Ideal for push notifications, daily guidance widgets, and quick reference.
    #[serde(rename = "coreMessage")]
    pub core_message: String,
    /// The date used for angel number selection (UTC).
    pub date: String,
    /// Numerology digit root calculated by summing all digits and reducing to a single digit. Links the daily angel number to its foundational numerology meaning.
    #[serde(rename = "digitRoot")]
    pub digit_root: f64,
    /// Overall energy classification. "positive" indicates encouraging, uplifting energy. "neutral" indicates transitional energy. "cautionary" indicates a gentle warning to rebalance or pay attention.
    pub energy: String,
    /// Five to eight keywords capturing the spiritual themes and energy of the daily angel number. Useful for search, filtering, and content generation.
    pub keywords: Vec<String>,
    /// Detailed interpretations across life areas for the daily angel number.
    pub meaning: GetDailyAngelNumberResponseMeaning,
    /// Angel number sequence selected for today. Three or more digit repeating, sequential, or mirror pattern (e.g., 111, 444, 1212).
    pub number: String,
    /// Computed seed used for this reading. Same seed always produces the same angel number.
    pub seed: String,
    /// Shadow or cautionary reading for the daily sequence. Complements the energy classification.
    pub shadow: String,
    /// Short descriptive title capturing the core theme and spiritual significance of the daily angel number.
    pub title: String,
    /// Pattern classification of the daily angel number. "repeating" means all digits are the same (111, 4444). "sequential" means consecutive digits (1234). "mirror" means palindrome or alternating pattern (1212, 1221).
    pub r#type: String,
}
/// Detailed interpretations across life areas for the daily angel number.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyAngelNumberResponseMeaning {
    /// Career and vocation guidance: professional opportunities, calling, and practical work advice. Money and finances are returned separately in the money field.
    pub career: String,
    /// Love and relationship interpretation covering singles, couples, and those healing from past relationships. Includes romantic guidance and partnership advice.
    pub love: String,
    /// Money, finances, and material abundance guidance, kept distinct from career and vocation.
    pub money: String,
    /// Two to three paragraph spiritual interpretation covering divine guidance, higher purpose, and the metaphysical significance of the angel number selected for this date.
    pub spiritual: String,
    /// Twin flame connection interpretation covering union, separation, and spiritual growth within the twin flame journey.
    #[serde(rename = "twinFlame")]
    pub twin_flame: String,
}
/// Path and query parameters of `getDailyAngelNumber`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetDailyAngelNumberParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetDailyAngelNumberParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetDailyAngelNumberParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getCurrentMoonPhase`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentMoonPhaseResponse {
    /// Lunar age in days since the last New Moon. Full lunation cycle is ~29.53 days.
    pub age: f64,
    /// Date of this moon phase calculation (YYYY-MM-DD).
    pub date: String,
    /// Degree of the Moon within its current zodiac sign (0-29.999).
    pub degree: f64,
    /// Distance from Earth to the Moon in kilometers.
    pub distance: f64,
    /// Moon illumination percentage (0-100). 0 = New Moon, 100 = Full Moon.
    pub illumination: f64,
    /// Moon phase meaning and astrological interpretation. Includes energy direction, keywords, and guidance for this lunar phase.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub meaning: Option<GetCurrentMoonPhaseResponseMeaning>,
    /// Current lunar phase name. One of: New Moon, Waxing Crescent Moon, First Quarter Moon, Waxing Gibbous Moon, Full Moon, Waning Gibbous Moon, Last Quarter Moon, Waning Crescent Moon.
    pub phase: String,
    /// Tropical zodiac sign the Moon currently occupies.
    pub sign: String,
}
/// Moon phase meaning and astrological interpretation. Includes energy direction, keywords, and guidance for this lunar phase.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentMoonPhaseResponseMeaning {
    /// Astrological interpretation of this lunar phase and its influence on activities, emotions, and intentions.
    pub description: String,
    /// Lunar energy direction: waxing (building), waning (releasing), new (beginning), or full (culmination).
    pub energy: GetCurrentMoonPhaseResponseMeaningEnergy,
    /// Illumination range description for this phase.
    pub illumination: String,
    /// Key themes and activities aligned with this moon phase.
    pub keywords: Vec<String>,
    /// Moon phase display name.
    pub name: String,
    /// Moon phase emoji symbol.
    pub symbol: String,
}
string_enum! {
    /// Lunar energy direction: waxing (building), waning (releasing), new (beginning), or full (culmination).
    GetCurrentMoonPhaseResponseMeaningEnergy {
        Waxing = "waxing",
        Waning = "waning",
        New = "new",
        Full = "full",
    }
}
/// Path and query parameters of `getCurrentMoonPhase`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetCurrentMoonPhaseParams {
    /// Date in YYYY-MM-DD format. Defaults to today if omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetCurrentMoonPhaseParamsLang>,
    /// Time in 24-hour HH:MM:SS format. Defaults to 12:00:00 (noon). Moon moves ~13 degrees per day so time affects phase precision.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub time: Option<String>,
    /// IANA name (e.g. "America/New_York", "Europe/London"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00"). IANA resolved to the DST-correct offset for the given date. Defaults to 0 (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetCurrentMoonPhaseParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getCurrentDasha`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponse {
    /// Antardasha (bhukti), sub-period within a Mahadasha. Each Mahadasha contains 9 Antardashas proportional to the Vimshottari years of each planet.
    pub antardasha: GetCurrentDashaResponseAntardasha,
    /// Ayanamsa actually applied, in degrees. The precession offset subtracted from the tropical (sayana) longitude to get the sidereal (nirayana) one. Lahiri sits near 23 deg 43 min for a 1990 birth, KP-Newcomb near 23 deg 38 min.
    pub ayanamsa: f64,
    /// Ayanamsa system used, echoing the request field. One of "lahiri", "kp-newcomb", "kp-old" or "custom". Echoed so a client can confirm which frame produced these dates without re-deriving it. When it reads "custom" the ayanamsa field above carries the exact value you supplied.
    #[serde(rename = "ayanamsaType")]
    pub ayanamsa_type: GetCurrentDashaResponseAyanamsaType,
    /// Houses common to the significators of the running dasha lords. In KP a matter fructifies under lords that jointly signify the houses of that matter, so these two sets are what a prediction is checked against.
    #[serde(rename = "commonHouses", skip_serializing_if = "Option::is_none")]
    pub common_houses: Option<GetCurrentDashaResponseCommonHouses>,
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<GetCurrentDashaResponseFocus>,
    /// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
    #[serde(rename = "houseThemes", skip_serializing_if = "Option::is_none")]
    pub house_themes: Option<GetCurrentDashaResponseHouseThemes>,
    /// Mahadasha (major planetary period) in the 120-year Vimshottari dasha cycle. Start and end dates are determined by Moon nakshatra at birth.
    pub mahadasha: GetCurrentDashaResponseMahadasha,
    /// Sidereal (nirayana) longitude of the birth Moon in degrees, 0 to 360, measured in the ayanamsa frame reported below. This single value determines the birth nakshatra and therefore every dasha start and end date in this response. Compare it against a reference chart to reconcile any date difference at its source.
    #[serde(rename = "moonLongitude")]
    pub moon_longitude: f64,
    /// Birth Moon nakshatra number (1-27). This nakshatra determines the starting dasha lord in the Vimshottari 120-year cycle.
    #[serde(rename = "moonNakshatra")]
    pub moon_nakshatra: i64,
    /// Vimshottari dasha lord of the birth nakshatra. This planet rules the first Mahadasha in the native life cycle.
    #[serde(rename = "nakshatraLord")]
    pub nakshatra_lord: GetCurrentDashaResponseNakshatraLord,
    /// Name of the birth Moon nakshatra (lunar mansion). One of 27 Vedic nakshatras from Ashwini to Revati.
    #[serde(rename = "nakshatraName")]
    pub nakshatra_name: String,
    /// Prana dasha (praana antardasha), the fifth and finest level of the Vimshottari dasha hierarchy. Each Sookshma dasha divides into 9 Prana periods, running from about 20 minutes inside a Sun Mahadasha to about 4 days inside a Saturn one. This is the level that takes Vimshottari from day-level to hour-level timing, used for muhurta selection and pinpointing the trigger inside an already identified window.
    #[serde(rename = "pranaDasha")]
    pub prana_dasha: GetCurrentDashaResponsePranaDasha,
    /// Pratyantardasha (sub-sub-period), the third level of the Vimshottari dasha hierarchy, Provides finer timing within each Antardasha for event prediction.
    pub pratyantardasha: GetCurrentDashaResponsePratyantardasha,
    /// Time remaining in the currently running Antardasha (sub-period) within the Mahadasha.
    #[serde(rename = "remainingInAntardasha")]
    pub remaining_in_antardasha: GetCurrentDashaResponseRemainingInAntardasha,
    /// Time remaining in the currently running Mahadasha (major period).
    #[serde(rename = "remainingInMahadasha")]
    pub remaining_in_mahadasha: GetCurrentDashaResponseRemainingInMahadasha,
    /// Time remaining in the currently running Prana dasha (fifth level). Prana periods run hours to days, so totalDays is often 0 or 1 and the years and months fields are almost always zero.
    #[serde(rename = "remainingInPrana")]
    pub remaining_in_prana: GetCurrentDashaResponseRemainingInPrana,
    /// Time remaining in the currently running Pratyantardasha (sub-sub-period).
    #[serde(rename = "remainingInPratyantardasha")]
    pub remaining_in_pratyantardasha: GetCurrentDashaResponseRemainingInPratyantardasha,
    /// Time remaining in the currently running Sookshma dasha (fourth level). Sookshma periods last days rather than months, so this value turns over quickly.
    #[serde(rename = "remainingInSookshma")]
    pub remaining_in_sookshma: GetCurrentDashaResponseRemainingInSookshma,
    /// Sookshma dasha (sookshma antardasha), the fourth level of the Vimshottari dasha hierarchy. Each Pratyantardasha divides into 9 Sookshma periods running roughly 3 to 30 days each, used for day-level event timing and muhurta style selection.
    #[serde(rename = "sookshmaDasha")]
    pub sookshma_dasha: GetCurrentDashaResponseSookshmaDasha,
}
/// Sookshma dasha (sookshma antardasha), the fourth level of the Vimshottari dasha hierarchy. Each Pratyantardasha divides into 9 Sookshma periods running roughly 3 to 30 days each, used for day-level event timing and muhurta style selection.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponseSookshmaDasha {
    /// Parent Antardasha lord under which this Pratyantardasha runs.
    #[serde(rename = "antardashaLord")]
    pub antardasha_lord: GetCurrentDashaResponseSookshmaDashaAntardashaLord,
    /// Duration of this dasha period in years. Mahadasha durations range from 6 years (Sun) to 20 years (Venus).
    #[serde(rename = "durationYears")]
    pub duration_years: f64,
    /// End datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Vedic interpretation of the planetary period describing themes, karmic lessons, and life areas affected by this graha.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interpretation: Option<String>,
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    #[serde(rename = "mahadashaLord")]
    pub mahadasha_lord: GetCurrentDashaResponseSookshmaDashaMahadashaLord,
    /// Theoretical start of this period, present ONLY when the birth date truncated it. The Vimshottari cycle is already running when a native is born, so the period in force at birth began earlier: startDate is clipped to the birth moment while this field keeps the real start. Its presence is also why the first period of a chart can contain fewer than 9 sub-periods, the earlier ones having finished before birth. Absent on every period that runs its full length.
    #[serde(rename = "nominalStartDate", skip_serializing_if = "Option::is_none")]
    pub nominal_start_date: Option<String>,
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    pub planet: GetCurrentDashaResponseSookshmaDashaPlanet,
    /// Parent Pratyantardasha lord under which this Sookshma dasha runs.
    #[serde(rename = "pratyantardashaLord")]
    pub pratyantardasha_lord: GetCurrentDashaResponseSookshmaDashaPratyantardashaLord,
    /// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub significators: Option<GetCurrentDashaResponseSookshmaDashaSignificators>,
    /// Start datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "startDate")]
    pub start_date: String,
}
/// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponseSookshmaDashaSignificators {
    /// House 1-12 this lord occupies in the Placidus birth chart. Its own Level 2 signification, repeated here because the occupied house is the first thing a KP reading looks at.
    pub house: i64,
    /// Every house this lord signifies, deduplicated and ordered strongest tier first. Where a house is reached at more than one level it is listed once, at its strongest. This is the flat "houses signified" column of a KP dasha table.
    #[serde(rename = "signifiedHouses")]
    pub signified_houses: Vec<i64>,
    /// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
    pub signifies: GetCurrentDashaResponseSookshmaDashaSignificatorsSignifies,
    /// Lord of the nakshatra this planet sits in, one of the 9 grahas. In KP the star lord outranks the planet itself: a period lord mainly delivers the houses its star lord occupies and owns, which is why those appear at L1 and L3 rather than the planet own house.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
    pub strength: GetCurrentDashaResponseSookshmaDashaSignificatorsStrength,
    /// Subset of signifiedHouses reached at grade A or B (levels L1 and L2). These are the houses a KP reading acts on for this period; the rest are supporting connections.
    #[serde(rename = "strongHouses")]
    pub strong_houses: Vec<i64>,
    /// KP sub lord of this planet, the 1 of 249 subdivision its longitude falls in, one of the 9 grahas. The star lord says WHAT results the period gives, the sub lord says WHETHER they materialize, so KP judgement checks both.
    #[serde(rename = "subLord", skip_serializing_if = "Option::is_none")]
    pub sub_lord: Option<String>,
}
/// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponseSookshmaDashaSignificatorsStrength {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    pub grade: GetCurrentDashaResponseSookshmaDashaSignificatorsStrengthGrade,
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    pub label: GetCurrentDashaResponseSookshmaDashaSignificatorsStrengthLabel,
    /// Mean KP percentage weight across signifiedHouses, each house counted at its strongest level (A 100, B 75, C 50, D 25). A mean rather than a total, so signifying many houses weakly does not outrank signifying two houses at grade A.
    pub score: f64,
}
string_enum! {
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    GetCurrentDashaResponseSookshmaDashaSignificatorsStrengthLabel {
        VeryStrong = "very-strong",
        Strong = "strong",
        Moderate = "moderate",
        Weak = "weak",
    }
}
string_enum! {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    GetCurrentDashaResponseSookshmaDashaSignificatorsStrengthGrade {
        A = "A",
        B = "B",
        C = "C",
        D = "D",
    }
}
/// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponseSookshmaDashaSignificatorsSignifies {
    /// Level 1, the strongest signification (grade A). Houses influenced because this planet sits in the nakshatra (star) of a planet occupying those houses. For Rahu and Ketu, also includes the L1 houses of their agent planets (conjoined, aspecting, sign lord).
    #[serde(rename = "L1")]
    pub l1: Vec<i64>,
    /// Level 2 (grade B). The house this planet physically occupies. For Rahu and Ketu, also includes houses occupied by their agent planets.
    #[serde(rename = "L2")]
    pub l2: Vec<i64>,
    /// Level 3 (grade C). Houses influenced because this planet sits in the nakshatra of the sign lord (owner) of those houses. For Rahu and Ketu, also includes the L3 houses of their agent planets.
    #[serde(rename = "L3")]
    pub l3: Vec<i64>,
    /// Level 4, the weakest signification (grade D). Houses this planet rules by zodiac sign ownership, up to 2 for Sun through Saturn and 3 where a sign is intercepted. Rahu and Ketu own no sign, so their L4 comes entirely from their agent planets.
    #[serde(rename = "L4")]
    pub l4: Vec<i64>,
}
string_enum! {
    /// Parent Pratyantardasha lord under which this Sookshma dasha runs.
    GetCurrentDashaResponseSookshmaDashaPratyantardashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    GetCurrentDashaResponseSookshmaDashaPlanet {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    GetCurrentDashaResponseSookshmaDashaMahadashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Parent Antardasha lord under which this Pratyantardasha runs.
    GetCurrentDashaResponseSookshmaDashaAntardashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Time remaining in the currently running Sookshma dasha (fourth level). Sookshma periods last days rather than months, so this value turns over quickly.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponseRemainingInSookshma {
    /// Additional days remaining beyond full months.
    pub days: f64,
    /// Additional months remaining beyond full years.
    pub months: f64,
    /// Total remaining days in this dasha period. Useful for progress calculations.
    #[serde(rename = "totalDays")]
    pub total_days: f64,
    /// Full years remaining in this Vimshottari dasha period.
    pub years: f64,
}
/// Time remaining in the currently running Pratyantardasha (sub-sub-period).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponseRemainingInPratyantardasha {
    /// Additional days remaining beyond full months.
    pub days: f64,
    /// Additional months remaining beyond full years.
    pub months: f64,
    /// Total remaining days in this dasha period. Useful for progress calculations.
    #[serde(rename = "totalDays")]
    pub total_days: f64,
    /// Full years remaining in this Vimshottari dasha period.
    pub years: f64,
}
/// Time remaining in the currently running Prana dasha (fifth level). Prana periods run hours to days, so totalDays is often 0 or 1 and the years and months fields are almost always zero.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponseRemainingInPrana {
    /// Additional days remaining beyond full months.
    pub days: f64,
    /// Additional months remaining beyond full years.
    pub months: f64,
    /// Total remaining days in this dasha period. Useful for progress calculations.
    #[serde(rename = "totalDays")]
    pub total_days: f64,
    /// Full years remaining in this Vimshottari dasha period.
    pub years: f64,
}
/// Time remaining in the currently running Mahadasha (major period).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponseRemainingInMahadasha {
    /// Additional days remaining beyond full months.
    pub days: f64,
    /// Additional months remaining beyond full years.
    pub months: f64,
    /// Total remaining days in this dasha period. Useful for progress calculations.
    #[serde(rename = "totalDays")]
    pub total_days: f64,
    /// Full years remaining in this Vimshottari dasha period.
    pub years: f64,
}
/// Time remaining in the currently running Antardasha (sub-period) within the Mahadasha.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponseRemainingInAntardasha {
    /// Additional days remaining beyond full months.
    pub days: f64,
    /// Additional months remaining beyond full years.
    pub months: f64,
    /// Total remaining days in this dasha period. Useful for progress calculations.
    #[serde(rename = "totalDays")]
    pub total_days: f64,
    /// Full years remaining in this Vimshottari dasha period.
    pub years: f64,
}
/// Pratyantardasha (sub-sub-period), the third level of the Vimshottari dasha hierarchy, Provides finer timing within each Antardasha for event prediction.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponsePratyantardasha {
    /// Parent Antardasha lord under which this Pratyantardasha runs.
    #[serde(rename = "antardashaLord")]
    pub antardasha_lord: GetCurrentDashaResponsePratyantardashaAntardashaLord,
    /// Duration of this dasha period in years. Mahadasha durations range from 6 years (Sun) to 20 years (Venus).
    #[serde(rename = "durationYears")]
    pub duration_years: f64,
    /// End datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Vedic interpretation of the planetary period describing themes, karmic lessons, and life areas affected by this graha.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interpretation: Option<String>,
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    #[serde(rename = "mahadashaLord")]
    pub mahadasha_lord: GetCurrentDashaResponsePratyantardashaMahadashaLord,
    /// Theoretical start of this period, present ONLY when the birth date truncated it. The Vimshottari cycle is already running when a native is born, so the period in force at birth began earlier: startDate is clipped to the birth moment while this field keeps the real start. Its presence is also why the first period of a chart can contain fewer than 9 sub-periods, the earlier ones having finished before birth. Absent on every period that runs its full length.
    #[serde(rename = "nominalStartDate", skip_serializing_if = "Option::is_none")]
    pub nominal_start_date: Option<String>,
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    pub planet: GetCurrentDashaResponsePratyantardashaPlanet,
    /// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub significators: Option<GetCurrentDashaResponsePratyantardashaSignificators>,
    /// Start datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "startDate")]
    pub start_date: String,
}
/// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponsePratyantardashaSignificators {
    /// House 1-12 this lord occupies in the Placidus birth chart. Its own Level 2 signification, repeated here because the occupied house is the first thing a KP reading looks at.
    pub house: i64,
    /// Every house this lord signifies, deduplicated and ordered strongest tier first. Where a house is reached at more than one level it is listed once, at its strongest. This is the flat "houses signified" column of a KP dasha table.
    #[serde(rename = "signifiedHouses")]
    pub signified_houses: Vec<i64>,
    /// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
    pub signifies: GetCurrentDashaResponsePratyantardashaSignificatorsSignifies,
    /// Lord of the nakshatra this planet sits in, one of the 9 grahas. In KP the star lord outranks the planet itself: a period lord mainly delivers the houses its star lord occupies and owns, which is why those appear at L1 and L3 rather than the planet own house.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
    pub strength: GetCurrentDashaResponsePratyantardashaSignificatorsStrength,
    /// Subset of signifiedHouses reached at grade A or B (levels L1 and L2). These are the houses a KP reading acts on for this period; the rest are supporting connections.
    #[serde(rename = "strongHouses")]
    pub strong_houses: Vec<i64>,
    /// KP sub lord of this planet, the 1 of 249 subdivision its longitude falls in, one of the 9 grahas. The star lord says WHAT results the period gives, the sub lord says WHETHER they materialize, so KP judgement checks both.
    #[serde(rename = "subLord", skip_serializing_if = "Option::is_none")]
    pub sub_lord: Option<String>,
}
/// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponsePratyantardashaSignificatorsStrength {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    pub grade: GetCurrentDashaResponsePratyantardashaSignificatorsStrengthGrade,
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    pub label: GetCurrentDashaResponsePratyantardashaSignificatorsStrengthLabel,
    /// Mean KP percentage weight across signifiedHouses, each house counted at its strongest level (A 100, B 75, C 50, D 25). A mean rather than a total, so signifying many houses weakly does not outrank signifying two houses at grade A.
    pub score: f64,
}
string_enum! {
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    GetCurrentDashaResponsePratyantardashaSignificatorsStrengthLabel {
        VeryStrong = "very-strong",
        Strong = "strong",
        Moderate = "moderate",
        Weak = "weak",
    }
}
string_enum! {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    GetCurrentDashaResponsePratyantardashaSignificatorsStrengthGrade {
        A = "A",
        B = "B",
        C = "C",
        D = "D",
    }
}
/// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponsePratyantardashaSignificatorsSignifies {
    /// Level 1, the strongest signification (grade A). Houses influenced because this planet sits in the nakshatra (star) of a planet occupying those houses. For Rahu and Ketu, also includes the L1 houses of their agent planets (conjoined, aspecting, sign lord).
    #[serde(rename = "L1")]
    pub l1: Vec<i64>,
    /// Level 2 (grade B). The house this planet physically occupies. For Rahu and Ketu, also includes houses occupied by their agent planets.
    #[serde(rename = "L2")]
    pub l2: Vec<i64>,
    /// Level 3 (grade C). Houses influenced because this planet sits in the nakshatra of the sign lord (owner) of those houses. For Rahu and Ketu, also includes the L3 houses of their agent planets.
    #[serde(rename = "L3")]
    pub l3: Vec<i64>,
    /// Level 4, the weakest signification (grade D). Houses this planet rules by zodiac sign ownership, up to 2 for Sun through Saturn and 3 where a sign is intercepted. Rahu and Ketu own no sign, so their L4 comes entirely from their agent planets.
    #[serde(rename = "L4")]
    pub l4: Vec<i64>,
}
string_enum! {
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    GetCurrentDashaResponsePratyantardashaPlanet {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    GetCurrentDashaResponsePratyantardashaMahadashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Parent Antardasha lord under which this Pratyantardasha runs.
    GetCurrentDashaResponsePratyantardashaAntardashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Prana dasha (praana antardasha), the fifth and finest level of the Vimshottari dasha hierarchy. Each Sookshma dasha divides into 9 Prana periods, running from about 20 minutes inside a Sun Mahadasha to about 4 days inside a Saturn one. This is the level that takes Vimshottari from day-level to hour-level timing, used for muhurta selection and pinpointing the trigger inside an already identified window.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponsePranaDasha {
    /// Parent Antardasha lord under which this Pratyantardasha runs.
    #[serde(rename = "antardashaLord")]
    pub antardasha_lord: GetCurrentDashaResponsePranaDashaAntardashaLord,
    /// Duration of this dasha period in years. Mahadasha durations range from 6 years (Sun) to 20 years (Venus).
    #[serde(rename = "durationYears")]
    pub duration_years: f64,
    /// End datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Vedic interpretation of the planetary period describing themes, karmic lessons, and life areas affected by this graha.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interpretation: Option<String>,
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    #[serde(rename = "mahadashaLord")]
    pub mahadasha_lord: GetCurrentDashaResponsePranaDashaMahadashaLord,
    /// Theoretical start of this period, present ONLY when the birth date truncated it. The Vimshottari cycle is already running when a native is born, so the period in force at birth began earlier: startDate is clipped to the birth moment while this field keeps the real start. Its presence is also why the first period of a chart can contain fewer than 9 sub-periods, the earlier ones having finished before birth. Absent on every period that runs its full length.
    #[serde(rename = "nominalStartDate", skip_serializing_if = "Option::is_none")]
    pub nominal_start_date: Option<String>,
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    pub planet: GetCurrentDashaResponsePranaDashaPlanet,
    /// Parent Pratyantardasha lord under which this Sookshma dasha runs.
    #[serde(rename = "pratyantardashaLord")]
    pub pratyantardasha_lord: GetCurrentDashaResponsePranaDashaPratyantardashaLord,
    /// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub significators: Option<GetCurrentDashaResponsePranaDashaSignificators>,
    /// Parent Sookshma dasha lord under which this Prana dasha runs.
    #[serde(rename = "sookshmaLord")]
    pub sookshma_lord: GetCurrentDashaResponsePranaDashaSookshmaLord,
    /// Start datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "startDate")]
    pub start_date: String,
}
string_enum! {
    /// Parent Sookshma dasha lord under which this Prana dasha runs.
    GetCurrentDashaResponsePranaDashaSookshmaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponsePranaDashaSignificators {
    /// House 1-12 this lord occupies in the Placidus birth chart. Its own Level 2 signification, repeated here because the occupied house is the first thing a KP reading looks at.
    pub house: i64,
    /// Every house this lord signifies, deduplicated and ordered strongest tier first. Where a house is reached at more than one level it is listed once, at its strongest. This is the flat "houses signified" column of a KP dasha table.
    #[serde(rename = "signifiedHouses")]
    pub signified_houses: Vec<i64>,
    /// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
    pub signifies: GetCurrentDashaResponsePranaDashaSignificatorsSignifies,
    /// Lord of the nakshatra this planet sits in, one of the 9 grahas. In KP the star lord outranks the planet itself: a period lord mainly delivers the houses its star lord occupies and owns, which is why those appear at L1 and L3 rather than the planet own house.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
    pub strength: GetCurrentDashaResponsePranaDashaSignificatorsStrength,
    /// Subset of signifiedHouses reached at grade A or B (levels L1 and L2). These are the houses a KP reading acts on for this period; the rest are supporting connections.
    #[serde(rename = "strongHouses")]
    pub strong_houses: Vec<i64>,
    /// KP sub lord of this planet, the 1 of 249 subdivision its longitude falls in, one of the 9 grahas. The star lord says WHAT results the period gives, the sub lord says WHETHER they materialize, so KP judgement checks both.
    #[serde(rename = "subLord", skip_serializing_if = "Option::is_none")]
    pub sub_lord: Option<String>,
}
/// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponsePranaDashaSignificatorsStrength {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    pub grade: GetCurrentDashaResponsePranaDashaSignificatorsStrengthGrade,
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    pub label: GetCurrentDashaResponsePranaDashaSignificatorsStrengthLabel,
    /// Mean KP percentage weight across signifiedHouses, each house counted at its strongest level (A 100, B 75, C 50, D 25). A mean rather than a total, so signifying many houses weakly does not outrank signifying two houses at grade A.
    pub score: f64,
}
string_enum! {
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    GetCurrentDashaResponsePranaDashaSignificatorsStrengthLabel {
        VeryStrong = "very-strong",
        Strong = "strong",
        Moderate = "moderate",
        Weak = "weak",
    }
}
string_enum! {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    GetCurrentDashaResponsePranaDashaSignificatorsStrengthGrade {
        A = "A",
        B = "B",
        C = "C",
        D = "D",
    }
}
/// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponsePranaDashaSignificatorsSignifies {
    /// Level 1, the strongest signification (grade A). Houses influenced because this planet sits in the nakshatra (star) of a planet occupying those houses. For Rahu and Ketu, also includes the L1 houses of their agent planets (conjoined, aspecting, sign lord).
    #[serde(rename = "L1")]
    pub l1: Vec<i64>,
    /// Level 2 (grade B). The house this planet physically occupies. For Rahu and Ketu, also includes houses occupied by their agent planets.
    #[serde(rename = "L2")]
    pub l2: Vec<i64>,
    /// Level 3 (grade C). Houses influenced because this planet sits in the nakshatra of the sign lord (owner) of those houses. For Rahu and Ketu, also includes the L3 houses of their agent planets.
    #[serde(rename = "L3")]
    pub l3: Vec<i64>,
    /// Level 4, the weakest signification (grade D). Houses this planet rules by zodiac sign ownership, up to 2 for Sun through Saturn and 3 where a sign is intercepted. Rahu and Ketu own no sign, so their L4 comes entirely from their agent planets.
    #[serde(rename = "L4")]
    pub l4: Vec<i64>,
}
string_enum! {
    /// Parent Pratyantardasha lord under which this Sookshma dasha runs.
    GetCurrentDashaResponsePranaDashaPratyantardashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    GetCurrentDashaResponsePranaDashaPlanet {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    GetCurrentDashaResponsePranaDashaMahadashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Parent Antardasha lord under which this Pratyantardasha runs.
    GetCurrentDashaResponsePranaDashaAntardashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Vimshottari dasha lord of the birth nakshatra. This planet rules the first Mahadasha in the native life cycle.
    GetCurrentDashaResponseNakshatraLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Mahadasha (major planetary period) in the 120-year Vimshottari dasha cycle. Start and end dates are determined by Moon nakshatra at birth.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponseMahadasha {
    /// Duration of this dasha period in years. Mahadasha durations range from 6 years (Sun) to 20 years (Venus).
    #[serde(rename = "durationYears")]
    pub duration_years: f64,
    /// End datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Vedic interpretation of the planetary period describing themes, karmic lessons, and life areas affected by this graha.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interpretation: Option<String>,
    /// Theoretical start of this period, present ONLY when the birth date truncated it. The Vimshottari cycle is already running when a native is born, so the period in force at birth began earlier: startDate is clipped to the birth moment while this field keeps the real start. Its presence is also why the first period of a chart can contain fewer than 9 sub-periods, the earlier ones having finished before birth. Absent on every period that runs its full length.
    #[serde(rename = "nominalStartDate", skip_serializing_if = "Option::is_none")]
    pub nominal_start_date: Option<String>,
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    pub planet: GetCurrentDashaResponseMahadashaPlanet,
    /// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub significators: Option<GetCurrentDashaResponseMahadashaSignificators>,
    /// Start datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "startDate")]
    pub start_date: String,
}
/// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponseMahadashaSignificators {
    /// House 1-12 this lord occupies in the Placidus birth chart. Its own Level 2 signification, repeated here because the occupied house is the first thing a KP reading looks at.
    pub house: i64,
    /// Every house this lord signifies, deduplicated and ordered strongest tier first. Where a house is reached at more than one level it is listed once, at its strongest. This is the flat "houses signified" column of a KP dasha table.
    #[serde(rename = "signifiedHouses")]
    pub signified_houses: Vec<i64>,
    /// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
    pub signifies: GetCurrentDashaResponseMahadashaSignificatorsSignifies,
    /// Lord of the nakshatra this planet sits in, one of the 9 grahas. In KP the star lord outranks the planet itself: a period lord mainly delivers the houses its star lord occupies and owns, which is why those appear at L1 and L3 rather than the planet own house.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
    pub strength: GetCurrentDashaResponseMahadashaSignificatorsStrength,
    /// Subset of signifiedHouses reached at grade A or B (levels L1 and L2). These are the houses a KP reading acts on for this period; the rest are supporting connections.
    #[serde(rename = "strongHouses")]
    pub strong_houses: Vec<i64>,
    /// KP sub lord of this planet, the 1 of 249 subdivision its longitude falls in, one of the 9 grahas. The star lord says WHAT results the period gives, the sub lord says WHETHER they materialize, so KP judgement checks both.
    #[serde(rename = "subLord", skip_serializing_if = "Option::is_none")]
    pub sub_lord: Option<String>,
}
/// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponseMahadashaSignificatorsStrength {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    pub grade: GetCurrentDashaResponseMahadashaSignificatorsStrengthGrade,
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    pub label: GetCurrentDashaResponseMahadashaSignificatorsStrengthLabel,
    /// Mean KP percentage weight across signifiedHouses, each house counted at its strongest level (A 100, B 75, C 50, D 25). A mean rather than a total, so signifying many houses weakly does not outrank signifying two houses at grade A.
    pub score: f64,
}
string_enum! {
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    GetCurrentDashaResponseMahadashaSignificatorsStrengthLabel {
        VeryStrong = "very-strong",
        Strong = "strong",
        Moderate = "moderate",
        Weak = "weak",
    }
}
string_enum! {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    GetCurrentDashaResponseMahadashaSignificatorsStrengthGrade {
        A = "A",
        B = "B",
        C = "C",
        D = "D",
    }
}
/// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponseMahadashaSignificatorsSignifies {
    /// Level 1, the strongest signification (grade A). Houses influenced because this planet sits in the nakshatra (star) of a planet occupying those houses. For Rahu and Ketu, also includes the L1 houses of their agent planets (conjoined, aspecting, sign lord).
    #[serde(rename = "L1")]
    pub l1: Vec<i64>,
    /// Level 2 (grade B). The house this planet physically occupies. For Rahu and Ketu, also includes houses occupied by their agent planets.
    #[serde(rename = "L2")]
    pub l2: Vec<i64>,
    /// Level 3 (grade C). Houses influenced because this planet sits in the nakshatra of the sign lord (owner) of those houses. For Rahu and Ketu, also includes the L3 houses of their agent planets.
    #[serde(rename = "L3")]
    pub l3: Vec<i64>,
    /// Level 4, the weakest signification (grade D). Houses this planet rules by zodiac sign ownership, up to 2 for Sun through Saturn and 3 where a sign is intercepted. Rahu and Ketu own no sign, so their L4 comes entirely from their agent planets.
    #[serde(rename = "L4")]
    pub l4: Vec<i64>,
}
string_enum! {
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    GetCurrentDashaResponseMahadashaPlanet {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponseHouseThemes {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, Vec<String>>,
}
string_enum! {
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    GetCurrentDashaResponseFocus {
        General = "general",
        Finance = "finance",
    }
}
/// Houses common to the significators of the running dasha lords. In KP a matter fructifies under lords that jointly signify the houses of that matter, so these two sets are what a prediction is checked against.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponseCommonHouses {
    /// Houses signified by ALL FIVE running lords at once (Mahadasha through Prana). The tightest reading available: a house every active level carries is the one the current moment is pointed at. Often empty, which is itself informative, it means the five levels do not converge on a single house.
    #[serde(rename = "allLevels")]
    pub all_levels: Vec<i64>,
    /// Houses signified by the Mahadasha, Antardasha and Pratyantardasha lords together, the classical KP three-lord test used to decide whether a matter fructifies in the running period. Wider than allLevels because it ignores the two fastest levels, which is what makes it the practical filter for month-scale predictions.
    #[serde(rename = "dashaBhuktiAntara")]
    pub dasha_bhukti_antara: Vec<i64>,
}
string_enum! {
    /// Ayanamsa system used, echoing the request field. One of "lahiri", "kp-newcomb", "kp-old" or "custom". Echoed so a client can confirm which frame produced these dates without re-deriving it. When it reads "custom" the ayanamsa field above carries the exact value you supplied.
    GetCurrentDashaResponseAyanamsaType {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Antardasha (bhukti), sub-period within a Mahadasha. Each Mahadasha contains 9 Antardashas proportional to the Vimshottari years of each planet.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponseAntardasha {
    /// Duration of this dasha period in years. Mahadasha durations range from 6 years (Sun) to 20 years (Venus).
    #[serde(rename = "durationYears")]
    pub duration_years: f64,
    /// End datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Vedic interpretation of the planetary period describing themes, karmic lessons, and life areas affected by this graha.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub interpretation: Option<String>,
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    #[serde(rename = "mahadashaLord")]
    pub mahadasha_lord: GetCurrentDashaResponseAntardashaMahadashaLord,
    /// Theoretical start of this period, present ONLY when the birth date truncated it. The Vimshottari cycle is already running when a native is born, so the period in force at birth began earlier: startDate is clipped to the birth moment while this field keeps the real start. Its presence is also why the first period of a chart can contain fewer than 9 sub-periods, the earlier ones having finished before birth. Absent on every period that runs its full length.
    #[serde(rename = "nominalStartDate", skip_serializing_if = "Option::is_none")]
    pub nominal_start_date: Option<String>,
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    pub planet: GetCurrentDashaResponseAntardashaPlanet,
    /// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub significators: Option<GetCurrentDashaResponseAntardashaSignificators>,
    /// Start datetime of this dasha period. Adjusted to the requested timezone offset.
    #[serde(rename = "startDate")]
    pub start_date: String,
}
/// KP significators of this period lord, read from the Placidus birth chart in the requested ayanamsa. Present only when the request sets "significators": true.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponseAntardashaSignificators {
    /// House 1-12 this lord occupies in the Placidus birth chart. Its own Level 2 signification, repeated here because the occupied house is the first thing a KP reading looks at.
    pub house: i64,
    /// Every house this lord signifies, deduplicated and ordered strongest tier first. Where a house is reached at more than one level it is listed once, at its strongest. This is the flat "houses signified" column of a KP dasha table.
    #[serde(rename = "signifiedHouses")]
    pub signified_houses: Vec<i64>,
    /// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
    pub signifies: GetCurrentDashaResponseAntardashaSignificatorsSignifies,
    /// Lord of the nakshatra this planet sits in, one of the 9 grahas. In KP the star lord outranks the planet itself: a period lord mainly delivers the houses its star lord occupies and owns, which is why those appear at L1 and L3 rather than the planet own house.
    #[serde(rename = "starLord")]
    pub star_lord: String,
    /// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
    pub strength: GetCurrentDashaResponseAntardashaSignificatorsStrength,
    /// Subset of signifiedHouses reached at grade A or B (levels L1 and L2). These are the houses a KP reading acts on for this period; the rest are supporting connections.
    #[serde(rename = "strongHouses")]
    pub strong_houses: Vec<i64>,
    /// KP sub lord of this planet, the 1 of 249 subdivision its longitude falls in, one of the 9 grahas. The star lord says WHAT results the period gives, the sub lord says WHETHER they materialize, so KP judgement checks both.
    #[serde(rename = "subLord", skip_serializing_if = "Option::is_none")]
    pub sub_lord: Option<String>,
}
/// How firmly this lord is tied to the houses it signifies, on the KP A to D significator grading. Reproducible from the significator levels alone, in two steps. STEP 1, per house keep only the strongest level: a planet routinely reaches the same house at more than one level, for example its star lord occupies house 11 and it also owns house 11, and KP cites a significator by its best connection, so that house counts once at grade A. This is why signifiedHouses is shorter than the four level arrays concatenated, and omitting it is what makes a hand calculation disagree. STEP 2, average the surviving weights: each house contributes 100, 75, 50 or 25 for grade A, B, C or D, and the mean is the score. Worked example, a lord signifying house 11 at level 1, house 6 at level 2 and house 2 at level 4 scores (100 + 75 + 25) / 3 = 66.7, which lands in band B because the band edges are the midpoints 87.5, 62.5 and 37.5. The score says how firmly the lord is connected, never whether the houses are favourable, which depends on the matter being judged.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponseAntardashaSignificatorsStrength {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    pub grade: GetCurrentDashaResponseAntardashaSignificatorsStrengthGrade,
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    pub label: GetCurrentDashaResponseAntardashaSignificatorsStrengthLabel,
    /// Mean KP percentage weight across signifiedHouses, each house counted at its strongest level (A 100, B 75, C 50, D 25). A mean rather than a total, so signifying many houses weakly does not outrank signifying two houses at grade A.
    pub score: f64,
}
string_enum! {
    /// Plain-language form of grade: "very-strong" for A, "strong" for B, "moderate" for C, "weak" for D. Says how firmly this lord is connected to the houses it signifies, NOT whether those houses are favourable, which depends on the matter being judged.
    GetCurrentDashaResponseAntardashaSignificatorsStrengthLabel {
        VeryStrong = "very-strong",
        Strong = "strong",
        Moderate = "moderate",
        Weak = "weak",
    }
}
string_enum! {
    /// Band the score falls in, on the standard KP significator grading: A planets in the constellation of the occupant, B occupants, C planets in the constellation of the house owner, D the house owner. Band edges are the midpoints between the four weights.
    GetCurrentDashaResponseAntardashaSignificatorsStrengthGrade {
        A = "A",
        B = "B",
        C = "C",
        D = "D",
    }
}
/// KP 4-level significator breakdown showing which houses (1-12) this planet signifies at each strength tier. L1 is strongest, L4 is weakest.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaResponseAntardashaSignificatorsSignifies {
    /// Level 1, the strongest signification (grade A). Houses influenced because this planet sits in the nakshatra (star) of a planet occupying those houses. For Rahu and Ketu, also includes the L1 houses of their agent planets (conjoined, aspecting, sign lord).
    #[serde(rename = "L1")]
    pub l1: Vec<i64>,
    /// Level 2 (grade B). The house this planet physically occupies. For Rahu and Ketu, also includes houses occupied by their agent planets.
    #[serde(rename = "L2")]
    pub l2: Vec<i64>,
    /// Level 3 (grade C). Houses influenced because this planet sits in the nakshatra of the sign lord (owner) of those houses. For Rahu and Ketu, also includes the L3 houses of their agent planets.
    #[serde(rename = "L3")]
    pub l3: Vec<i64>,
    /// Level 4, the weakest signification (grade D). Houses this planet rules by zodiac sign ownership, up to 2 for Sun through Saturn and 3 where a sign is intercepted. Rahu and Ketu own no sign, so their L4 comes entirely from their agent planets.
    #[serde(rename = "L4")]
    pub l4: Vec<i64>,
}
string_enum! {
    /// Ruling graha of this Vimshottari dasha period. One of 9 planets in the Ketu-Venus-Sun-Moon-Mars-Rahu-Jupiter-Saturn-Mercury sequence.
    GetCurrentDashaResponseAntardashaPlanet {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Parent Mahadasha lord under which this Antardasha sub-period runs.
    GetCurrentDashaResponseAntardashaMahadashaLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Request body of `getCurrentDasha`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCurrentDashaRequest {
    /// Ayanamsa system used to place the birth Moon in its nakshatra, which sets every dasha start and end date. "lahiri" uses Lahiri/Chitrapaksha, the traditional Vedic standard, and is the default. "kp-newcomb" uses the KP-Newcomb dynamic formula, matching Krishnamurti Paddhati software. "kp-old" uses the Krishnamurti original table from KP Reader-1. "raman" uses the B.V. Raman ayanamsa, the second frame traditional Indian software commonly offers beside Lahiri. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. Switching frames shifts every dasha boundary by weeks, so pick the one your reference software uses.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<GetCurrentDashaRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// ISO 8601 datetime (YYYY-MM-DDTHH:MM:SS) to read the running periods at, for a reading prepared for a future day, a backtest, or a chart cast for a past moment. Defaults to the current instant. Interpreted as local time in the request timezone (a trailing Z is accepted but ignored); with timezone 0 it is UTC.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub datetime: Option<String>,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Lunar node type for Rahu and Ketu, used ONLY when "significators" is true. Dasha dates themselves come from the Moon and never move with this field. "mean" uses the smooth mean node (traditional default). "true" uses the osculating node, which swings up to 1.5 degrees either side of mean over a 173-day cycle and can therefore change which house or star a node falls in. Defaults to "mean".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<GetCurrentDashaRequestNodeType>,
    /// Set true to attach the KP significators of each period lord: its star lord, sub lord, occupied house, the houses it signifies at levels L1 to L4, and a strength grade. Off by default, so responses stay exactly as they are for clients that only need dates. Requires the birth latitude and longitude, since significators are read off a Placidus house chart, and uses the same ayanamsa frame selected above.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub significators: Option<bool>,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetCurrentDashaRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetCurrentDashaRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node type for Rahu and Ketu, used ONLY when "significators" is true. Dasha dates themselves come from the Moon and never move with this field. "mean" uses the smooth mean node (traditional default). "true" uses the osculating node, which swings up to 1.5 degrees either side of mean over a 173-day cycle and can therefore change which house or star a node falls in. Defaults to "mean".
    GetCurrentDashaRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// Ayanamsa system used to place the birth Moon in its nakshatra, which sets every dasha start and end date. "lahiri" uses Lahiri/Chitrapaksha, the traditional Vedic standard, and is the default. "kp-newcomb" uses the KP-Newcomb dynamic formula, matching Krishnamurti Paddhati software. "kp-old" uses the Krishnamurti original table from KP Reader-1. "raman" uses the B.V. Raman ayanamsa, the second frame traditional Indian software commonly offers beside Lahiri. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. Switching frames shifts every dasha boundary by weeks, so pick the one your reference software uses.
    GetCurrentDashaRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Path and query parameters of `getCurrentDasha`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetCurrentDashaParams {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<GetCurrentDashaParamsFocus>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetCurrentDashaParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetCurrentDashaParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    GetCurrentDashaParamsFocus {
        General = "general",
        Finance = "finance",
    }
}
/// Response body of `getCrystalsByZodiac`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCrystalsByZodiacResponse {
    /// Crystal summaries for this zodiac sign. Call /crystals/{id} for full healing properties.
    pub crystals: Vec<GetCrystalsByZodiacResponseCrystalsItem>,
    /// Maximum crystals returned per page.
    pub limit: f64,
    /// Number of crystals skipped.
    pub offset: f64,
    /// The zodiac sign that was queried.
    pub sign: String,
    /// Total number of crystals associated with this zodiac sign.
    pub total: f64,
}
/// One entry of `crystals`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCrystalsByZodiacResponseCrystalsItem {
    /// Primary colors of this crystal variety. Null when color data is unavailable.
    pub colors: Option<Vec<String>>,
    /// URL-safe crystal identifier for detail lookup.
    pub id: String,
    /// URL to crystal photograph for visual identification.
    #[serde(rename = "imageUrl")]
    pub image_url: Option<String>,
    /// Crystal display name.
    pub name: String,
}
/// Path and query parameters of `getCrystalsByZodiac`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCrystalsByZodiacParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetCrystalsByZodiacParamsLang>,
    /// Maximum items to return per page. Range: 1-30, default 20.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
    /// Zodiac sign name, case-insensitive (e.g., pisces, Pisces, PISCES all work). Valid: aries, taurus, gemini, cancer, leo, virgo, libra, scorpio, sagittarius, capricorn, aquarius, pisces.
    pub sign: GetCrystalsByZodiacParamsSign,
}
string_enum! {
    /// Zodiac sign name, case-insensitive (e.g., pisces, Pisces, PISCES all work). Valid: aries, taurus, gemini, cancer, leo, virgo, libra, scorpio, sagittarius, capricorn, aquarius, pisces.
    GetCrystalsByZodiacParamsSign {
        Aries = "aries",
        Taurus = "taurus",
        Gemini = "gemini",
        Cancer = "cancer",
        Leo = "leo",
        Virgo = "virgo",
        Libra = "libra",
        Scorpio = "scorpio",
        Sagittarius = "sagittarius",
        Capricorn = "capricorn",
        Aquarius = "aquarius",
        Pisces = "pisces",
    }
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetCrystalsByZodiacParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getCrystalsByElement`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCrystalsByElementResponse {
    /// Crystal summaries for this element. Call /crystals/{id} for full healing properties.
    pub crystals: Vec<GetCrystalsByElementResponseCrystalsItem>,
    /// The element that was queried.
    pub element: String,
    /// Maximum crystals returned per page.
    pub limit: f64,
    /// Number of crystals skipped.
    pub offset: f64,
    /// Total number of crystals associated with this element.
    pub total: f64,
}
/// One entry of `crystals`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCrystalsByElementResponseCrystalsItem {
    /// Primary colors of this crystal variety. Null when color data is unavailable.
    pub colors: Option<Vec<String>>,
    /// URL-safe crystal identifier for detail lookup.
    pub id: String,
    /// URL to crystal photograph for visual identification.
    #[serde(rename = "imageUrl")]
    pub image_url: Option<String>,
    /// Crystal display name.
    pub name: String,
}
/// Path and query parameters of `getCrystalsByElement`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCrystalsByElementParams {
    /// Element name, case-insensitive (e.g., water, Water, WATER all work). Valid: Earth, Water, Fire, Air, Storm.
    pub element: GetCrystalsByElementParamsElement,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetCrystalsByElementParamsLang>,
    /// Maximum items to return per page. Range: 1-30, default 20.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetCrystalsByElementParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Element name, case-insensitive (e.g., water, Water, WATER all work). Valid: Earth, Water, Fire, Air, Storm.
    GetCrystalsByElementParamsElement {
        Earth = "Earth",
        Water = "Water",
        Fire = "Fire",
        Air = "Air",
        Storm = "Storm",
    }
}
/// Response body of `getCrystalsByChakra`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCrystalsByChakraResponse {
    /// The chakra energy center that was queried.
    pub chakra: String,
    /// Crystal summaries for this chakra. Call /crystals/{id} for full healing properties.
    pub crystals: Vec<GetCrystalsByChakraResponseCrystalsItem>,
    /// Maximum crystals returned per page.
    pub limit: f64,
    /// Number of crystals skipped.
    pub offset: f64,
    /// Total number of crystals associated with this chakra.
    pub total: f64,
}
/// One entry of `crystals`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCrystalsByChakraResponseCrystalsItem {
    /// Primary colors of this crystal variety. Null when color data is unavailable.
    pub colors: Option<Vec<String>>,
    /// URL-safe crystal identifier for detail lookup.
    pub id: String,
    /// URL to crystal photograph for visual identification.
    #[serde(rename = "imageUrl")]
    pub image_url: Option<String>,
    /// Crystal display name.
    pub name: String,
}
/// Path and query parameters of `getCrystalsByChakra`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCrystalsByChakraParams {
    /// Chakra name, case-insensitive (e.g., heart, Heart, HEART all work). Valid: Root, Sacral, Solar Plexus, Heart, Throat, Third Eye, Crown.
    pub chakra: GetCrystalsByChakraParamsChakra,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetCrystalsByChakraParamsLang>,
    /// Maximum items to return per page. Range: 1-30, default 20.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetCrystalsByChakraParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Chakra name, case-insensitive (e.g., heart, Heart, HEART all work). Valid: Root, Sacral, Solar Plexus, Heart, Throat, Third Eye, Crown.
    GetCrystalsByChakraParamsChakra {
        Root = "Root",
        Sacral = "Sacral",
        SolarPlexus = "Solar Plexus",
        Heart = "Heart",
        Throat = "Throat",
        ThirdEye = "Third Eye",
        Crown = "Crown",
    }
}
/// Response body of `getCrystal`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCrystalResponse {
    /// Positive affirmation aligned with this crystal energy. Use for meditation, journaling, or daily affirmation features.
    pub affirmation: String,
    /// Birth month (1-12) if this crystal is a traditional birthstone. Null if not a birthstone. January is 1, December is 12.
    #[serde(rename = "birthMonth")]
    pub birth_month: Option<f64>,
    /// Chakra energy centers this crystal resonates with. One of: Root, Sacral, Solar Plexus, Heart, Throat, Third Eye, Crown.
    pub chakras: Vec<String>,
    /// Primary colors of this crystal variety. Null when color data is unavailable. Useful for color-based crystal selection and filtering.
    pub colors: Option<Vec<String>>,
    /// Overview of the crystal covering its primary healing purpose, spiritual significance, and key benefits.
    pub description: String,
    /// Elemental associations (Earth, Water, Fire, Air, Storm) connecting the crystal to natural forces and energy types. Null when elemental data is unavailable.
    pub elements: Option<Vec<String>>,
    /// Mohs hardness scale rating (1-10). Indicates durability for jewelry use. Quartz family is 7, Diamond is 10, Selenite is 2.
    pub hardness: f64,
    /// URL-safe identifier for the crystal.
    pub id: String,
    /// URL to a high-quality crystal photograph. Use for visual crystal guides, product listings, and crystal identification features.
    #[serde(rename = "imageUrl")]
    pub image_url: Option<String>,
    /// Keywords capturing the core healing properties and spiritual themes of this crystal. The count varies by stone, from a single keyword up to twenty. Null when keyword data is unavailable.
    pub keywords: Option<Vec<String>>,
    /// Detailed healing interpretations across three areas: spiritual and metaphysical, emotional and psychological, and physical body associations.
    pub meaning: GetCrystalResponseMeaning,
    /// Display name of the crystal or healing stone.
    pub name: String,
    /// Numerological vibration number linking this crystal to numerology meanings. Connects crystal healing with numerology practice.
    #[serde(rename = "numericalVibration")]
    pub numerical_vibration: f64,
    /// Crystal identifiers that pair well with this stone for enhanced healing combinations. Use for crystal grid and pairing recommendations.
    #[serde(rename = "pairsWith")]
    pub pairs_with: Vec<String>,
    /// Ruling planet or celestial body associated with this crystal in astrological tradition. Null when planetary association is unavailable.
    pub planet: Option<String>,
    /// Zodiac signs this crystal is traditionally associated with. Null when zodiac data is unavailable. Useful for personalized crystal recommendations based on birth chart.
    #[serde(rename = "zodiacSigns")]
    pub zodiac_signs: Option<Vec<String>>,
}
/// Detailed healing interpretations across three areas: spiritual and metaphysical, emotional and psychological, and physical body associations.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCrystalResponseMeaning {
    /// Emotional healing properties including stress relief, relationship support, and emotional balance benefits.
    pub emotional: String,
    /// Physical healing associations traditionally attributed to this crystal in crystal healing practice. Null when physical healing data is unavailable.
    pub physical: Option<String>,
    /// Spiritual and metaphysical healing properties including energy work, meditation benefits, and higher consciousness connections. Null when spiritual interpretation is unavailable.
    pub spiritual: Option<String>,
}
/// Path and query parameters of `getCrystal`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCrystalParams {
    /// URL-safe crystal identifier, case-insensitive (e.g., "amethyst", "Amethyst", "rose-quartz" all resolve). Must match an entry in the database.
    pub id: String,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetCrystalParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetCrystalParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getCrystalPairings`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCrystalPairingsResponse {
    /// Number of recommended crystal pairings.
    pub count: f64,
    /// The crystal identifier that pairings were requested for.
    pub crystal: String,
    /// Display name of the source crystal.
    pub name: String,
    /// Crystals recommended for use alongside the source crystal for synergistic healing.
    pub pairings: Vec<GetCrystalPairingsResponsePairingsItem>,
}
/// One entry of `pairings`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCrystalPairingsResponsePairingsItem {
    /// Chakra associations for the paired crystal.
    pub chakras: Vec<String>,
    /// Brief overview of the paired crystal.
    pub description: String,
    /// URL-safe identifier for the paired crystal.
    pub id: String,
    /// URL to paired crystal photograph.
    #[serde(rename = "imageUrl")]
    pub image_url: Option<String>,
    /// Healing property keywords for the paired crystal. Null when keyword data is unavailable.
    pub keywords: Option<Vec<String>>,
    /// Paired crystal display name.
    pub name: String,
}
/// Path and query parameters of `getCrystalPairings`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCrystalPairingsParams {
    /// URL-safe crystal identifier to find pairings for, case-insensitive (e.g., "amethyst", "Amethyst", "rose-quartz" all resolve).
    pub id: String,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetCrystalPairingsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetCrystalPairingsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getCriticalDays`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCriticalDaysResponse {
    /// Birth date used for this calculation.
    #[serde(rename = "birthDate")]
    pub birth_date: String,
    /// All critical day events in the range, sorted by date.
    #[serde(rename = "criticalDays")]
    pub critical_days: Vec<GetCriticalDaysResponseCriticalDaysItem>,
    /// Dates where 2 or more primary cycles cross zero simultaneously. These are particularly significant days requiring extra caution.
    #[serde(rename = "doubleCriticalDays")]
    pub double_critical_days: Vec<String>,
    /// End of the search range.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Start of the search range.
    #[serde(rename = "startDate")]
    pub start_date: String,
    /// Total count of critical day events in the range. A double critical day counts as two events.
    #[serde(rename = "totalCriticalDays")]
    pub total_critical_days: f64,
    /// Date where all 3 primary cycles cross zero simultaneously. Extremely rare event. Null if none found in range.
    #[serde(rename = "tripleCriticalDay")]
    pub triple_critical_day: Option<String>,
}
/// One entry of `criticalDays`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCriticalDaysResponseCriticalDaysItem {
    /// Advisory text explaining the significance of this critical day and recommended precautions.
    pub advisory: String,
    /// Which primary cycle crosses zero on this date. One of: physical, emotional, intellectual. Only the three primary cycles are scanned; the secondary and composite cycles are not.
    pub cycle: GetCriticalDaysResponseCriticalDaysItemCycle,
    /// Date of the zero crossing (YYYY-MM-DD).
    pub date: String,
    /// Whether the cycle is rising through zero (ascending) or falling through zero (descending).
    pub direction: GetCriticalDaysResponseCriticalDaysItemDirection,
    /// Cycle period in days.
    pub period: f64,
    /// How many primary cycles are critical on this date. One of: single, double, triple.
    pub severity: GetCriticalDaysResponseCriticalDaysItemSeverity,
}
string_enum! {
    /// How many primary cycles are critical on this date. One of: single, double, triple.
    GetCriticalDaysResponseCriticalDaysItemSeverity {
        Single = "single",
        Double = "double",
        Triple = "triple",
    }
}
string_enum! {
    /// Whether the cycle is rising through zero (ascending) or falling through zero (descending).
    GetCriticalDaysResponseCriticalDaysItemDirection {
        Ascending = "ascending",
        Descending = "descending",
    }
}
string_enum! {
    /// Which primary cycle crosses zero on this date. One of: physical, emotional, intellectual. Only the three primary cycles are scanned; the secondary and composite cycles are not.
    GetCriticalDaysResponseCriticalDaysItemCycle {
        Physical = "physical",
        Emotional = "emotional",
        Intellectual = "intellectual",
    }
}
/// Path and query parameters of `getCriticalDays`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetCriticalDaysParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetCriticalDaysParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetCriticalDaysParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getCompoundNumber`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCompoundNumberResponse {
    /// Cheiro interpretation of the hidden influence carried by this compound number.
    pub meaning: String,
    /// Classical symbolic title from Cheiro, or null when none is given.
    pub name: Option<String>,
    /// Overall tenor of the number. "mixed" marks conditional numbers, fortunate only with a favorable single number or in one domain.
    pub nature: GetCompoundNumberResponseNature,
    /// The compound number (10 to 52).
    pub number: f64,
    /// The single-digit root the compound reduces to (1 to 9).
    pub root: f64,
    /// For numbers 33 to 52, the lower compound in the same series whose meaning this number shares.
    #[serde(rename = "sameAs", skip_serializing_if = "Option::is_none")]
    pub same_as: Option<f64>,
}
string_enum! {
    /// Overall tenor of the number. "mixed" marks conditional numbers, fortunate only with a favorable single number or in one domain.
    GetCompoundNumberResponseNature {
        Fortunate = "fortunate",
        Unfortunate = "unfortunate",
        Mixed = "mixed",
    }
}
/// Path and query parameters of `getCompoundNumber`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCompoundNumberParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetCompoundNumberParamsLang>,
    /// Compound number from 10 to 52.
    pub number: String,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetCompoundNumberParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getCitiesByCountry`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCitiesByCountryResponse {
    /// Cities for the current page, sorted by population (largest first).
    pub cities: Vec<GetCitiesByCountryResponseCitiesItem>,
    /// Page size used for this response.
    pub limit: f64,
    /// Number of cities skipped. Use with limit for pagination.
    pub offset: f64,
    /// Total number of places available for this country across all pages.
    pub total: f64,
}
/// Geographic location with coordinates, timezone, and UTC offset. Every field is designed for direct use as input parameters in astrology, horoscope, and location-dependent API calculations.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCitiesByCountryResponseCitiesItem {
    /// City name as commonly used. Matches the local or internationally recognized name for the location.
    pub city: String,
    /// Full country name in English.
    pub country: String,
    /// ISO 3166-1 alpha-2 country code. Use for filtering cities by country or building country-specific location pickers.
    pub iso2: String,
    /// Geographic latitude in decimal degrees (-90 to 90). Pass directly to birth chart, natal chart, horoscope, synastry, transit, kundli, and panchang API endpoints as the latitude parameter.
    pub latitude: f64,
    /// Geographic longitude in decimal degrees (-180 to 180). Pass directly to astrology, horoscope, and panchang API endpoints alongside latitude.
    pub longitude: f64,
    /// Population estimate for the place. Breaks ties between results of equal match quality, so among several places matching equally well the largest leads. It never outranks a better match, which is why a small town still wins when its name is typed exactly. May be 0 for a hamlet or administrative seat that carries no published figure.
    pub population: f64,
    /// State, province, canton, or administrative region. Show it whenever more than one result comes back: it is what separates Richfield, Utah from Richfield, Minnesota, and the six US Springfields from each other. Empty for the small number of places with no administrative division recorded.
    pub province: String,
    /// IANA timezone identifier following the tz database standard (e.g. Europe/Berlin, America/New_York, Asia/Tokyo). Always present. Pass THIS, not the numeric offset, into any chart or panchang request for a past date: the calculation endpoints resolve it to the offset that was actually in force on that date, including historical daylight saving. Also works directly with JavaScript Date, Luxon, day.js, or any date library.
    pub timezone: String,
    /// UTC offset in decimal hours for TODAY at this place, already adjusted for daylight saving. Convenient for displaying local time now. For a birth date or any past date use the `timezone` field instead, since the offset in force then may differ. Examples: 1 for CET, 2 for CEST, -5 for EST, 5.5 for IST, 5.75 for Nepal.
    #[serde(rename = "utcOffset")]
    pub utc_offset: f64,
}
/// Response body of `getChoghadiya`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetChoghadiyaResponse {
    /// Calendar date the choghadiya muhurta table was computed for, YYYY-MM-DD, echoed back from the request. The day periods run from that date sunrise to its sunset, and the night periods run on to the next sunrise.
    pub date: String,
    /// 8 daytime choghadiya periods (sunrise to sunset)
    #[serde(rename = "dayChoghadiya")]
    pub day_choghadiya: Vec<GetChoghadiyaResponseDayChoghadiyaItem>,
    /// 8 nighttime choghadiya periods (sunset to next sunrise)
    #[serde(rename = "nightChoghadiya")]
    pub night_choghadiya: Vec<GetChoghadiyaResponseNightChoghadiyaItem>,
}
/// One entry of `nightChoghadiya`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetChoghadiyaResponseNightChoghadiyaItem {
    /// Auspiciousness of this period. Good periods (Amrit, Shubh, Labh, Char) are suitable for important activities. Bad periods (Udveg, Rog, Kaal) should be avoided.
    pub effect: GetChoghadiyaResponseNightChoghadiyaItemEffect,
    /// Period end time in ISO 8601 format. Each Choghadiya period is one-eighth of the day or night duration.
    pub end: String,
    /// Ruling planet of this Choghadiya period. Planet determines the quality and suitability of activities during this muhurta.
    pub lord: String,
    /// Choghadiya muhurta name. Auspicious: Amrit (Moon), Shubh (Jupiter), Labh (Mercury), Char (Venus). Inauspicious: Udveg (Sun), Rog (Mars), Kaal (Saturn).
    pub name: GetChoghadiyaResponseNightChoghadiyaItemName,
    /// Period start time in ISO 8601 format. Timezone-adjusted based on input timezone offset.
    pub start: String,
}
string_enum! {
    /// Choghadiya muhurta name. Auspicious: Amrit (Moon), Shubh (Jupiter), Labh (Mercury), Char (Venus). Inauspicious: Udveg (Sun), Rog (Mars), Kaal (Saturn).
    GetChoghadiyaResponseNightChoghadiyaItemName {
        Udveg = "Udveg",
        Amrit = "Amrit",
        Rog = "Rog",
        Labh = "Labh",
        Shubh = "Shubh",
        Char = "Char",
        Kaal = "Kaal",
    }
}
string_enum! {
    /// Auspiciousness of this period. Good periods (Amrit, Shubh, Labh, Char) are suitable for important activities. Bad periods (Udveg, Rog, Kaal) should be avoided.
    GetChoghadiyaResponseNightChoghadiyaItemEffect {
        Good = "Good",
        Bad = "Bad",
    }
}
/// One entry of `dayChoghadiya`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetChoghadiyaResponseDayChoghadiyaItem {
    /// Auspiciousness of this period. Good periods (Amrit, Shubh, Labh, Char) are suitable for important activities. Bad periods (Udveg, Rog, Kaal) should be avoided.
    pub effect: GetChoghadiyaResponseDayChoghadiyaItemEffect,
    /// Period end time in ISO 8601 format. Each Choghadiya period is one-eighth of the day or night duration.
    pub end: String,
    /// Ruling planet of this Choghadiya period. Planet determines the quality and suitability of activities during this muhurta.
    pub lord: String,
    /// Choghadiya muhurta name. Auspicious: Amrit (Moon), Shubh (Jupiter), Labh (Mercury), Char (Venus). Inauspicious: Udveg (Sun), Rog (Mars), Kaal (Saturn).
    pub name: GetChoghadiyaResponseDayChoghadiyaItemName,
    /// Period start time in ISO 8601 format. Timezone-adjusted based on input timezone offset.
    pub start: String,
}
string_enum! {
    /// Choghadiya muhurta name. Auspicious: Amrit (Moon), Shubh (Jupiter), Labh (Mercury), Char (Venus). Inauspicious: Udveg (Sun), Rog (Mars), Kaal (Saturn).
    GetChoghadiyaResponseDayChoghadiyaItemName {
        Udveg = "Udveg",
        Amrit = "Amrit",
        Rog = "Rog",
        Labh = "Labh",
        Shubh = "Shubh",
        Char = "Char",
        Kaal = "Kaal",
    }
}
string_enum! {
    /// Auspiciousness of this period. Good periods (Amrit, Shubh, Labh, Char) are suitable for important activities. Bad periods (Udveg, Rog, Kaal) should be avoided.
    GetChoghadiyaResponseDayChoghadiyaItemEffect {
        Good = "Good",
        Bad = "Bad",
    }
}
/// Request body of `getChoghadiya`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetChoghadiyaRequest {
    /// Date in YYYY-MM-DD format. A single-digit month or day is accepted and zero-padded (2026-3-5 becomes 2026-03-05). Impossible calendar dates are rejected. Calculations that read planetary positions support 1550-01-02 to 2650-01-22; outside that span they answer 400 with code date_out_of_range, and a calculation that reads a window around the date (a sunrise search, a run of days) may answer the same 400 for a date within a few days of either end.
    pub date: String,
    /// Observer latitude in decimal degrees. Determines sunrise and sunset times which define day/night boundaries for muhurta calculations.
    pub latitude: f64,
    /// Observer longitude in decimal degrees. Affects local time calculations for sunrise, sunset, and muhurta period boundaries.
    pub longitude: f64,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Used for accurate sunrise/sunset calculation and output time formatting. Essential for correct Choghadiya periods outside IST. Defaults to 5.5 (IST).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetChoghadiyaRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Used for accurate sunrise/sunset calculation and output time formatting. Essential for correct Choghadiya periods outside IST. Defaults to 5.5 (IST).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetChoghadiyaRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
/// Path and query parameters of `getCenter`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCenterParams {
    /// Center id. One of head, ajna, throat, g, heart, sacral, solar-plexus, spleen, root.
    pub id: GetCenterParamsId,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetCenterParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetCenterParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Center id. One of head, ajna, throat, g, heart, sacral, solar-plexus, spleen, root.
    GetCenterParamsId {
        Head = "head",
        Ajna = "ajna",
        Throat = "throat",
        G = "g",
        Heart = "heart",
        Sacral = "sacral",
        SolarPlexus = "solar-plexus",
        Spleen = "spleen",
        Root = "root",
    }
}
/// Path and query parameters of `getCard`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCardParams {
    /// Card identifier. Major arcana: "fool", "magician", "death". Minor arcana: "ace-of-cups", "seven-of-wands", "queen-of-swords", "king-of-pentacles". Casing and separators are flexible, so "Fool" and "ACE_OF_CUPS" both resolve, and a leading definite article is optional, so "the-star" resolves to "star". The canonical form, and the one every response echoes, is kebab-case with no article.
    pub id: String,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetCardParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetCardParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getBirthstones`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetBirthstonesResponse {
    /// Birthstone crystals for this month. Call /crystals/{id} for full healing properties.
    pub crystals: Vec<GetBirthstonesResponseCrystalsItem>,
    /// The month number that was queried (1-12).
    pub month: f64,
    /// Full name of the queried month.
    #[serde(rename = "monthName")]
    pub month_name: String,
    /// Number of birthstone crystals for this month.
    pub total: f64,
}
/// One entry of `crystals`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetBirthstonesResponseCrystalsItem {
    /// Primary colors of this crystal variety. Null when color data is unavailable.
    pub colors: Option<Vec<String>>,
    /// URL-safe crystal identifier for detail lookup.
    pub id: String,
    /// URL to crystal photograph for visual identification.
    #[serde(rename = "imageUrl")]
    pub image_url: Option<String>,
    /// Crystal display name.
    pub name: String,
}
/// Path and query parameters of `getBirthstones`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetBirthstonesParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetBirthstonesParamsLang>,
    /// Birth month as a number from 1 (January) to 12 (December).
    pub month: i64,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetBirthstonesParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getBasicPanchang`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetBasicPanchangResponse {
    /// Karana (half-tithi) information. Fourth panchang element, changes twice per tithi.
    pub karana: GetBasicPanchangResponseKarana,
    /// Sidereal longitude of the Moon in degrees (0-360). Moon moves ~13 degrees per day through the nakshatras.
    #[serde(rename = "moonLongitude")]
    pub moon_longitude: f64,
    /// Nakshatra (lunar mansion) information with interpretations
    pub nakshatra: GetBasicPanchangResponseNakshatra,
    /// Sidereal longitude of the Sun in degrees (0-360). Used for tithi and yoga calculations.
    #[serde(rename = "sunLongitude")]
    pub sun_longitude: f64,
    /// Lunar day (tithi) information with interpretations. Central panchang element for determining auspicious timings.
    pub tithi: GetBasicPanchangResponseTithi,
    /// Nitya Yoga information. Yoga is the third panchang element, derived from combined Sun-Moon longitude.
    pub yoga: GetBasicPanchangResponseYoga,
}
/// Nitya Yoga information. Yoga is the third panchang element, derived from combined Sun-Moon longitude.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetBasicPanchangResponseYoga {
    /// Characteristics and auspiciousness of this yoga for activity planning.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub characteristics: Option<String>,
    /// Sanskrit name of the Nitya Yoga. One of 27 yogas formed by combined Sun-Moon motion, each with distinct auspiciousness.
    pub name: String,
    /// Nitya Yoga index (1-27). Calculated from the sum of Sun and Moon sidereal longitudes divided by 13 degrees 20 minutes.
    pub number: i64,
}
/// Lunar day (tithi) information with interpretations. Central panchang element for determining auspicious timings.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetBasicPanchangResponseTithi {
    /// Presiding deity of this tithi from Vedic tradition.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deity: Option<String>,
    /// Elemental quality of this tithi (Fire, Earth, Air, Water, Ether).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub element: Option<String>,
    /// Sanskrit name of the tithi (lunar day). One of 30 tithis in the lunar month cycle.
    pub name: String,
    /// Tithi number (1-30). 1-15 are Shukla Paksha (waxing), 16-30 are Krishna Paksha (waning). Purnima is 15, Amavasya is 30.
    pub number: i64,
    /// Lunar fortnight: Shukla (waxing, bright half) or Krishna (waning, dark half).
    pub paksha: GetBasicPanchangResponseTithiPaksha,
    /// Percentage of the current tithi elapsed (0-100). Useful for determining tithi strength and transition proximity.
    pub percent: f64,
    /// Planetary ruler of this tithi. Influences the day energy and activities.
    #[serde(rename = "rulingPlanet", skip_serializing_if = "Option::is_none")]
    pub ruling_planet: Option<String>,
}
string_enum! {
    /// Lunar fortnight: Shukla (waxing, bright half) or Krishna (waning, dark half).
    GetBasicPanchangResponseTithiPaksha {
        Shukla = "Shukla",
        Krishna = "Krishna",
    }
}
/// Nakshatra (lunar mansion) information with interpretations
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetBasicPanchangResponseNakshatra {
    /// Personality traits and behavioral tendencies when the Moon occupies this nakshatra. Useful for daily panchang readings.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub characteristics: Option<String>,
    /// Presiding deity of this nakshatra from Vedic mythology. Influences spiritual qualities and karmic themes.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deity: Option<String>,
    /// Planetary ruler of this nakshatra. Determines Vimshottari dasha lord and influences nakshatra characteristics.
    pub lord: String,
    /// Sanskrit name of the nakshatra (lunar mansion). One of 27 nakshatras spanning the zodiac belt.
    pub name: String,
    /// Nakshatra index (1-27) in the zodiac sequence starting from Ashwini. Each nakshatra spans 13 degrees 20 minutes.
    pub number: i64,
    /// Pada (quarter, 1-4) of the nakshatra. Each nakshatra has 4 padas spanning 3 degrees 20 minutes each. Determines the navamsha sign and fine-tunes nakshatra predictions.
    pub pada: i64,
    /// Traditional symbol representing this nakshatra. Reflects core energy and life themes.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub symbol: Option<String>,
}
/// Karana (half-tithi) information. Fourth panchang element, changes twice per tithi.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetBasicPanchangResponseKarana {
    /// Activity suitability and characteristics of this karana for muhurta selection.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub characteristics: Option<String>,
    /// Sanskrit name of the karana. 7 movable karanas (Bava through Naga) repeat 8 times, plus 4 fixed karanas.
    pub name: String,
    /// Karana index. There are 11 karanas total (4 fixed + 7 movable) cycling through 60 half-tithis per lunar month.
    pub number: i64,
    /// Karana type: Movable (repeating, generally auspicious) or Fixed (occur once per month).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}
/// Request body of `getBasicPanchang`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetBasicPanchangRequest {
    /// Date in YYYY-MM-DD format. Panchang elements (Tithi, Nakshatra, Yoga, Karana) are calculated for this date.
    pub date: String,
    /// Observer latitude in decimal degrees. Determines sunrise/sunset times which define the Vara (weekday) and muhurta boundaries.
    pub latitude: f64,
    /// Observer longitude in decimal degrees. Affects local time calculations for sunrise/sunset-dependent panchang elements.
    pub longitude: f64,
    /// Time in HH:MM:SS format (24-hour). Determines the exact Moon and Sun positions for tithi and nakshatra calculation.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5 (IST).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<GetBasicPanchangRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5 (IST).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GetBasicPanchangRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
/// Path and query parameters of `getBasicPanchang`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetBasicPanchangParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetBasicPanchangParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetBasicPanchangParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getBaguaSector`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetBaguaSectorResponse {
    /// Colours of the phase this sector carries, for activating it. Derived from the element rather than assigned per sector, so they cannot disagree with the element beside them.
    pub colors: Vec<String>,
    /// Compass sector of the palace, taken from the trigram that sits there. Absent on the centre palace, which has no direction.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub direction: Option<String>,
    /// The trigram that sits in this direction under the Earlier Heaven arrangement, read for the symbolic relation between opposite sectors. A different question from the Later Heaven trigram, not a competing answer. Absent on the centre palace.
    #[serde(rename = "earlierHeavenTrigram", skip_serializing_if = "Option::is_none")]
    pub earlier_heaven_trigram: Option<GetBaguaSectorResponseEarlierHeavenTrigram>,
    /// Five phase of this entry: Wood, Fire, Earth, Metal or Water. Always English so it stays safe to compare against and to key styling on. The full cycles live on the Chinese astrology elements endpoint.
    pub element: String,
    /// What this sector governs, in a few words.
    pub focus: String,
    /// Life area id: career, knowledge, family, wealth, fame, love, children, helpful-people or health. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees.
    pub id: String,
    /// What the sector governs and how to work with it.
    pub meaning: String,
    /// Display name of the life area. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Life area name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat name exactly. Never compare against this value.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Lo Shu number of the palace, 1 to 9. This is the same number the flying stars use, so a chart palace and a Bagua sector line up by it.
    pub number: f64,
    /// Palace of the Lo Shu grid: one of the eight compass sectors, or Center for the ninth. Always English, safe to compare against.
    pub palace: String,
    /// The Later Heaven trigram of the sector, which is the arrangement every compass reading and every flying star chart uses. Absent on the centre palace.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trigram: Option<GetBaguaSectorResponseTrigram>,
}
/// The Later Heaven trigram of the sector, which is the arrangement every compass reading and every flying star chart uses. Absent on the centre palace.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetBaguaSectorResponseTrigram {
    /// Three lines bottom to top, 1 for yang and 0 for yin. The Eight Mansions classification of any sector is decided by which of these three lines differ from your own trigram.
    pub binary: String,
    /// Chinese character for the trigram. Data, identical in every language.
    pub chinese: String,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against in code and against the same value on the I-Ching trigram endpoints.
    pub direction: String,
    /// Compass sector in the requested language, for display only, the same word the composed readings use. Present only when lang is set to a language other than English. Never compare against this value.
    #[serde(rename = "directionLocalized", skip_serializing_if = "Option::is_none")]
    pub direction_localized: Option<String>,
    /// Five phase of this entry: Wood, Fire, Earth, Metal or Water. Always English so it stays safe to compare against and to key styling on. The full cycles live on the Chinese astrology elements endpoint.
    pub element: String,
    /// Five phase name in the requested language, for display only. Present only when lang is set to a language other than English. Never compare against this value.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// English name of the trigram, byte identical to the English value the I-Ching trigram endpoints publish for this number. Always English here, whatever the lang parameter says, so it stays safe to compare against. Use nameLocalized for anything a reader sees.
    pub english: String,
    /// Family role of the trigram. Read alongside an affliction to know which member of the household a sector points at. Always English, and it carries no localized sibling: no vocabulary this package ships names the eight family roles.
    #[serde(rename = "familyMember")]
    pub family_member: String,
    /// Trigram name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat english exactly. Never compare against this value.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Trigram number, 1 to 8, the same identifier the I-Ching trigram endpoints use. It is a lookup key, not a ranking.
    pub number: f64,
    /// Tone-marked pinyin for the trigram. Data, identical in every language.
    pub pinyin: String,
    /// Unicode trigram symbol, for rendering a Bagua diagram without an icon set.
    pub symbol: String,
}
/// The trigram that sits in this direction under the Earlier Heaven arrangement, read for the symbolic relation between opposite sectors. A different question from the Later Heaven trigram, not a competing answer. Absent on the centre palace.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetBaguaSectorResponseEarlierHeavenTrigram {
    /// Three lines bottom to top, 1 for yang and 0 for yin. The Eight Mansions classification of any sector is decided by which of these three lines differ from your own trigram.
    pub binary: String,
    /// Chinese character for the trigram. Data, identical in every language.
    pub chinese: String,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against in code and against the same value on the I-Ching trigram endpoints.
    pub direction: String,
    /// Compass sector in the requested language, for display only, the same word the composed readings use. Present only when lang is set to a language other than English. Never compare against this value.
    #[serde(rename = "directionLocalized", skip_serializing_if = "Option::is_none")]
    pub direction_localized: Option<String>,
    /// Five phase of this entry: Wood, Fire, Earth, Metal or Water. Always English so it stays safe to compare against and to key styling on. The full cycles live on the Chinese astrology elements endpoint.
    pub element: String,
    /// Five phase name in the requested language, for display only. Present only when lang is set to a language other than English. Never compare against this value.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// English name of the trigram, byte identical to the English value the I-Ching trigram endpoints publish for this number. Always English here, whatever the lang parameter says, so it stays safe to compare against. Use nameLocalized for anything a reader sees.
    pub english: String,
    /// Family role of the trigram. Read alongside an affliction to know which member of the household a sector points at. Always English, and it carries no localized sibling: no vocabulary this package ships names the eight family roles.
    #[serde(rename = "familyMember")]
    pub family_member: String,
    /// Trigram name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat english exactly. Never compare against this value.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Trigram number, 1 to 8, the same identifier the I-Ching trigram endpoints use. It is a lookup key, not a ranking.
    pub number: f64,
    /// Tone-marked pinyin for the trigram. Data, identical in every language.
    pub pinyin: String,
    /// Unicode trigram symbol, for rendering a Bagua diagram without an icon set.
    pub symbol: String,
}
/// Path and query parameters of `getBaguaSector`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetBaguaSectorParams {
    /// Life area id. One of career, knowledge, family, wealth, fame, love, children, helpful-people, health.
    pub id: GetBaguaSectorParamsId,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetBaguaSectorParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetBaguaSectorParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Life area id. One of career, knowledge, family, wealth, fame, love, children, helpful-people, health.
    GetBaguaSectorParamsId {
        Career = "career",
        Knowledge = "knowledge",
        Family = "family",
        Wealth = "wealth",
        Fame = "fame",
        Love = "love",
        Children = "children",
        HelpfulPeople = "helpful-people",
        Health = "health",
    }
}
/// Path and query parameters of `getAztecTrecena`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAztecTrecenaParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetAztecTrecenaParamsLang>,
    /// Trecena number, 1 to 20. Trecena 1 opens on 1 Cipactli, trecena 2 on 1 Ocelotl, and each subsequent period opens thirteen signs further round the twenty.
    pub number: i64,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetAztecTrecenaParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `getAztecDaySign`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAztecDaySignParams {
    /// Day sign id, case-insensitive and punctuation-insensitive. One of cipactli, ehecatl, calli, cuetzpalin, coatl, miquiztli, mazatl, tochtli, atl, itzcuintli, ozomahtli, malinalli, acatl, ocelotl, cuauhtli, cozcacuauhtli, ollin, tecpatl, quiahuitl, xochitl.
    pub id: GetAztecDaySignParamsId,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetAztecDaySignParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetAztecDaySignParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Day sign id, case-insensitive and punctuation-insensitive. One of cipactli, ehecatl, calli, cuetzpalin, coatl, miquiztli, mazatl, tochtli, atl, itzcuintli, ozomahtli, malinalli, acatl, ocelotl, cuauhtli, cozcacuauhtli, ollin, tecpatl, quiahuitl, xochitl.
    GetAztecDaySignParamsId {
        Cipactli = "cipactli",
        Ehecatl = "ehecatl",
        Calli = "calli",
        Cuetzpalin = "cuetzpalin",
        Coatl = "coatl",
        Miquiztli = "miquiztli",
        Mazatl = "mazatl",
        Tochtli = "tochtli",
        Atl = "atl",
        Itzcuintli = "itzcuintli",
        Ozomahtli = "ozomahtli",
        Malinalli = "malinalli",
        Acatl = "acatl",
        Ocelotl = "ocelotl",
        Cuauhtli = "cuauhtli",
        Cozcacuauhtli = "cozcacuauhtli",
        Ollin = "ollin",
        Tecpatl = "tecpatl",
        Quiahuitl = "quiahuitl",
        Xochitl = "xochitl",
    }
}
/// Response body of `getAvastha`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAvasthaResponse {
    /// Unique slug for the avastha state. It is the lowercased form of the state name the birth chart returns, so a chart value maps straight onto this record.
    pub id: String,
    /// What the state means for the results the graha delivers, which is the whole purpose of reading an avastha: the chart says where a graha is, the avastha says how much of its promise it can keep.
    pub interpretation: String,
    /// Short label for the state, sized for a table cell beside the graha.
    pub meaning: String,
    /// Sanskrit name of the state, exactly as it appears in the `awastha`, `jagradadi` or `deeptadi` field of a birth chart.
    pub name: String,
    /// Which avastha system the state belongs to, and therefore which birth-chart field it appears in. "baladi" is the five-fold age state set by degree within the sign and appears in `awastha`. "jagradadi" is the three-fold waking state set by sign dignity. "deeptadi" is the nine-fold dispositional state. Baladi applies to every body; the other two apply to the seven classical grahas only.
    pub system: GetAvasthaResponseSystem,
}
string_enum! {
    /// Which avastha system the state belongs to, and therefore which birth-chart field it appears in. "baladi" is the five-fold age state set by degree within the sign and appears in `awastha`. "jagradadi" is the three-fold waking state set by sign dignity. "deeptadi" is the nine-fold dispositional state. Baladi applies to every body; the other two apply to the seven classical grahas only.
    GetAvasthaResponseSystem {
        Baladi = "baladi",
        Jagradadi = "jagradadi",
        Deeptadi = "deeptadi",
    }
}
/// Path and query parameters of `getAvastha`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAvasthaParams {
    /// Avastha slug. Baladi: bala, kumara, yuva, vriddha, mrita. Jagradadi: jagrat, swapna, sushupti. Deeptadi: dipta, svastha, pramudita, shanta, dina, duhkhita, vikala, khala, kopa.
    pub id: GetAvasthaParamsId,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetAvasthaParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetAvasthaParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Avastha slug. Baladi: bala, kumara, yuva, vriddha, mrita. Jagradadi: jagrat, swapna, sushupti. Deeptadi: dipta, svastha, pramudita, shanta, dina, duhkhita, vikala, khala, kopa.
    GetAvasthaParamsId {
        Bala = "bala",
        Kumara = "kumara",
        Yuva = "yuva",
        Vriddha = "vriddha",
        Mrita = "mrita",
        Jagrat = "jagrat",
        Swapna = "swapna",
        Sushupti = "sushupti",
        Dipta = "dipta",
        Svastha = "svastha",
        Pramudita = "pramudita",
        Shanta = "shanta",
        Dina = "dina",
        Duhkhita = "duhkhita",
        Vikala = "vikala",
        Khala = "khala",
        Kopa = "kopa",
    }
}
/// Response body of `getAnnualFlyingStars`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAnnualFlyingStarsResponse {
    /// Flying star number, 1 to 9. The number IS the identifier of the star: 8 is always the Eight White Earth star whichever plate it appears on.
    #[serde(rename = "centerStar")]
    pub center_star: f64,
    /// The date this plate takes effect, which is Li Chun and NOT Lunar New Year. Lunar New Year 2026 falls on 17 February, roughly two weeks later, and applying the new plate from that date is the most common error in annual feng shui.
    #[serde(rename = "changeoverDate")]
    pub changeover_date: String,
    /// All nine palaces with the star that flew there, centre first and then along the Lo Shu path. The plate is universal: it is the same for every building on earth.
    pub palaces: Vec<GetAnnualFlyingStarsResponsePalacesItem>,
    /// The solar year this plate is for.
    pub year: f64,
}
/// One entry of `palaces`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAnnualFlyingStarsResponsePalacesItem {
    /// Five phase of this entry: Wood, Fire, Earth, Metal or Water. Always English so it stays safe to compare against and to key styling on. The full cycles live on the Chinese astrology elements endpoint.
    pub element: String,
    /// Five phase of this entry: Wood, Fire, Earth, Metal or Water. Always English so it stays safe to compare against and to key styling on. The full cycles live on the Chinese astrology elements endpoint.
    pub enhancer: String,
    /// What the star does in the sector it has flown to this period.
    pub meaning: String,
    /// Display name of the star in this palace. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Star name in the requested language, for display only. Present only when lang is set to a language other than English.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// The untimely reading of the star, auspicious or inauspicious.
    pub nature: String,
    /// Palace of the Lo Shu grid: one of the eight compass sectors, or Center. Always English, safe to compare against and to key a grid cell on.
    pub palace: String,
    /// Five phase of this entry: Wood, Fire, Earth, Metal or Water. Always English so it stays safe to compare against and to key styling on. The full cycles live on the Chinese astrology elements endpoint.
    pub remedy: String,
    /// Flying star number, 1 to 9. The number IS the identifier of the star: 8 is always the Eight White Earth star whichever plate it appears on.
    pub star: f64,
}
/// Path and query parameters of `getAnnualFlyingStars`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAnnualFlyingStarsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetAnnualFlyingStarsParamsLang>,
    /// Solar year, 1900 to 2100. The year runs from Li Chun to Li Chun, so a date in January belongs to the previous year here.
    pub year: i64,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetAnnualFlyingStarsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getAnnualAfflictions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAnnualAfflictionsResponse {
    /// The date all four afflictions move, which is Li Chun and NOT Lunar New Year. In 2026 Lunar New Year falls on 17 February, roughly two weeks after the afflictions have already changed.
    #[serde(rename = "changeoverDate")]
    pub changeover_date: String,
    /// The Five Yellow, read off the annual star plate rather than from the year branch, which is why it is the only one of the four that has nothing to do with the animal of the year.
    #[serde(rename = "fiveYellow")]
    pub five_yellow: GetAnnualAfflictionsResponseFiveYellow,
    /// The Three Killings. Two readings of its extent are in circulation and both are given: the exact 75 degree branch span in startDegree and endDegree, and the 45 degree cardinal palace named in direction.
    #[serde(rename = "sanSha")]
    pub san_sha: GetAnnualAfflictionsResponseSanSha,
    /// The Year Breaker, always the mountain directly opposite Tai Sui.
    #[serde(rename = "suiPo")]
    pub sui_po: GetAnnualAfflictionsResponseSuiPo,
    /// The Grand Duke, occupying a single 15 degree mountain rather than a whole sector. Precision matters here more than anywhere else in the system, because the neighbouring mountains of the same sector are unaffected.
    #[serde(rename = "taiSui")]
    pub tai_sui: GetAnnualAfflictionsResponseTaiSui,
    /// The solar year these positions are for.
    pub year: f64,
    /// Earthly Branch of the solar year, in pinyin. Three of the four afflictions are derived from it. Always English pinyin, safe to compare against.
    #[serde(rename = "yearBranch")]
    pub year_branch: String,
}
/// The Grand Duke, occupying a single 15 degree mountain rather than a whole sector. Precision matters here more than anywhere else in the system, because the neighbouring mountains of the same sector are unaffected.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAnnualAfflictionsResponseTaiSui {
    /// Zodiac animal of the year, which shares the sign Tai Sui occupies. Always English, safe to compare against.
    pub animal: String,
    /// Chinese characters for the affliction. Data, identical in every language.
    pub chinese: String,
    /// The animal directly opposite, which clashes with Tai Sui head on. People of this sign are the ones traditionally advised to take the most care during the year.
    #[serde(rename = "clashingAnimal")]
    pub clashing_animal: String,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, safe to compare against and to key styling on.
    pub direction: String,
    /// Stable machine key for the affliction: taiSui, suiPo, sanSha or fiveYellow. Always English, identical in every language, and the field to branch on. Use this rather than name, which is display copy and does translate.
    pub id: String,
    /// What the affliction does and the standing rule for handling it.
    pub meaning: String,
    /// The `mountain` field.
    pub mountain: GetAnnualAfflictionsResponseTaiSuiMountain,
    /// Display name of the affliction, translated in place when lang is set (Tai Sui in English, 太岁 under zh-Hans). Display copy, never a comparison key: branch on id instead.
    pub name: String,
    /// Tone-marked pinyin. Data, identical in every language.
    pub pinyin: String,
}
/// The `mountain` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAnnualAfflictionsResponseTaiSuiMountain {
    /// Chinese character for the mountain. Data, identical in every language.
    pub chinese: String,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against in code and against the same value on the I-Ching trigram endpoints.
    pub direction: String,
    /// End of the 15 degree span, in compass degrees.
    #[serde(rename = "endDegree")]
    pub end_degree: f64,
    /// Mountain id, the pinyin of the stem, branch or trigram that names it. Always English pinyin, safe to compare against.
    pub id: String,
    /// Compass label of the mountain, sector plus position 1 to 3 clockwise. The form a facing is usually quoted in.
    pub label: String,
    /// Tone-marked pinyin for the mountain. Data, identical in every language.
    pub pinyin: String,
    /// San Yuan polarity of the mountain, yang or yin, which decides whether a plate entering the centre flies forward or in reverse. This is NOT the natural polarity of the stem or branch and the two differ on eight of the 24 mountains.
    pub polarity: String,
    /// Start of the 15 degree span, in compass degrees. Wraps past 360 for the two northernmost mountains.
    #[serde(rename = "startDegree")]
    pub start_degree: f64,
    /// Which of the three dragons the mountain holds inside its sector: earth for the first mountain clockwise, heaven for the middle, human for the last. The heaven and human dragons share a polarity, which is why they share a chart.
    pub yuan: String,
}
/// The Year Breaker, always the mountain directly opposite Tai Sui.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAnnualAfflictionsResponseSuiPo {
    /// Chinese characters for the affliction. Data, identical in every language.
    pub chinese: String,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, safe to compare against and to key styling on.
    pub direction: String,
    /// Stable machine key for the affliction: taiSui, suiPo, sanSha or fiveYellow. Always English, identical in every language, and the field to branch on. Use this rather than name, which is display copy and does translate.
    pub id: String,
    /// What the affliction does and the standing rule for handling it.
    pub meaning: String,
    /// The `mountain` field.
    pub mountain: GetAnnualAfflictionsResponseSuiPoMountain,
    /// Display name of the affliction, translated in place when lang is set (Tai Sui in English, 太岁 under zh-Hans). Display copy, never a comparison key: branch on id instead.
    pub name: String,
    /// Tone-marked pinyin. Data, identical in every language.
    pub pinyin: String,
}
/// The `mountain` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAnnualAfflictionsResponseSuiPoMountain {
    /// Chinese character for the mountain. Data, identical in every language.
    pub chinese: String,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against in code and against the same value on the I-Ching trigram endpoints.
    pub direction: String,
    /// End of the 15 degree span, in compass degrees.
    #[serde(rename = "endDegree")]
    pub end_degree: f64,
    /// Mountain id, the pinyin of the stem, branch or trigram that names it. Always English pinyin, safe to compare against.
    pub id: String,
    /// Compass label of the mountain, sector plus position 1 to 3 clockwise. The form a facing is usually quoted in.
    pub label: String,
    /// Tone-marked pinyin for the mountain. Data, identical in every language.
    pub pinyin: String,
    /// San Yuan polarity of the mountain, yang or yin, which decides whether a plate entering the centre flies forward or in reverse. This is NOT the natural polarity of the stem or branch and the two differ on eight of the 24 mountains.
    pub polarity: String,
    /// Start of the 15 degree span, in compass degrees. Wraps past 360 for the two northernmost mountains.
    #[serde(rename = "startDegree")]
    pub start_degree: f64,
    /// Which of the three dragons the mountain holds inside its sector: earth for the first mountain clockwise, heaven for the middle, human for the last. The heaven and human dragons share a polarity, which is why they share a chart.
    pub yuan: String,
}
/// The Three Killings. Two readings of its extent are in circulation and both are given: the exact 75 degree branch span in startDegree and endDegree, and the 45 degree cardinal palace named in direction.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAnnualAfflictionsResponseSanSha {
    /// Chinese characters for the affliction. Data, identical in every language.
    pub chinese: String,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, safe to compare against and to key styling on.
    pub direction: String,
    /// End of the afflicted span in compass degrees.
    #[serde(rename = "endDegree")]
    pub end_degree: f64,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, safe to compare against and to key styling on.
    #[serde(rename = "frameDirection")]
    pub frame_direction: String,
    /// The five phase the year branch forms with its trine. The Three Killings always sits in the cardinal direction opposite this frame.
    #[serde(rename = "frameElement")]
    pub frame_element: String,
    /// Stable machine key for the affliction: taiSui, suiPo, sanSha or fiveYellow. Always English, identical in every language, and the field to branch on. Use this rather than name, which is display copy and does translate.
    pub id: String,
    /// What the affliction does and the standing rule for handling it.
    pub meaning: String,
    /// Display name of the affliction, translated in place when lang is set (Tai Sui in English, 太岁 under zh-Hans). Display copy, never a comparison key: branch on id instead.
    pub name: String,
    /// The three mountains of the span, first to last in compass order. They are one affliction read in three parts, not three separate ones, and disturbing any part is taken to wake the whole.
    pub parts: Vec<GetAnnualAfflictionsResponseSanShaPartsItem>,
    /// Tone-marked pinyin. Data, identical in every language.
    pub pinyin: String,
    /// Start of the afflicted span in compass degrees. The span crosses 360 when the affliction is in the north.
    #[serde(rename = "startDegree")]
    pub start_degree: f64,
}
/// One entry of `parts`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAnnualAfflictionsResponseSanShaPartsItem {
    /// Chinese characters for the part. Data, identical in every language.
    pub chinese: String,
    /// Which of the three parts this is: jie-sha, zai-sha or sui-sha, in compass order. Always English, safe to compare against.
    pub id: String,
    /// What this part of the span brings.
    pub meaning: String,
    /// The `mountain` field.
    pub mountain: GetAnnualAfflictionsResponseSanShaPartsItemMountain,
    /// Display name of the part, translated in place when lang is set. Display copy, never a comparison key: branch on id instead.
    pub name: String,
    /// Tone-marked pinyin. Data, identical in every language.
    pub pinyin: String,
}
/// The `mountain` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAnnualAfflictionsResponseSanShaPartsItemMountain {
    /// Chinese character for the mountain. Data, identical in every language.
    pub chinese: String,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against in code and against the same value on the I-Ching trigram endpoints.
    pub direction: String,
    /// End of the 15 degree span, in compass degrees.
    #[serde(rename = "endDegree")]
    pub end_degree: f64,
    /// Mountain id, the pinyin of the stem, branch or trigram that names it. Always English pinyin, safe to compare against.
    pub id: String,
    /// Compass label of the mountain, sector plus position 1 to 3 clockwise. The form a facing is usually quoted in.
    pub label: String,
    /// Tone-marked pinyin for the mountain. Data, identical in every language.
    pub pinyin: String,
    /// San Yuan polarity of the mountain, yang or yin, which decides whether a plate entering the centre flies forward or in reverse. This is NOT the natural polarity of the stem or branch and the two differ on eight of the 24 mountains.
    pub polarity: String,
    /// Start of the 15 degree span, in compass degrees. Wraps past 360 for the two northernmost mountains.
    #[serde(rename = "startDegree")]
    pub start_degree: f64,
    /// Which of the three dragons the mountain holds inside its sector: earth for the first mountain clockwise, heaven for the middle, human for the last. The heaven and human dragons share a polarity, which is why they share a chart.
    pub yuan: String,
}
/// The Five Yellow, read off the annual star plate rather than from the year branch, which is why it is the only one of the four that has nothing to do with the animal of the year.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAnnualAfflictionsResponseFiveYellow {
    /// Chinese characters for the affliction. Data, identical in every language.
    pub chinese: String,
    /// Stable machine key for the affliction: taiSui, suiPo, sanSha or fiveYellow. Always English, identical in every language, and the field to branch on. Use this rather than name, which is display copy and does translate.
    pub id: String,
    /// What the affliction does and the standing rule for handling it.
    pub meaning: String,
    /// Display name of the affliction, translated in place when lang is set (Tai Sui in English, 太岁 under zh-Hans). Display copy, never a comparison key: branch on id instead.
    pub name: String,
    /// Palace the 5 flew to this year, one of the eight sectors or Center. Always English, safe to compare against.
    pub palace: String,
    /// Tone-marked pinyin. Data, identical in every language.
    pub pinyin: String,
    /// The phase that drains the 5, which is what the 5 itself produces. Never treat it with Fire, which produces Earth and feeds it.
    pub remedy: String,
    /// Flying star number, 1 to 9. The number IS the identifier of the star: 8 is always the Eight White Earth star whichever plate it appears on.
    pub star: f64,
}
/// Path and query parameters of `getAnnualAfflictions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAnnualAfflictionsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetAnnualAfflictionsParamsLang>,
    /// Solar year, 1900 to 2100. The year runs from Li Chun to Li Chun, so a date in January belongs to the previous year here.
    pub year: i64,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetAnnualAfflictionsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getAngelNumber`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAngelNumberResponse {
    /// Three to five specific, actionable steps to take when you see this angel number. Practical spiritual guidance for daily life.
    #[serde(rename = "actionSteps")]
    pub action_steps: Vec<String>,
    /// Positive affirmation aligned with this angel number. Can be used for daily affirmation features, meditation guidance, or spiritual journal prompts.
    pub affirmation: String,
    /// Biblical and religious perspective on the sequence, framed honestly. States plainly when a number is not a scriptural concept rather than inventing scripture.
    pub biblical: String,
    /// One to two sentence summary of the divine message. Ideal for push notifications, daily guidance widgets, and quick reference lookups.
    #[serde(rename = "coreMessage")]
    pub core_message: String,
    /// Numerology digit root calculated by summing all digits and reducing to a single digit. Links each angel number to foundational numerology meaning. Master numbers 11, 22, 33 are preserved without further reduction.
    #[serde(rename = "digitRoot")]
    pub digit_root: f64,
    /// Overall energy classification. "positive" indicates encouraging, uplifting energy. "neutral" indicates transitional energy (neither purely positive nor cautionary). "cautionary" indicates a gentle warning to rebalance or pay attention.
    pub energy: String,
    /// Five to eight keywords capturing the spiritual themes and energy of this angel number. Useful for search, filtering, and content generation.
    pub keywords: Vec<String>,
    /// The `meaning` field.
    pub meaning: GetAngelNumberResponseMeaning,
    /// Angel number sequence as a string. Common patterns include triple repeating (111-999), quad repeating (1111-9999), master numbers (11, 22, 33), mirror patterns (1212), and sequential numbers (1234).
    pub number: String,
    /// Shadow or cautionary reading: the misuse, over-reliance, or imbalance this sequence can signal. Complements the energy classification.
    pub shadow: String,
    /// Short descriptive title capturing the core theme and spiritual significance of this angel number.
    pub title: String,
    /// Pattern classification of the angel number. "repeating" means all digits are the same (111, 4444). "sequential" means consecutive digits (1234). "mirror" means palindrome or alternating pattern (1212, 1221). "master" means numerology master number (11, 22, 33). "root" means single digit (0-9). "compound" means a mixed sequence with no pure pattern (911, 1122).
    pub r#type: String,
}
/// The `meaning` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAngelNumberResponseMeaning {
    /// Career and vocation guidance: professional opportunities, calling, and practical work advice aligned with this angel number energy. Money and finances are returned separately in the money field.
    pub career: String,
    /// Love and relationship interpretation covering singles, couples, and those healing from past relationships. Includes romantic guidance and partnership advice.
    pub love: String,
    /// Money, finances, and material abundance guidance, kept distinct from career and vocation. Covers income, spending, debt, and prosperity mindset for this angel number.
    pub money: String,
    /// Two to three paragraph spiritual interpretation covering divine guidance, higher purpose, and the metaphysical significance of this angel number sequence.
    pub spiritual: String,
    /// Twin flame connection interpretation covering union, separation, and spiritual growth within the twin flame journey.
    #[serde(rename = "twinFlame")]
    pub twin_flame: String,
}
/// Path and query parameters of `getAngelNumber`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAngelNumberParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetAngelNumberParamsLang>,
    /// Angel number sequence to look up (e.g., "111", "444", "1212", "1234"). Must match an entry in the database.
    pub number: String,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetAngelNumberParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getAlmanacDay`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAlmanacDayResponse {
    /// Activity identifiers, always English kebab case so they stay safe to compare against in code. Use the /calendar/auspicious-days endpoint to search a date range for one of them.
    pub avoids: Vec<String>,
    /// The zodiac animal the day clashes with, which is the animal six branches away from the day branch. Anyone born in that animal year traditionally avoids the day for anything important.
    #[serde(rename = "clashAnimal")]
    pub clash_animal: String,
    /// Display name of the clashing animal in the requested language. Absent when lang is en, so an English response is unchanged.
    #[serde(rename = "clashAnimalLocalized", skip_serializing_if = "Option::is_none")]
    pub clash_animal_localized: Option<String>,
    /// The Gregorian date of the day, at the reference meridian.
    pub date: String,
    /// The `dayOfficer` field.
    #[serde(rename = "dayOfficer")]
    pub day_officer: GetAlmanacDayResponseDayOfficer,
    /// The `dayPillar` field.
    #[serde(rename = "dayPillar")]
    pub day_pillar: GetAlmanacDayResponseDayPillar,
    /// Activity identifiers, always English kebab case so they stay safe to compare against in code. Use the /calendar/auspicious-days endpoint to search a date range for one of them.
    pub favours: Vec<String>,
    /// The `lunar` field.
    pub lunar: GetAlmanacDayResponseLunar,
    /// The `mansion` field.
    pub mansion: GetAlmanacDayResponseMansion,
    /// Sexagenary month pillar of the day, and the pillar the day officer is counted from. Attributed by whole days like the year pillar, so the day a minor solar term falls on belongs to the new month even when the term arrives late in the evening. This is what an almanac prints, and it is not the same as the month pillar of a birth moment inside that day.
    #[serde(rename = "monthPillar")]
    pub month_pillar: GetAlmanacDayResponseMonthPillar,
    /// Sexagenary year pillar of the day. Attributed by whole days, so the day Li Chun falls on belongs to the new year for its whole length. A BaZi chart built from a birth TIME uses the term instant instead, so a birth in the hours before the term on that same day carries the previous year pillar.
    #[serde(rename = "yearPillar")]
    pub year_pillar: GetAlmanacDayResponseYearPillar,
}
/// Sexagenary year pillar of the day. Attributed by whole days, so the day Li Chun falls on belongs to the new year for its whole length. A BaZi chart built from a birth TIME uses the term instant instead, so a birth in the hours before the term on that same day carries the previous year pillar.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAlmanacDayResponseYearPillar {
    /// Earthly Branch of the pillar, one of zi chou yin mao chen si wu wei shen you xu hai.
    pub branch: String,
    /// The pillar in Chinese characters. A data field, identical in every language.
    pub chinese: String,
    /// Pillar identifier as stem-branch, e.g. jia-zi. Always English pinyin, whatever the lang parameter says, so it stays safe to compare against in code.
    pub id: String,
    /// Na Yin sound element of the pillar. It is a property of the pair, not of the stem, so it often names a different phase from the stem itself.
    #[serde(rename = "naYin")]
    pub na_yin: String,
    /// Five phase the Na Yin resolves to. Always English, so it stays safe to compare against in code.
    #[serde(rename = "naYinElement")]
    pub na_yin_element: String,
    /// Position in the sixty year cycle, 1 to 60. jia-zi is 1 and gui-hai is 60.
    pub number: f64,
    /// Heavenly Stem of the pillar, one of jia yi bing ding wu ji geng xin ren gui.
    pub stem: String,
}
/// Sexagenary month pillar of the day, and the pillar the day officer is counted from. Attributed by whole days like the year pillar, so the day a minor solar term falls on belongs to the new month even when the term arrives late in the evening. This is what an almanac prints, and it is not the same as the month pillar of a birth moment inside that day.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAlmanacDayResponseMonthPillar {
    /// Earthly Branch of the pillar, one of zi chou yin mao chen si wu wei shen you xu hai.
    pub branch: String,
    /// The pillar in Chinese characters. A data field, identical in every language.
    pub chinese: String,
    /// Pillar identifier as stem-branch, e.g. jia-zi. Always English pinyin, whatever the lang parameter says, so it stays safe to compare against in code.
    pub id: String,
    /// Na Yin sound element of the pillar. It is a property of the pair, not of the stem, so it often names a different phase from the stem itself.
    #[serde(rename = "naYin")]
    pub na_yin: String,
    /// Five phase the Na Yin resolves to. Always English, so it stays safe to compare against in code.
    #[serde(rename = "naYinElement")]
    pub na_yin_element: String,
    /// Position in the sixty year cycle, 1 to 60. jia-zi is 1 and gui-hai is 60.
    pub number: f64,
    /// Heavenly Stem of the pillar, one of jia yi bing ding wu ji geng xin ren gui.
    pub stem: String,
}
/// The `mansion` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAlmanacDayResponseMansion {
    /// Animal emblem of the mansion, the third character of its full Chinese name. English and canonical, identical in every language, matching how clashAnimal behaves on the same response. The translation is in animalLocalized.
    pub animal: String,
    /// Animal emblem in the requested language. Absent when lang is en, and absent when a language has no entry, so a caller falls back to animal.
    #[serde(rename = "animalLocalized", skip_serializing_if = "Option::is_none")]
    pub animal_localized: Option<String>,
    /// The mansion in Chinese. A data field, identical in every language.
    pub chinese: String,
    /// English display name of the mansion. Canonical, identical in every language. The translation is in nameLocalized. Note the mansion has no string id: number is the stable 1 to 28 key, because five of the 28 share a pinyin spelling.
    pub name: String,
    /// Display name of the mansion in the requested language. Absent when lang is en, and absent when a language has no entry for this mansion, so a caller falls back to name rather than rendering a blank.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Mansion number, 1 to 28, counted from the Horn. This is the identifier: three mansions share the pinyin wei and two share bi, so there is no unique pinyin key.
    pub number: f64,
    /// One of the four palaces, seven mansions each: azure-dragon, black-tortoise, white-tiger, vermilion-bird. Always English, so it stays safe to compare against in code.
    pub palace: String,
    /// Tone marked pinyin for the character.
    pub pinyin: String,
    /// The luminary the mansion belongs to, one of Wood Metal Earth Sun Moon Fire Water. Twenty eight mansions over seven luminaries is four weeks exactly, which is why a mansion always falls on the same weekday.
    pub planet: String,
}
/// The `lunar` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAlmanacDayResponseLunar {
    /// The Gregorian date this lunar day covers, evaluated at the reference meridian.
    pub date: String,
    /// Day of the lunar month, 1 to 30. A lunar month never has 31 days.
    pub day: f64,
    /// True when this is the leap repetition of the month number rather than the first pass through it.
    #[serde(rename = "isLeapMonth")]
    pub is_leap_month: bool,
    /// Lunar month, 1 to 12. A leap month repeats the number of the month it follows.
    pub month: f64,
    /// Days in this lunar month, 29 for a short month or 30 for a long one. It is the interval between two new moons, so it varies month to month.
    #[serde(rename = "monthLength")]
    pub month_length: f64,
    /// Lunisolar year. It advances on the first day of month 1, not at Li Chun, so it can lag the Gregorian year by up to seven weeks.
    pub year: f64,
}
/// The `dayPillar` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAlmanacDayResponseDayPillar {
    /// Earthly Branch of the pillar, one of zi chou yin mao chen si wu wei shen you xu hai.
    pub branch: String,
    /// The pillar in Chinese characters. A data field, identical in every language.
    pub chinese: String,
    /// Pillar identifier as stem-branch, e.g. jia-zi. Always English pinyin, whatever the lang parameter says, so it stays safe to compare against in code.
    pub id: String,
    /// Na Yin sound element of the pillar. It is a property of the pair, not of the stem, so it often names a different phase from the stem itself.
    #[serde(rename = "naYin")]
    pub na_yin: String,
    /// Five phase the Na Yin resolves to. Always English, so it stays safe to compare against in code.
    #[serde(rename = "naYinElement")]
    pub na_yin_element: String,
    /// Position in the sixty year cycle, 1 to 60. jia-zi is 1 and gui-hai is 60.
    pub number: f64,
    /// Heavenly Stem of the pillar, one of jia yi bing ding wu ji geng xin ren gui.
    pub stem: String,
}
/// The `dayOfficer` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAlmanacDayResponseDayOfficer {
    /// The officer in Chinese. A data field, identical in every language.
    pub chinese: String,
    /// Day officer identifier, one of jian chu man ping ding zhi po wei cheng shou kai bi. Always English pinyin, so it stays safe to compare against in code.
    pub id: String,
    /// What the officer means, in the terms a date choice uses it in.
    pub meaning: String,
    /// English display name of the officer. Canonical, identical in every language, so it stays safe to compare against in code. The translation is in nameLocalized.
    pub name: String,
    /// Display name of the officer in the requested language. Absent when lang is en, so an English response is unchanged.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone marked pinyin for the character.
    pub pinyin: String,
    /// Whether the officer falls on the auspicious or the inauspicious side of the coarse yellow and black split. Read favours and avoids for what the day actually rules on.
    pub quality: String,
}
/// Path and query parameters of `getAlmanacDay`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAlmanacDayParams {
    /// Gregorian date in YYYY-MM-DD format, evaluated at the reference meridian. Years 1900 to 2100.
    pub date: String,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GetAlmanacDayParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GetAlmanacDayParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `generateTransit`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateTransitResponse {
    /// The 13 transiting bodies at this moment with the gate and line each currently activates. A transit is a single instant, so there is no Design side, only current positions.
    pub activations: Vec<GenerateTransitResponseActivationsItem>,
    /// Channels the transit temporarily completes that the natal chart did not already define, each labelled personal or educational with the side that supplied each gate.
    #[serde(rename = "completedChannels")]
    pub completed_channels: Vec<GenerateTransitResponseCompletedChannelsItem>,
    /// Date the transit overlay was computed for, in YYYY-MM-DD UTC.
    pub date: String,
    /// Short factual summary of the overlay with channel and center counts only.
    pub summary: String,
    /// Centers that are open in the natal chart and temporarily defined by a transit-completed channel.
    #[serde(rename = "temporaryCenters")]
    pub temporary_centers: Vec<GenerateTransitResponseTemporaryCentersItem>,
    /// Time the transit overlay was computed for, in HH:MM:SS UTC.
    pub time: String,
    /// UTC offset of the transit moment. Always 0, since the transit is computed in UTC.
    pub timezone: f64,
}
/// One entry of `temporaryCenters`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateTransitResponseTemporaryCentersItem {
    /// Center identifier. One of head, ajna, throat, g, heart, sacral, solar-plexus, spleen, root.
    pub id: String,
    /// Display name of the center. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Center name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Always true. The center is open in the natal chart and temporarily defined by a transit-completed channel for the duration of the transit.
    #[serde(rename = "temporarilyDefined")]
    pub temporarily_defined: bool,
}
/// One entry of `completedChannels`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateTransitResponseCompletedChannelsItem {
    /// The two centers this channel connects and temporarily defines.
    pub centers: Vec<String>,
    /// Circuit family of the channel. One of Individual, Collective, Tribal. Always English, whatever the lang parameter says. Use circuitLocalized for anything a reader sees.
    pub circuit: String,
    /// Circuit family name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "circuitLocalized", skip_serializing_if = "Option::is_none")]
    pub circuit_localized: Option<String>,
    /// First gate of the completed channel.
    #[serde(rename = "gateA")]
    pub gate_a: f64,
    /// Second gate of the completed channel.
    #[serde(rename = "gateB")]
    pub gate_b: f64,
    /// How the transit completes the channel. personal means the natal chart already holds one gate and the transit supplies the other, the classic electromagnetic completion. educational means both gates are open in the natal chart and the transit supplies both at once. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use kindLocalized for anything a reader sees.
    pub kind: String,
    /// Completion kind name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "kindLocalized", skip_serializing_if = "Option::is_none")]
    pub kind_localized: Option<String>,
    /// Name of the channel the transit temporarily completes. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Channel name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Gate or gates of this channel the natal chart already holds. Empty for an educational channel.
    #[serde(rename = "natalGates")]
    pub natal_gates: Vec<f64>,
    /// Gate or gates of this channel supplied by the transit. One gate for a personal channel, both gates for an educational channel.
    #[serde(rename = "transitGates")]
    pub transit_gates: Vec<f64>,
}
/// One entry of `activations`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateTransitResponseActivationsItem {
    /// Transiting body whose current position lands on this gate. One of Sun, Earth, Moon, North Node, South Node, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto. Always English, whatever the lang parameter says, so it stays safe to compare against in code and to key a glyph table on. Use bodyLocalized for anything a reader sees.
    pub body: String,
    /// Transiting body name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "bodyLocalized", skip_serializing_if = "Option::is_none")]
    pub body_localized: Option<String>,
    /// Human Design gate number from 1 to 64 this transiting body currently sits in.
    pub gate: f64,
    /// Human Design keynote name of the gate the transiting body activates. Always English, whatever the lang parameter says. Use gateNameLocalized for anything a reader sees.
    #[serde(rename = "gateName")]
    pub gate_name: String,
    /// Gate keynote name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "gateNameLocalized", skip_serializing_if = "Option::is_none")]
    pub gate_name_localized: Option<String>,
    /// Cross-reference to the I-Ching hexagram that shares this gate number.
    #[serde(rename = "ichingHexagram")]
    pub iching_hexagram: GenerateTransitResponseActivationsItemIchingHexagram,
    /// Line number from 1 to 6 within the gate, setting the line keynote of the transit.
    pub line: f64,
}
/// Cross-reference to the I-Ching hexagram that shares this gate number.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateTransitResponseActivationsItemIchingHexagram {
    /// English name of the corresponding I-Ching hexagram.
    pub english: String,
    /// I-Ching hexagram number, identical to the gate number it corresponds to.
    pub number: f64,
}
/// Request body of `generateTransit`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateTransitRequest {
    /// Birth moment whose natal bodygraph the transit is overlaid on.
    #[serde(rename = "birthData")]
    pub birth_data: GenerateTransitRequestBirthData,
    /// Transit date in YYYY-MM-DD UTC. Optional. Defaults to today in UTC when omitted, giving the just-now transit.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Transit time in HH:MM:SS UTC. Optional. Defaults to the current UTC time when omitted. Precision matters: the Moon moves through a gate in roughly half a day.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub time: Option<String>,
}
/// Birth moment whose natal bodygraph the transit is overlaid on.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateTransitRequestBirthData {
    /// Birth date in YYYY-MM-DD format. The anchor for both the Personality activations at birth and the Design activations 88 degrees of solar arc earlier.
    pub date: String,
    /// Birth latitude in decimal degrees. Optional and does not affect the bodygraph, which depends only on ecliptic longitudes. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Optional and does not affect the bodygraph. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<GenerateTransitRequestBirthDataNodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Precision matters: the profile lines and gate boundaries shift with the exact minute of birth.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: GenerateTransitRequestBirthDataTimezone,
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GenerateTransitRequestBirthDataTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    GenerateTransitRequestBirthDataNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Path and query parameters of `generateTransit`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateTransitParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateTransitParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateTransitParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `generateTimeline`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateTimelineResponse {
    /// Echo of the birth subject this forecast was built for.
    #[serde(rename = "birthData")]
    pub birth_data: GenerateTimelineResponseBirthData,
    /// Number of events in the timeline after deduplication, filtering, and the event cap.
    pub count: f64,
    /// Last day of the resolved forecast window after the horizon clamp.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// The merged, time-ordered forecast events across the requested domains.
    pub events: Vec<GenerateTimelineResponseEventsItem>,
    /// First day of the resolved forecast window.
    #[serde(rename = "startDate")]
    pub start_date: String,
}
/// One entry of `events`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateTimelineResponseEventsItem {
    /// For a transit-aspect, the angular relationship. One of conjunction, sextile, square, trine, opposition. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub aspect: Option<String>,
    /// Primary subject of the event. A transiting planet for western events, Sun for a solar eclipse, Moon for a lunar eclipse or a new or full moon, or the critical cycle for biorhythm days. For a dasha-change, the Vimshottari lords outermost first, joined by a hyphen, then one space and the level: Saturn Mahadasha, Saturn-Mercury Antardasha, Saturn-Mercury-Ketu Pratyantardasha. Lords are always one of Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury. Never localized.
    pub body: String,
    /// Calendar date of the event in YYYY-MM-DD (UTC).
    pub date: String,
    /// Exact instant of the event as an ISO-8601 UTC datetime, to the nearest second. Astronomical events are refined to this instant by search, not reported at a daily sample point; a dasha-change is the period boundary itself, counted from the birth instant.
    pub datetime: String,
    /// Plain-language summary of the event, suitable for direct display. The only localized field: when lang is set this sentence, and the body, target, and aspect names within it, render in the requested language while the structured fields stay English.
    pub description: String,
    /// Forecast domain. western covers transit aspects, sign ingresses, retrograde stations, eclipses, and new and full moons. vedic covers Vimshottari mahadasha, antardasha, and pratyantardasha boundaries. biorhythm covers critical days. A stable machine value, never localized, so consumers can branch on it under any language.
    pub domain: GenerateTimelineResponseEventsItemDomain,
    /// For an eclipse, its classification. total and penumbral apply to lunar eclipses, partial applies to both, annular and total apply to solar eclipses. A stable machine value, never localized. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kind: Option<GenerateTimelineResponseEventsItemKind>,
    /// For a lunar eclipse, the peak fraction from 0 to 1 of the Moon disc covered by Earth umbra. 1 for a total lunar eclipse, between 0 and 1 for a partial, 0 for a penumbral. Absent for solar eclipses and other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub obscuration: Option<f64>,
    /// For a transit-aspect, the separation in degrees from the exact aspect at the reported instant, rounded to three decimals. The instant is the moment the aspect perfects, so this reads 0. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub orb: Option<f64>,
    /// For a lunar-phase event, which syzygy it is: new-moon (Sun-Moon conjunction) or full-moon (Sun-Moon opposition). The intermediate quarters are not emitted. A stable machine value, never localized. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phase: Option<GenerateTimelineResponseEventsItemPhase>,
    /// Importance score from 0 to 100. Outer-planet exact transit aspects and mahadasha changes score highest; fast Moon events and biorhythm critical days score lower. When domainWeights is supplied this is the weighted score, rounded and clamped to 0 to 100, which is the same value the significance floor and the event cap acted on.
    pub significance: f64,
    /// For a retrograde-station, whether the planet turns retrograde or direct. A stable machine value, never localized. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub station: Option<GenerateTimelineResponseEventsItemStation>,
    /// For a transit-aspect, the natal body the transit aspects. For a sign-ingress, the zodiac sign entered, and for a lunar-phase, the zodiac sign of the New or Full Moon. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub target: Option<String>,
    /// Event kind. transit-aspect, sign-ingress, retrograde-station, eclipse, and lunar-phase are western, dasha-change is vedic Vimshottari, critical-day is biorhythm. A stable machine value, never localized, so consumers can branch on it under any language.
    pub r#type: GenerateTimelineResponseEventsItemType,
}
string_enum! {
    /// Event kind. transit-aspect, sign-ingress, retrograde-station, eclipse, and lunar-phase are western, dasha-change is vedic Vimshottari, critical-day is biorhythm. A stable machine value, never localized, so consumers can branch on it under any language.
    GenerateTimelineResponseEventsItemType {
        TransitAspect = "transit-aspect",
        SignIngress = "sign-ingress",
        RetrogradeStation = "retrograde-station",
        Eclipse = "eclipse",
        LunarPhase = "lunar-phase",
        DashaChange = "dasha-change",
        CriticalDay = "critical-day",
    }
}
string_enum! {
    /// For a retrograde-station, whether the planet turns retrograde or direct. A stable machine value, never localized. Absent for other event types.
    GenerateTimelineResponseEventsItemStation {
        Retrograde = "retrograde",
        Direct = "direct",
    }
}
string_enum! {
    /// For a lunar-phase event, which syzygy it is: new-moon (Sun-Moon conjunction) or full-moon (Sun-Moon opposition). The intermediate quarters are not emitted. A stable machine value, never localized. Absent for other event types.
    GenerateTimelineResponseEventsItemPhase {
        NewMoon = "new-moon",
        FullMoon = "full-moon",
    }
}
string_enum! {
    /// For an eclipse, its classification. total and penumbral apply to lunar eclipses, partial applies to both, annular and total apply to solar eclipses. A stable machine value, never localized. Absent for other event types.
    GenerateTimelineResponseEventsItemKind {
        Penumbral = "penumbral",
        Partial = "partial",
        Annular = "annular",
        Total = "total",
    }
}
string_enum! {
    /// Forecast domain. western covers transit aspects, sign ingresses, retrograde stations, eclipses, and new and full moons. vedic covers Vimshottari mahadasha, antardasha, and pratyantardasha boundaries. biorhythm covers critical days. A stable machine value, never localized, so consumers can branch on it under any language.
    GenerateTimelineResponseEventsItemDomain {
        Western = "western",
        Vedic = "vedic",
        Biorhythm = "biorhythm",
    }
}
/// Echo of the birth subject this forecast was built for.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateTimelineResponseBirthData {
    /// Birth date in YYYY-MM-DD format. Anchors the natal chart and the Vimshottari dasha sequence.
    pub date: String,
    /// Birth latitude in decimal degrees. Optional and does not affect the timeline. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Optional and does not affect the timeline. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Birth time in 24-hour HH:MM:SS format. Precision matters for the natal positions the transit aspects are measured against.
    pub time: String,
    /// Decimal UTC offset the forecast was computed with, resolved from whatever the request sent. An IANA name is resolved to the offset in force at the birth date and time, so this is the literal number applied, never the name.
    pub timezone: f64,
}
/// Request body of `generateTimeline`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateTimelineRequest {
    /// The single birth subject this forecast is built for. One object only, never an array.
    #[serde(rename = "birthData")]
    pub birth_data: GenerateTimelineRequestBirthData,
    /// Per-domain significance multipliers applied before the significance floor and event cap. Bias which domains survive filtering and the cap. Omitted domains default to a weight of 1. Valid keys are western, vedic, and biorhythm.
    #[serde(rename = "domainWeights", skip_serializing_if = "Option::is_none")]
    pub domain_weights: Option<GenerateTimelineRequestDomainWeights>,
    /// Which forecast domains to include. Defaults to all three. Pass a subset to scope the timeline to one or two engines.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub domains: Option<Vec<GenerateTimelineRequestDomainsItem>>,
    /// Last day of the forecast window in YYYY-MM-DD format. Defaults to startDate plus 30 days. The window is clamped to a maximum of 90 days from startDate.
    #[serde(rename = "endDate", skip_serializing_if = "Option::is_none")]
    pub end_date: Option<String>,
    /// Drop events scoring below this significance threshold from 0 to 100. Defaults to 0, keeping all events.
    #[serde(rename = "minSignificance", skip_serializing_if = "Option::is_none")]
    pub min_significance: Option<f64>,
    /// First day of the forecast window in YYYY-MM-DD format. Defaults to today in UTC.
    #[serde(rename = "startDate", skip_serializing_if = "Option::is_none")]
    pub start_date: Option<String>,
}
string_enum! {
    /// Forecast domain. western covers transit aspects, sign ingresses, retrograde stations, eclipses, and new and full moons. vedic covers Vimshottari mahadasha, antardasha, and pratyantardasha boundaries. biorhythm covers critical days.
    GenerateTimelineRequestDomainsItem {
        Western = "western",
        Vedic = "vedic",
        Biorhythm = "biorhythm",
    }
}
/// Per-domain significance multipliers applied before the significance floor and event cap. Bias which domains survive filtering and the cap. Omitted domains default to a weight of 1. Valid keys are western, vedic, and biorhythm.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateTimelineRequestDomainWeights {
    /// Multiplier for this domain significance. 1 leaves it unchanged, above 1 promotes the domain, below 1 demotes it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub biorhythm: Option<f64>,
    /// Multiplier for this domain significance. 1 leaves it unchanged, above 1 promotes the domain, below 1 demotes it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vedic: Option<f64>,
    /// Multiplier for this domain significance. 1 leaves it unchanged, above 1 promotes the domain, below 1 demotes it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub western: Option<f64>,
}
/// The single birth subject this forecast is built for. One object only, never an array.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateTimelineRequestBirthData {
    /// Birth date in YYYY-MM-DD format. Anchors the natal chart and the Vimshottari dasha sequence.
    pub date: String,
    /// Birth latitude in decimal degrees. Optional and does not affect the timeline. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Optional and does not affect the timeline. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Birth time in 24-hour HH:MM:SS format. Precision matters for the natal positions the transit aspects are measured against.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: GenerateTimelineRequestBirthDataTimezone,
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GenerateTimelineRequestBirthDataTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
/// Path and query parameters of `generateTimeline`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateTimelineParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateTimelineParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateTimelineParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `generateSolarReturn`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateSolarReturnResponse {
    /// Original birth date used for natal Sun longitude calculation.
    #[serde(rename = "birthDate")]
    pub birth_date: String,
    /// Full natal-style chart erected for the solar return moment. Contains all 14 celestial bodies (10 classical planets, lunar nodes, Chiron, Black Moon Lilith), 12 house cusps, aspects, Ascendant, and Midheaven in the tropical zodiac.
    pub chart: GenerateSolarReturnResponseChart,
    /// Solar return interpretation with annual forecast themes. Solar returns are the primary technique in Western astrology for year-ahead predictions.
    pub interpretation: GenerateSolarReturnResponseInterpretation,
    /// Location used for the solar return chart. The Ascendant and house cusps change based on where you are at your birthday, a key technique in relocated solar returns.
    pub location: GenerateSolarReturnResponseLocation,
    /// Original natal Sun position that the transiting Sun returns to. This conjunction defines the solar return moment.
    #[serde(rename = "natalSunPosition")]
    pub natal_sun_position: GenerateSolarReturnResponseNatalSunPosition,
    /// Exact solar return moment, when the transiting Sun conjuncts the natal Sun longitude. Adjusted to requested timezone. This is your astrological birthday for the year.
    #[serde(rename = "solarReturnDate")]
    pub solar_return_date: String,
    /// Year of this solar return chart. Covers the period from this birthday to the next.
    #[serde(rename = "solarReturnYear")]
    pub solar_return_year: f64,
}
/// Original natal Sun position that the transiting Sun returns to. This conjunction defines the solar return moment.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateSolarReturnResponseNatalSunPosition {
    /// Degree within the zodiac sign (0-29.999). The precise position the Sun returns to.
    pub degree: f64,
    /// Natal Sun ecliptic longitude in degrees (0-360). The transiting Sun returns to this exact degree each year.
    pub longitude: f64,
    /// Tropical zodiac sign of the natal Sun (your Sun sign).
    pub sign: String,
}
/// Location used for the solar return chart. The Ascendant and house cusps change based on where you are at your birthday, a key technique in relocated solar returns.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateSolarReturnResponseLocation {
    /// Observer latitude used for Placidus house cusp and Ascendant calculation in the solar return chart.
    pub latitude: f64,
    /// Observer longitude used for local sidereal time and Midheaven calculation in the solar return chart.
    pub longitude: f64,
    /// Timezone offset from UTC applied to output datetime formatting.
    pub timezone: f64,
}
/// Solar return interpretation with annual forecast themes. Solar returns are the primary technique in Western astrology for year-ahead predictions.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateSolarReturnResponseInterpretation {
    /// Key life areas and themes highlighted by this solar return chart. Focus on these for the birthday year.
    #[serde(rename = "keyThemes")]
    pub key_themes: Vec<String>,
    /// Explanation of how to use solar return charts for annual forecasting, identifying yearly themes, and timing predictions.
    pub purpose: String,
    /// Narrative overview of the solar return year themes and energy.
    pub summary: String,
}
/// Full natal-style chart erected for the solar return moment. Contains all 14 celestial bodies (10 classical planets, lunar nodes, Chiron, Black Moon Lilith), 12 house cusps, aspects, Ascendant, and Midheaven in the tropical zodiac.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateSolarReturnResponseChart {
    /// All planetary aspects found in this chart with orbs, strength, and applying/separating status.
    pub aspects: Vec<GenerateSolarReturnResponseChartAspectsItem>,
    /// Birth details used to generate this chart.
    #[serde(rename = "birthDetails")]
    pub birth_details: GenerateSolarReturnResponseChartBirthDetails,
    /// House system used for this chart (placidus, whole-sign, equal, or koch).
    #[serde(rename = "houseSystem")]
    pub house_system: GenerateSolarReturnResponseChartHouseSystem,
    /// All 12 house cusps calculated using the selected house system.
    pub houses: Vec<GenerateSolarReturnResponseChartHousesItem>,
    /// Part of Fortune (Lot of Fortune). A point derived from the Ascendant and the two luminaries that marks an area of ease, vitality, and material wellbeing in the chart.
    #[serde(rename = "partOfFortune")]
    pub part_of_fortune: GenerateSolarReturnResponseChartPartOfFortune,
    /// All 14 celestial bodies in the tropical zodiac with house placements: the 10 classical planets (Sun through Pluto), the lunar nodes (North Node, South Node, in the requested `nodeType` convention), Chiron, and Black Moon Lilith. Chiron is included for charts from 1600 to 2500 and omitted outside that range.
    pub planets: Vec<GenerateSolarReturnResponseChartPlanetsItem>,
    /// Vertex. The western intersection of the prime vertical with the ecliptic, often read as a point of fated encounters and turning-point relationships. The opposite point is the Anti-Vertex.
    pub vertex: GenerateSolarReturnResponseChartVertex,
}
/// Vertex. The western intersection of the prime vertical with the ecliptic, often read as a point of fated encounters and turning-point relationships. The opposite point is the Anti-Vertex.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateSolarReturnResponseChartVertex {
    /// Degree within the Vertex sign (0-29.999).
    pub degree: f64,
    /// House containing this point, resolved against the same cusps as `planets[].house` and using the requested house system. Read this field rather than inferring a house from the sign: the two disagree whenever a house spans more than one sign, which is most of the time outside Whole Sign.
    pub house: i64,
    /// Absolute ecliptic longitude of the Vertex (0-360).
    pub longitude: f64,
    /// Zodiac sign holding the Vertex.
    pub sign: String,
}
/// One entry of `planets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateSolarReturnResponseChartPlanetsItem {
    /// Degree within the zodiac sign (0-29.999). Indicates how far the planet has progressed through the sign.
    pub degree: f64,
    /// House placement (1-12). Determined by the selected house system and birth location.
    pub house: i64,
    /// Whether the planet appears to move backward from Earth perspective. Retrograde periods signal review and introspection.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Apparent geocentric ecliptic latitude of date, in degrees. Near zero for most planets, varies for the Moon and Pluto, and reaches up to about 5 degrees for Black Moon Lilith (projected from the inclined mean lunar orbit).
    pub latitude: f64,
    /// Apparent geocentric tropical longitude on the true ecliptic of date, in degrees (0-360): light time and aberration applied, nutation included, the convention desktop chart software and the NASA JPL Horizons observer tables print, so it compares directly with either. Primary coordinate for zodiac sign and aspect calculations.
    pub longitude: f64,
    /// Body name. One of the 10 classical planets (Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto), the lunar nodes (North Node, South Node), Chiron, or Black Moon Lilith (the mean lunar apogee). The lunar nodes follow the request nodeType, which defaults to the true (osculating) node; pass "mean" for the smoothed node. The two differ by up to about 1.8 degrees and no other body is affected.
    pub name: GenerateSolarReturnResponseChartPlanetsItemName,
    /// Tropical zodiac sign this planet occupies. Determined by 30-degree divisions of ecliptic longitude.
    pub sign: String,
    /// Daily motion in degrees per day. Negative values indicate retrograde motion.
    pub speed: f64,
}
string_enum! {
    /// Body name. One of the 10 classical planets (Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto), the lunar nodes (North Node, South Node), Chiron, or Black Moon Lilith (the mean lunar apogee). The lunar nodes follow the request nodeType, which defaults to the true (osculating) node; pass "mean" for the smoothed node. The two differ by up to about 1.8 degrees and no other body is affected.
    GenerateSolarReturnResponseChartPlanetsItemName {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
/// Part of Fortune (Lot of Fortune). A point derived from the Ascendant and the two luminaries that marks an area of ease, vitality, and material wellbeing in the chart.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateSolarReturnResponseChartPartOfFortune {
    /// Degree within the Part of Fortune sign (0-29.999).
    pub degree: f64,
    /// House containing this point, resolved against the same cusps as `planets[].house` and using the requested house system. Read this field rather than inferring a house from the sign: the two disagree whenever a house spans more than one sign, which is most of the time outside Whole Sign.
    pub house: i64,
    /// Absolute ecliptic longitude of the Part of Fortune (0-360).
    pub longitude: f64,
    /// Chart sect used for the calculation. Day (diurnal) when the Sun is above the horizon, night (nocturnal) when below. Day charts use Ascendant plus Moon minus Sun, night charts use Ascendant plus Sun minus Moon.
    pub sect: GenerateSolarReturnResponseChartPartOfFortuneSect,
    /// Zodiac sign holding the Part of Fortune.
    pub sign: String,
}
string_enum! {
    /// Chart sect used for the calculation. Day (diurnal) when the Sun is above the horizon, night (nocturnal) when below. Day charts use Ascendant plus Moon minus Sun, night charts use Ascendant plus Sun minus Moon.
    GenerateSolarReturnResponseChartPartOfFortuneSect {
        Day = "day",
        Night = "night",
    }
}
/// One entry of `houses`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateSolarReturnResponseChartHousesItem {
    /// Degree within the zodiac sign on this cusp (0-29.999).
    pub degree: f64,
    /// Ecliptic longitude of this house cusp in degrees (0-360).
    pub longitude: f64,
    /// House number (1-12). Each house governs specific life themes in Western astrology.
    pub number: i64,
    /// Zodiac sign on this house cusp. Colors the themes of this life area.
    pub sign: String,
}
string_enum! {
    /// House system used for this chart (placidus, whole-sign, equal, or koch).
    GenerateSolarReturnResponseChartHouseSystem {
        Placidus = "placidus",
        WholeSign = "whole-sign",
        Equal = "equal",
        Koch = "koch",
    }
}
/// Birth details used to generate this chart.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateSolarReturnResponseChartBirthDetails {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone offset from UTC in decimal hours, resolved for the birth date. Examples: New York = -5 in winter and -4 in summer, London = 0, India = 5.5, Tokyo = 9.
    pub timezone: f64,
}
/// One entry of `aspects`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateSolarReturnResponseChartAspectsItem {
    /// Exact angular separation that defines this aspect type in degrees.
    pub angle: f64,
    /// Aspect nature. Harmonious (trine, sextile) flows easily. Challenging (square, opposition) creates tension and growth. Neutral (conjunction) blends energies. Always English, whatever the lang parameter says: it is an identifier consumers switch and style on. Use interpretationLocalized for anything a reader sees.
    pub interpretation: GenerateSolarReturnResponseChartAspectsItemInterpretation,
    /// Whether the aspect is applying (planets moving toward exact) or separating (moving apart). Applying aspects grow stronger.
    #[serde(rename = "isApplying")]
    pub is_applying: bool,
    /// Deviation from exact aspect in degrees. Tighter orb means stronger influence.
    pub orb: f64,
    /// First planet in the aspect pair.
    pub planet1: GenerateSolarReturnResponseChartAspectsItemPlanet1,
    /// Second planet in the aspect pair.
    pub planet2: GenerateSolarReturnResponseChartAspectsItemPlanet2,
    /// Aspect strength percentage (0-100). Based on orb tightness relative to the allowed maximum.
    pub strength: f64,
    /// Aspect type. Major: conjunction (0), opposition (180), trine (120), square (90), sextile (60). Minor: semi-sextile, quincunx, semi-square, sesquiquadrate.
    pub r#type: GenerateSolarReturnResponseChartAspectsItemType,
}
string_enum! {
    /// Aspect type. Major: conjunction (0), opposition (180), trine (120), square (90), sextile (60). Minor: semi-sextile, quincunx, semi-square, sesquiquadrate.
    GenerateSolarReturnResponseChartAspectsItemType {
        Conjunction = "CONJUNCTION",
        Opposition = "OPPOSITION",
        Trine = "TRINE",
        Square = "SQUARE",
        Sextile = "SEXTILE",
        SemiSextile = "SEMI_SEXTILE",
        Quincunx = "QUINCUNX",
        SemiSquare = "SEMI_SQUARE",
        Sesquiquadrate = "SESQUIQUADRATE",
    }
}
string_enum! {
    /// Second planet in the aspect pair.
    GenerateSolarReturnResponseChartAspectsItemPlanet2 {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
string_enum! {
    /// First planet in the aspect pair.
    GenerateSolarReturnResponseChartAspectsItemPlanet1 {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
string_enum! {
    /// Aspect nature. Harmonious (trine, sextile) flows easily. Challenging (square, opposition) creates tension and growth. Neutral (conjunction) blends energies. Always English, whatever the lang parameter says: it is an identifier consumers switch and style on. Use interpretationLocalized for anything a reader sees.
    GenerateSolarReturnResponseChartAspectsItemInterpretation {
        Harmonious = "harmonious",
        Challenging = "challenging",
        Neutral = "neutral",
    }
}
/// Request body of `generateSolarReturn`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateSolarReturnRequest {
    /// Original birth date in YYYY-MM-DD format. Used to determine natal Sun longitude for the solar return calculation.
    #[serde(rename = "birthDate")]
    pub birth_date: String,
    /// Original birth time in 24-hour HH:MM:SS format. Determines exact natal Sun position for annual return timing.
    #[serde(rename = "birthTime")]
    pub birth_time: String,
    /// House system for the solar return chart. Placidus (default) is most common in Western astrology. Whole Sign, Equal, and Koch also supported.
    #[serde(rename = "houseSystem", skip_serializing_if = "Option::is_none")]
    pub house_system: Option<GenerateSolarReturnRequestHouseSystem>,
    /// Latitude of the solar return location in decimal degrees (-90 to 90). Use current residence or travel location at time of birthday. Solar return charts are location-sensitive.
    pub latitude: f64,
    /// Longitude of the solar return location in decimal degrees (-180 to 180). Affects house cusps and Ascendant of the return chart.
    pub longitude: f64,
    /// Year for which to cast the solar return chart. The chart is erected for the exact moment the transiting Sun conjuncts the natal Sun longitude in this year.
    #[serde(rename = "returnYear")]
    pub return_year: i64,
    /// Decimal hours from UTC OR IANA name (e.g. "America/New_York"). IANA resolved to the DST-correct offset for the birthDate. Output datetime is adjusted to this timezone.
    pub timezone: GenerateSolarReturnRequestTimezone,
}
/// Decimal hours from UTC OR IANA name (e.g. "America/New_York"). IANA resolved to the DST-correct offset for the birthDate. Output datetime is adjusted to this timezone.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GenerateSolarReturnRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// House system for the solar return chart. Placidus (default) is most common in Western astrology. Whole Sign, Equal, and Koch also supported.
    GenerateSolarReturnRequestHouseSystem {
        Placidus = "placidus",
        WholeSign = "whole-sign",
        Equal = "equal",
        Koch = "koch",
    }
}
/// Path and query parameters of `generateSolarReturn`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateSolarReturnParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateSolarReturnParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateSolarReturnParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `generateSolarArc`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateSolarArcParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateSolarArcParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateSolarArcParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `generateRelocationChart`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateRelocationChartParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateRelocationChartParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateRelocationChartParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `generateProgressions`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateProgressionsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateProgressionsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateProgressionsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `generateProfections`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateProfectionsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateProfectionsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateProfectionsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `generatePlanetaryReturn`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GeneratePlanetaryReturnResponse {
    /// Approximate orbital period for this planet. Mercury ~88 days, Venus ~225 days, Mars ~687 days (~1.9 years), Jupiter ~12 years, Saturn ~29 years.
    #[serde(rename = "approximateCycle")]
    pub approximate_cycle: String,
    /// Original birth date used for natal planet longitude calculation.
    #[serde(rename = "birthDate")]
    pub birth_date: String,
    /// Full tropical zodiac chart erected for the planetary return moment. Contains planetary positions, house cusps, aspects, Ascendant, and Midheaven.
    pub chart: GeneratePlanetaryReturnResponseChart,
    /// Planetary return interpretation. Saturn returns (~29 years) mark major life milestones. Jupiter returns (~12 years) signal growth cycles. Inner planet returns offer shorter-term insights.
    pub interpretation: GeneratePlanetaryReturnResponseInterpretation,
    /// Location used for the planetary return chart house and Ascendant calculations.
    pub location: GeneratePlanetaryReturnResponseLocation,
    /// Original natal planet position that defines the return. The transiting planet conjuncts this longitude to trigger the return.
    #[serde(rename = "natalPlanetPosition")]
    pub natal_planet_position: GeneratePlanetaryReturnResponseNatalPlanetPosition,
    /// Planet whose return was calculated. Each planet has a different orbital period and return significance.
    pub planet: String,
    /// Exact planetary return moment, when the transiting planet conjuncts its natal longitude. Adjusted to requested timezone. Marks the beginning of a new cycle for that planet in your life.
    #[serde(rename = "returnDate")]
    pub return_date: String,
}
/// Original natal planet position that defines the return. The transiting planet conjuncts this longitude to trigger the return.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GeneratePlanetaryReturnResponseNatalPlanetPosition {
    /// Degree within the zodiac sign (0-29.999).
    pub degree: f64,
    /// Natal planet ecliptic longitude in degrees (0-360). The transiting planet returns to this exact degree.
    pub longitude: f64,
    /// Tropical zodiac sign of the natal planet position.
    pub sign: String,
}
/// Location used for the planetary return chart house and Ascendant calculations.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GeneratePlanetaryReturnResponseLocation {
    /// Observer latitude used for house cusp calculation in the return chart.
    pub latitude: f64,
    /// Observer longitude used for Midheaven and local sidereal time.
    pub longitude: f64,
    /// Timezone offset from UTC applied to output datetime formatting.
    pub timezone: f64,
}
/// Planetary return interpretation. Saturn returns (~29 years) mark major life milestones. Jupiter returns (~12 years) signal growth cycles. Inner planet returns offer shorter-term insights.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GeneratePlanetaryReturnResponseInterpretation {
    /// Key life themes activated during this return cycle. Focus areas vary by planet: Jupiter brings expansion, Saturn brings structure and responsibility.
    #[serde(rename = "keyThemes")]
    pub key_themes: Vec<String>,
    /// Narrative overview of this planetary return cycle and its significance for personal development.
    pub summary: String,
}
/// Full tropical zodiac chart erected for the planetary return moment. Contains planetary positions, house cusps, aspects, Ascendant, and Midheaven.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GeneratePlanetaryReturnResponseChart {
    /// All planetary aspects found in this chart with orbs, strength, and applying/separating status.
    pub aspects: Vec<GeneratePlanetaryReturnResponseChartAspectsItem>,
    /// Birth details used to generate this chart.
    #[serde(rename = "birthDetails")]
    pub birth_details: GeneratePlanetaryReturnResponseChartBirthDetails,
    /// House system used for this chart (placidus, whole-sign, equal, or koch).
    #[serde(rename = "houseSystem")]
    pub house_system: GeneratePlanetaryReturnResponseChartHouseSystem,
    /// All 12 house cusps calculated using the selected house system.
    pub houses: Vec<GeneratePlanetaryReturnResponseChartHousesItem>,
    /// Part of Fortune (Lot of Fortune). A point derived from the Ascendant and the two luminaries that marks an area of ease, vitality, and material wellbeing in the chart.
    #[serde(rename = "partOfFortune")]
    pub part_of_fortune: GeneratePlanetaryReturnResponseChartPartOfFortune,
    /// All 14 celestial bodies in the tropical zodiac with house placements: the 10 classical planets (Sun through Pluto), the lunar nodes (North Node, South Node, in the requested `nodeType` convention), Chiron, and Black Moon Lilith. Chiron is included for charts from 1600 to 2500 and omitted outside that range.
    pub planets: Vec<GeneratePlanetaryReturnResponseChartPlanetsItem>,
    /// Vertex. The western intersection of the prime vertical with the ecliptic, often read as a point of fated encounters and turning-point relationships. The opposite point is the Anti-Vertex.
    pub vertex: GeneratePlanetaryReturnResponseChartVertex,
}
/// Vertex. The western intersection of the prime vertical with the ecliptic, often read as a point of fated encounters and turning-point relationships. The opposite point is the Anti-Vertex.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GeneratePlanetaryReturnResponseChartVertex {
    /// Degree within the Vertex sign (0-29.999).
    pub degree: f64,
    /// House containing this point, resolved against the same cusps as `planets[].house` and using the requested house system. Read this field rather than inferring a house from the sign: the two disagree whenever a house spans more than one sign, which is most of the time outside Whole Sign.
    pub house: i64,
    /// Absolute ecliptic longitude of the Vertex (0-360).
    pub longitude: f64,
    /// Zodiac sign holding the Vertex.
    pub sign: String,
}
/// One entry of `planets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GeneratePlanetaryReturnResponseChartPlanetsItem {
    /// Degree within the zodiac sign (0-29.999). Indicates how far the planet has progressed through the sign.
    pub degree: f64,
    /// House placement (1-12). Determined by the selected house system and birth location.
    pub house: i64,
    /// Whether the planet appears to move backward from Earth perspective. Retrograde periods signal review and introspection.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Apparent geocentric ecliptic latitude of date, in degrees. Near zero for most planets, varies for the Moon and Pluto, and reaches up to about 5 degrees for Black Moon Lilith (projected from the inclined mean lunar orbit).
    pub latitude: f64,
    /// Apparent geocentric tropical longitude on the true ecliptic of date, in degrees (0-360): light time and aberration applied, nutation included, the convention desktop chart software and the NASA JPL Horizons observer tables print, so it compares directly with either. Primary coordinate for zodiac sign and aspect calculations.
    pub longitude: f64,
    /// Body name. One of the 10 classical planets (Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto), the lunar nodes (North Node, South Node), Chiron, or Black Moon Lilith (the mean lunar apogee). The lunar nodes follow the request nodeType, which defaults to the true (osculating) node; pass "mean" for the smoothed node. The two differ by up to about 1.8 degrees and no other body is affected.
    pub name: GeneratePlanetaryReturnResponseChartPlanetsItemName,
    /// Tropical zodiac sign this planet occupies. Determined by 30-degree divisions of ecliptic longitude.
    pub sign: String,
    /// Daily motion in degrees per day. Negative values indicate retrograde motion.
    pub speed: f64,
}
string_enum! {
    /// Body name. One of the 10 classical planets (Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto), the lunar nodes (North Node, South Node), Chiron, or Black Moon Lilith (the mean lunar apogee). The lunar nodes follow the request nodeType, which defaults to the true (osculating) node; pass "mean" for the smoothed node. The two differ by up to about 1.8 degrees and no other body is affected.
    GeneratePlanetaryReturnResponseChartPlanetsItemName {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
/// Part of Fortune (Lot of Fortune). A point derived from the Ascendant and the two luminaries that marks an area of ease, vitality, and material wellbeing in the chart.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GeneratePlanetaryReturnResponseChartPartOfFortune {
    /// Degree within the Part of Fortune sign (0-29.999).
    pub degree: f64,
    /// House containing this point, resolved against the same cusps as `planets[].house` and using the requested house system. Read this field rather than inferring a house from the sign: the two disagree whenever a house spans more than one sign, which is most of the time outside Whole Sign.
    pub house: i64,
    /// Absolute ecliptic longitude of the Part of Fortune (0-360).
    pub longitude: f64,
    /// Chart sect used for the calculation. Day (diurnal) when the Sun is above the horizon, night (nocturnal) when below. Day charts use Ascendant plus Moon minus Sun, night charts use Ascendant plus Sun minus Moon.
    pub sect: GeneratePlanetaryReturnResponseChartPartOfFortuneSect,
    /// Zodiac sign holding the Part of Fortune.
    pub sign: String,
}
string_enum! {
    /// Chart sect used for the calculation. Day (diurnal) when the Sun is above the horizon, night (nocturnal) when below. Day charts use Ascendant plus Moon minus Sun, night charts use Ascendant plus Sun minus Moon.
    GeneratePlanetaryReturnResponseChartPartOfFortuneSect {
        Day = "day",
        Night = "night",
    }
}
/// One entry of `houses`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GeneratePlanetaryReturnResponseChartHousesItem {
    /// Degree within the zodiac sign on this cusp (0-29.999).
    pub degree: f64,
    /// Ecliptic longitude of this house cusp in degrees (0-360).
    pub longitude: f64,
    /// House number (1-12). Each house governs specific life themes in Western astrology.
    pub number: i64,
    /// Zodiac sign on this house cusp. Colors the themes of this life area.
    pub sign: String,
}
string_enum! {
    /// House system used for this chart (placidus, whole-sign, equal, or koch).
    GeneratePlanetaryReturnResponseChartHouseSystem {
        Placidus = "placidus",
        WholeSign = "whole-sign",
        Equal = "equal",
        Koch = "koch",
    }
}
/// Birth details used to generate this chart.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GeneratePlanetaryReturnResponseChartBirthDetails {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone offset from UTC in decimal hours, resolved for the birth date. Examples: New York = -5 in winter and -4 in summer, London = 0, India = 5.5, Tokyo = 9.
    pub timezone: f64,
}
/// One entry of `aspects`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GeneratePlanetaryReturnResponseChartAspectsItem {
    /// Exact angular separation that defines this aspect type in degrees.
    pub angle: f64,
    /// Aspect nature. Harmonious (trine, sextile) flows easily. Challenging (square, opposition) creates tension and growth. Neutral (conjunction) blends energies. Always English, whatever the lang parameter says: it is an identifier consumers switch and style on. Use interpretationLocalized for anything a reader sees.
    pub interpretation: GeneratePlanetaryReturnResponseChartAspectsItemInterpretation,
    /// Whether the aspect is applying (planets moving toward exact) or separating (moving apart). Applying aspects grow stronger.
    #[serde(rename = "isApplying")]
    pub is_applying: bool,
    /// Deviation from exact aspect in degrees. Tighter orb means stronger influence.
    pub orb: f64,
    /// First planet in the aspect pair.
    pub planet1: GeneratePlanetaryReturnResponseChartAspectsItemPlanet1,
    /// Second planet in the aspect pair.
    pub planet2: GeneratePlanetaryReturnResponseChartAspectsItemPlanet2,
    /// Aspect strength percentage (0-100). Based on orb tightness relative to the allowed maximum.
    pub strength: f64,
    /// Aspect type. Major: conjunction (0), opposition (180), trine (120), square (90), sextile (60). Minor: semi-sextile, quincunx, semi-square, sesquiquadrate.
    pub r#type: GeneratePlanetaryReturnResponseChartAspectsItemType,
}
string_enum! {
    /// Aspect type. Major: conjunction (0), opposition (180), trine (120), square (90), sextile (60). Minor: semi-sextile, quincunx, semi-square, sesquiquadrate.
    GeneratePlanetaryReturnResponseChartAspectsItemType {
        Conjunction = "CONJUNCTION",
        Opposition = "OPPOSITION",
        Trine = "TRINE",
        Square = "SQUARE",
        Sextile = "SEXTILE",
        SemiSextile = "SEMI_SEXTILE",
        Quincunx = "QUINCUNX",
        SemiSquare = "SEMI_SQUARE",
        Sesquiquadrate = "SESQUIQUADRATE",
    }
}
string_enum! {
    /// Second planet in the aspect pair.
    GeneratePlanetaryReturnResponseChartAspectsItemPlanet2 {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
string_enum! {
    /// First planet in the aspect pair.
    GeneratePlanetaryReturnResponseChartAspectsItemPlanet1 {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
string_enum! {
    /// Aspect nature. Harmonious (trine, sextile) flows easily. Challenging (square, opposition) creates tension and growth. Neutral (conjunction) blends energies. Always English, whatever the lang parameter says: it is an identifier consumers switch and style on. Use interpretationLocalized for anything a reader sees.
    GeneratePlanetaryReturnResponseChartAspectsItemInterpretation {
        Harmonious = "harmonious",
        Challenging = "challenging",
        Neutral = "neutral",
    }
}
/// Request body of `generatePlanetaryReturn`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GeneratePlanetaryReturnRequest {
    /// Approximate date near the expected planetary return (YYYY-MM-DD). The return nearest this date is returned, so a date off by months still lands on a genuine return; during a retrograde loop the planet crosses its natal degree up to three times and the crossing nearest the date is the one returned.
    #[serde(rename = "approximateDate")]
    pub approximate_date: String,
    /// Original birth date in YYYY-MM-DD format. Used to determine the natal longitude of the selected planet.
    #[serde(rename = "birthDate")]
    pub birth_date: String,
    /// Original birth time in 24-hour HH:MM:SS format. Determines exact natal planet position for return timing.
    #[serde(rename = "birthTime")]
    pub birth_time: String,
    /// House system for the return chart. Placidus (default), Whole Sign, Equal, or Koch.
    #[serde(rename = "houseSystem", skip_serializing_if = "Option::is_none")]
    pub house_system: Option<GeneratePlanetaryReturnRequestHouseSystem>,
    /// Latitude of the return location in decimal degrees (-90 to 90). Affects house cusps and Ascendant of the return chart.
    pub latitude: f64,
    /// Longitude of the return location in decimal degrees (-180 to 180).
    pub longitude: f64,
    /// Planet for the return calculation. Supports Mercury (~88 days), Venus (~225 days), Mars (~687 days), Jupiter (~12 years), and Saturn (~29 years). Saturn return is a major life milestone in Western astrology.
    pub planet: GeneratePlanetaryReturnRequestPlanet,
    /// Decimal hours from UTC OR IANA name (e.g. "America/New_York"). IANA resolved to the DST-correct offset for the birthDate. Output datetime is adjusted to this timezone.
    pub timezone: GeneratePlanetaryReturnRequestTimezone,
}
/// Decimal hours from UTC OR IANA name (e.g. "America/New_York"). IANA resolved to the DST-correct offset for the birthDate. Output datetime is adjusted to this timezone.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GeneratePlanetaryReturnRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Planet for the return calculation. Supports Mercury (~88 days), Venus (~225 days), Mars (~687 days), Jupiter (~12 years), and Saturn (~29 years). Saturn return is a major life milestone in Western astrology.
    GeneratePlanetaryReturnRequestPlanet {
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
    }
}
string_enum! {
    /// House system for the return chart. Placidus (default), Whole Sign, Equal, or Koch.
    GeneratePlanetaryReturnRequestHouseSystem {
        Placidus = "placidus",
        WholeSign = "whole-sign",
        Equal = "equal",
        Koch = "koch",
    }
}
/// Path and query parameters of `generatePlanetaryReturn`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GeneratePlanetaryReturnParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GeneratePlanetaryReturnParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GeneratePlanetaryReturnParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `generateNumerologyChart`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponse {
    /// Additional numerology insights: karmic analysis, yearly/monthly forecasts, pinnacles, challenges, hidden passion, subconscious self, and name letter analysis.
    #[serde(rename = "additionalInsights")]
    pub additional_insights: GenerateNumerologyChartResponseAdditionalInsights,
    /// Birth Day profile with day-specific meaning (1-31). Unlike the core Birth Day number, this provides unique interpretation per calendar day.
    #[serde(rename = "birthDayProfile", skip_serializing_if = "Option::is_none")]
    pub birth_day_profile: Option<GenerateNumerologyChartResponseBirthDayProfile>,
    /// Six core numerology numbers with full interpretations. The foundation of any complete numerology reading.
    #[serde(rename = "coreNumbers")]
    pub core_numbers: GenerateNumerologyChartResponseCoreNumbers,
    /// Lucky associations based on Life Path number: colors, gemstones, day, element, planet, and compatibility.
    #[serde(rename = "luckyAssociations", skip_serializing_if = "Option::is_none")]
    pub lucky_associations: Option<GenerateNumerologyChartResponseLuckyAssociations>,
    /// Maturity number activation status based on current age.
    #[serde(rename = "maturityStatus")]
    pub maturity_status: GenerateNumerologyChartResponseMaturityStatus,
    /// Input profile data used to generate the chart.
    pub profile: GenerateNumerologyChartResponseProfile,
    /// AI-ready holistic summary weaving all core numbers, karmic insights, and yearly forecast into a cohesive narrative. Ideal for generating personalized reports, chatbot responses, or one-page numerology overviews.
    pub summary: String,
}
/// Input profile data used to generate the chart.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseProfile {
    /// Birth date in YYYY-MM-DD format.
    pub birthdate: String,
    /// Full birth name used for letter-based calculations (Expression, Soul Urge, Personality).
    pub name: String,
}
/// Maturity number activation status based on current age.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseMaturityStatus {
    /// Age range when the Maturity number typically activates (35-40).
    #[serde(rename = "activationRange")]
    pub activation_range: String,
    /// The current UTC calendar year minus the birth year. The birthday is not considered, so before the birthday it reads one more than the age in whole years, and currentYear does not move it.
    #[serde(rename = "currentAge")]
    pub current_age: f64,
    /// Whether the Maturity number is currently active (typically activates around age 35-40).
    #[serde(rename = "isActive")]
    pub is_active: bool,
}
/// Lucky associations based on Life Path number: colors, gemstones, day, element, planet, and compatibility.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseLuckyAssociations {
    /// Lucky colors associated with the Life Path number.
    pub colors: Vec<String>,
    /// Most compatible Life Path numbers.
    #[serde(rename = "compatibleNumbers")]
    pub compatible_numbers: Vec<f64>,
    /// Lucky day of the week.
    pub day: String,
    /// Classical element (Fire, Water, Earth, Air).
    pub element: String,
    /// Lucky gemstones aligned to the ruling planet.
    pub gemstones: Vec<String>,
    /// Least compatible Life Path numbers.
    #[serde(rename = "incompatibleNumbers")]
    pub incompatible_numbers: Vec<f64>,
    /// Ruling planet for this Life Path number.
    #[serde(rename = "rulingPlanet")]
    pub ruling_planet: String,
}
/// Six core numerology numbers with full interpretations. The foundation of any complete numerology reading.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseCoreNumbers {
    /// Birth Day number. Reveals a special talent or gift based on the calendar day of birth.
    #[serde(rename = "birthDay")]
    pub birth_day: GenerateNumerologyChartResponseCoreNumbersBirthDay,
    /// Expression (Destiny) number. Reveals natural talents, abilities, and life goals derived from the full birth name.
    pub expression: GenerateNumerologyChartResponseCoreNumbersExpression,
    /// Life Path. The most significant core number, revealing life purpose and destiny path.
    #[serde(rename = "lifePath")]
    pub life_path: GenerateNumerologyChartResponseCoreNumbersLifePath,
    /// Maturity number. The person you are becoming. Sum of Life Path and Expression, activates around age 35-40.
    pub maturity: GenerateNumerologyChartResponseCoreNumbersMaturity,
    /// Personality number. The outer you, how the world perceives you. Calculated from consonants in the birth name.
    pub personality: GenerateNumerologyChartResponseCoreNumbersPersonality,
    /// Soul Urge (Heart Desire) number. Reveals innermost desires, motivations, and what truly makes you happy. Calculated from vowels.
    #[serde(rename = "soulUrge")]
    pub soul_urge: GenerateNumerologyChartResponseCoreNumbersSoulUrge,
}
/// Soul Urge (Heart Desire) number. Reveals innermost desires, motivations, and what truly makes you happy. Calculated from vowels.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseCoreNumbersSoulUrge {
    /// Vowel extraction and reduction calculation.
    pub calculation: String,
    /// Whether karmic debt was encountered.
    #[serde(rename = "hasKarmicDebt")]
    pub has_karmic_debt: bool,
    /// Karmic debt number if present.
    #[serde(rename = "karmicDebtNumber", skip_serializing_if = "Option::is_none")]
    pub karmic_debt_number: Option<f64>,
    /// Complete interpretation of the Soul Urge number with archetype, emotional drives, relationship needs, and spiritual direction.
    pub meaning: GenerateNumerologyChartResponseCoreNumbersSoulUrgeMeaning,
    /// Soul Urge (Heart Desire) number from vowels in birth name.
    pub number: f64,
    /// Single digit or master number.
    pub r#type: GenerateNumerologyChartResponseCoreNumbersSoulUrgeType,
}
string_enum! {
    /// Single digit or master number.
    GenerateNumerologyChartResponseCoreNumbersSoulUrgeType {
        Single = "single",
        Master = "master",
    }
}
/// Complete interpretation of the Soul Urge number with archetype, emotional drives, relationship needs, and spiritual direction.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseCoreNumbersSoulUrgeMeaning {
    /// Career paths that satisfy your deepest emotional needs. Focuses on work that feeds the soul rather than just the resume, aligned with lasting inner fulfillment.
    pub career: String,
    /// Inner shadows and emotional patterns to balance. Explains how each challenge manifests when the Soul Urge energy is overextended or repressed.
    pub challenges: Vec<String>,
    /// Core interpretation of the inner self, hidden desires and emotional landscape. Together with the strengths, challenges, career, relationships and spirituality fields it makes a full reading.
    pub description: String,
    /// Core emotional drives and inner motivations. These define what truly fulfills you at the deepest level, beyond surface-level desires and social expectations.
    pub keywords: Vec<String>,
    /// How your Soul Urge shapes what you need from love, friendship, and family. Covers emotional compatibility, attachment style, and the key to feeling truly seen and understood.
    pub relationships: String,
    /// The spiritual hunger at your core. Explores what your soul is seeking in this lifetime and the contemplative practices that bring you closest to inner peace and alignment.
    pub spirituality: String,
    /// Emotional superpowers and inner gifts. Each strength describes how it shapes decision-making, relationships, and the pursuit of personal fulfillment.
    pub strengths: Vec<String>,
    /// Numerology archetype for this Soul Urge number. Reveals the deepest inner motivation, such as "The Seeker" for 7 or "The Master Teacher" for 33.
    pub title: String,
}
/// Personality number. The outer you, how the world perceives you. Calculated from consonants in the birth name.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseCoreNumbersPersonality {
    /// Consonant extraction and reduction calculation.
    pub calculation: String,
    /// Whether karmic debt was encountered.
    #[serde(rename = "hasKarmicDebt")]
    pub has_karmic_debt: bool,
    /// Karmic debt number if present.
    #[serde(rename = "karmicDebtNumber", skip_serializing_if = "Option::is_none")]
    pub karmic_debt_number: Option<f64>,
    /// Complete interpretation of the Personality number with archetype, social traits, professional image, and first-impression dynamics.
    pub meaning: GenerateNumerologyChartResponseCoreNumbersPersonalityMeaning,
    /// Personality number from consonants in birth name.
    pub number: f64,
    /// Single digit or master number.
    pub r#type: GenerateNumerologyChartResponseCoreNumbersPersonalityType,
}
string_enum! {
    /// Single digit or master number.
    GenerateNumerologyChartResponseCoreNumbersPersonalityType {
        Single = "single",
        Master = "master",
    }
}
/// Complete interpretation of the Personality number with archetype, social traits, professional image, and first-impression dynamics.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseCoreNumbersPersonalityMeaning {
    /// How your outward presence shapes professional opportunities. Covers the industries, roles, and environments where your public image creates the greatest advantage.
    pub career: String,
    /// Blind spots in your public persona. Patterns others notice that you may not, including defense mechanisms and image-management tendencies that can limit authentic connection.
    pub challenges: Vec<String>,
    /// Core interpretation of the outer personality, social presence and the image projected to the world. Together with the strengths, challenges, career, relationships and spirituality fields it makes a full reading.
    pub description: String,
    /// Traits that define your public persona and first impression. These are the qualities others perceive before they get to know the real you.
    pub keywords: Vec<String>,
    /// First impressions in love and social dynamics. Explores how your Personality number attracts certain partners, sets relationship expectations, and influences group dynamics.
    pub relationships: String,
    /// The spiritual energy you radiate to others. Explores how your outer presence serves as a channel for deeper purpose and what your public path reveals about your soul mission.
    pub spirituality: String,
    /// Your strongest social assets and public-facing gifts. These qualities shape how you are received in professional settings, social gatherings, and first meetings.
    pub strengths: Vec<String>,
    /// Numerology archetype for this Personality number. Represents the outer mask you show the world, such as "The Builder" for 4 or "The Powerhouse" for 8.
    pub title: String,
}
/// Maturity number. The person you are becoming. Sum of Life Path and Expression, activates around age 35-40.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseCoreNumbersMaturity {
    /// Shows Life Path + Expression reduction.
    pub calculation: String,
    /// Whether karmic debt was encountered.
    #[serde(rename = "hasKarmicDebt")]
    pub has_karmic_debt: bool,
    /// Karmic debt number if present.
    #[serde(rename = "karmicDebtNumber", skip_serializing_if = "Option::is_none")]
    pub karmic_debt_number: Option<f64>,
    /// Complete interpretation of the Maturity number with archetype, emerging traits, career evolution, and spiritual awakening.
    pub meaning: GenerateNumerologyChartResponseCoreNumbersMaturityMeaning,
    /// Maturity number (Life Path + Expression). Becomes active around age 35-40.
    pub number: f64,
    /// Single digit or master number.
    pub r#type: GenerateNumerologyChartResponseCoreNumbersMaturityType,
}
string_enum! {
    /// Single digit or master number.
    GenerateNumerologyChartResponseCoreNumbersMaturityType {
        Single = "single",
        Master = "master",
    }
}
/// Complete interpretation of the Maturity number with archetype, emerging traits, career evolution, and spiritual awakening.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseCoreNumbersMaturityMeaning {
    /// Career evolution and professional reinvention for the second act. Covers industries, roles, and pursuits that align with your mature energy and accumulated wisdom.
    pub career: String,
    /// Growth areas to watch as Maturity energy intensifies. Understanding these early helps you navigate the transition into your mature self with awareness and grace.
    pub challenges: Vec<String>,
    /// Core interpretation of the person being grown into in the second half of life, the wisdom gained through lived experience. Together with the strengths, challenges, career, relationships and spirituality fields it makes a full reading.
    pub description: String,
    /// Emerging traits and qualities that strengthen after age 35 to 40. These energies gradually integrate into your personality as you mature and gain life experience.
    pub keywords: Vec<String>,
    /// How your relationships deepen and transform as Maturity energy takes hold. Covers evolving partnership needs, family dynamics, and the relationship wisdom that comes with age.
    pub relationships: String,
    /// Spiritual awakening in the mature years. Explores the deeper meaning that emerges when life experience meets the Maturity number and practices for this transformative phase.
    pub spirituality: String,
    /// Late-blooming strengths that emerge with age and experience. These are the gifts that become your greatest assets in the second half of life.
    pub strengths: Vec<String>,
    /// Numerology archetype for the Maturity number. Reveals who you are becoming in the second half of life, such as "The Builder" for 4 or "The Humanitarian" for 9.
    pub title: String,
}
/// Life Path. The most significant core number, revealing life purpose and destiny path.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseCoreNumbersLifePath {
    /// Step-by-step calculation showing how the Life Path number was derived from the birth date.
    pub calculation: String,
    /// True if the reduction passed through a karmic debt number (13, 14, 16, 19).
    #[serde(rename = "hasKarmicDebt")]
    pub has_karmic_debt: bool,
    /// The karmic debt number encountered during reduction, if any.
    #[serde(rename = "karmicDebtNumber", skip_serializing_if = "Option::is_none")]
    pub karmic_debt_number: Option<f64>,
    /// Complete interpretation of the Life Path number with archetype, traits, career guidance, relationship insights, and spiritual direction.
    pub meaning: GenerateNumerologyChartResponseCoreNumbersLifePathMeaning,
    /// Life Path number (1-9, 11, 22, 33). The most important number in numerology, derived from birth date. Reveals life purpose and destiny.
    pub number: f64,
    /// Whether this is a single digit (1-9) or master number (11, 22, 33). Master numbers carry amplified spiritual significance.
    pub r#type: GenerateNumerologyChartResponseCoreNumbersLifePathType,
}
string_enum! {
    /// Whether this is a single digit (1-9) or master number (11, 22, 33). Master numbers carry amplified spiritual significance.
    GenerateNumerologyChartResponseCoreNumbersLifePathType {
        Single = "single",
        Master = "master",
    }
}
/// Complete interpretation of the Life Path number with archetype, traits, career guidance, relationship insights, and spiritual direction.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseCoreNumbersLifePathMeaning {
    /// Tailored career guidance covering ideal industries, roles, and work environments. Includes specific job titles and explains why certain professional paths resonate with this Life Path energy.
    pub career: String,
    /// Growth areas and shadow qualities to work through. Each entry explains the root cause, how it surfaces in behavior, and constructive strategies for personal development.
    pub challenges: Vec<String>,
    /// Core interpretation of the Life Path covering personality, life purpose and core themes. Together with the strengths, challenges, career, relationships and spirituality fields it makes a full reading.
    pub description: String,
    /// Defining personality traits and energetic themes for this Life Path. Useful for compatibility matching, personality snapshots, and building numerology profile summaries.
    pub keywords: Vec<String>,
    /// Love, friendship, and family dynamics shaped by this Life Path. Covers romantic compatibility with other numbers, communication style, and the key relationship lessons for lasting partnerships.
    pub relationships: String,
    /// Spiritual path, soul lessons, and recommended practices. Explores the deeper purpose behind this Life Path number and guidance for personal growth and inner transformation.
    pub spirituality: String,
    /// Core strengths and positive qualities. Each entry pairs a trait with a detailed explanation of how it manifests in everyday life and decision-making.
    pub strengths: Vec<String>,
    /// Numerology archetype name for this Life Path number. A defining phrase that captures the core identity, such as "The Leader" for 1 or "The Humanitarian" for 9.
    pub title: String,
}
/// Expression (Destiny) number. Reveals natural talents, abilities, and life goals derived from the full birth name.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseCoreNumbersExpression {
    /// Letter-to-number conversion showing how the Expression number was calculated.
    pub calculation: String,
    /// Whether karmic debt was encountered during calculation.
    #[serde(rename = "hasKarmicDebt")]
    pub has_karmic_debt: bool,
    /// Karmic debt number if present.
    #[serde(rename = "karmicDebtNumber", skip_serializing_if = "Option::is_none")]
    pub karmic_debt_number: Option<f64>,
    /// Complete interpretation of the Expression number with archetype, talents, career paths, relationship dynamics, and spiritual expression.
    pub meaning: GenerateNumerologyChartResponseCoreNumbersExpressionMeaning,
    /// Expression (Destiny) number derived from full birth name using Pythagorean numerology.
    pub number: f64,
    /// Single digit or master number.
    pub r#type: GenerateNumerologyChartResponseCoreNumbersExpressionType,
}
string_enum! {
    /// Single digit or master number.
    GenerateNumerologyChartResponseCoreNumbersExpressionType {
        Single = "single",
        Master = "master",
    }
}
/// Complete interpretation of the Expression number with archetype, talents, career paths, relationship dynamics, and spiritual expression.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseCoreNumbersExpressionMeaning {
    /// Career paths where your Expression number talents create the greatest professional advantage. Covers specific industries, creative pursuits, and work styles aligned with your name vibration.
    pub career: String,
    /// Growth areas where natural talent can become a liability without conscious balance. Explains how each challenge manifests and practical ways to work through it.
    pub challenges: Vec<String>,
    /// Core interpretation of the natural abilities, life goals and talents the birth name describes. Together with the strengths, challenges, career, relationships and spirituality fields it makes a full reading.
    pub description: String,
    /// Natural talents and abilities encoded in the birth name. These define your innate skill set, creative potential, and the gifts available to you throughout life.
    pub keywords: Vec<String>,
    /// How your Expression number shapes the way you communicate, connect, and express love. Covers partnership dynamics, social style, and the relationship patterns rooted in your name energy.
    pub relationships: String,
    /// The spiritual dimension of your natural gifts. Explores how your Expression number talents serve a higher purpose and the creative practices that deepen self-expression.
    pub spirituality: String,
    /// Natural-born talents and creative gifts. Each strength describes a specific ability that comes effortlessly and how it contributes to personal and professional success.
    pub strengths: Vec<String>,
    /// Numerology archetype for this Expression number. Reveals the natural talent blueprint, such as "The Communicator" for 3 or "The Master Builder" for 22.
    pub title: String,
}
/// Birth Day number. Reveals a special talent or gift based on the calendar day of birth.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseCoreNumbersBirthDay {
    /// Step-by-step calculation showing how the Birth Day number was reduced from the calendar day of birth.
    pub calculation: String,
    /// True if the birth day is a karmic debt number (13, 14, 16, 19).
    #[serde(rename = "hasKarmicDebt")]
    pub has_karmic_debt: bool,
    /// The karmic debt number if the birth day carries one (13, 14, 16, or 19).
    #[serde(rename = "karmicDebtNumber", skip_serializing_if = "Option::is_none")]
    pub karmic_debt_number: Option<f64>,
    /// Complete interpretation of the Birth Day number with archetype, innate talents, career advantages, and relationship dynamics.
    pub meaning: GenerateNumerologyChartResponseCoreNumbersBirthDayMeaning,
    /// Birth Day number (1-31). A special talent number based on the day of the month you were born.
    pub number: f64,
    /// Whether this is a single digit (1-9) or master number (11, 22). Birth days of 11 and 22 are preserved as master numbers.
    pub r#type: GenerateNumerologyChartResponseCoreNumbersBirthDayType,
}
string_enum! {
    /// Whether this is a single digit (1-9) or master number (11, 22). Birth days of 11 and 22 are preserved as master numbers.
    GenerateNumerologyChartResponseCoreNumbersBirthDayType {
        Single = "single",
        Master = "master",
    }
}
/// Complete interpretation of the Birth Day number with archetype, innate talents, career advantages, and relationship dynamics.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseCoreNumbersBirthDayMeaning {
    /// Professional paths where your birth day talents create an immediate advantage. Covers specific roles, industries, and work styles aligned with your innate abilities.
    pub career: String,
    /// The flip side of your gifts. Each challenge explains how an overreliance on natural talent can become a liability without conscious balance.
    pub challenges: Vec<String>,
    /// Core interpretation of the special abilities the birth day brings and how they complement the Life Path and Expression numbers. Together with the strengths, challenges, career, relationships and spirituality fields it makes a full reading.
    pub description: String,
    /// Innate talents and natural aptitudes encoded in your birth day. These gifts are available from birth and become more refined with age and experience.
    pub keywords: Vec<String>,
    /// How your birth day gifts shape the way you connect with others. Covers romantic chemistry, friendship dynamics, and the relationship patterns rooted in your natural temperament.
    pub relationships: String,
    /// The spiritual dimension of your natural gifts. Explores how your birth day talents serve a higher purpose and the practices that help you channel them with intention.
    pub spirituality: String,
    /// Natural-born strengths that come effortlessly. These are the talents you can rely on even without formal training or conscious development.
    pub strengths: Vec<String>,
    /// Numerology archetype for this Birth Day number. Represents the specific talent or gift you brought into this life, like "The Nurturer" for 6 or "The Seeker" for 7.
    pub title: String,
}
/// Birth Day profile with day-specific meaning (1-31). Unlike the core Birth Day number, this provides unique interpretation per calendar day.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseBirthDayProfile {
    /// Career guidance for this specific birth day.
    pub career: String,
    /// Challenges specific to this birth day.
    pub challenges: Vec<String>,
    /// Calendar day of birth (1-31).
    pub day: f64,
    /// Detailed personality profile unique to this calendar day, not just the reduced digit.
    pub description: String,
    /// Personality traits specific to this birth day.
    pub keywords: Vec<String>,
    /// Single digit or master number this day reduces to.
    #[serde(rename = "reducesTo")]
    pub reduces_to: f64,
    /// Relationship dynamics for this birth day.
    pub relationships: String,
    /// Strengths specific to this birth day.
    pub strengths: Vec<String>,
    /// Unique archetype title for this specific birth day.
    pub title: String,
}
/// Additional numerology insights: karmic analysis, yearly/monthly forecasts, pinnacles, challenges, hidden passion, subconscious self, and name letter analysis.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseAdditionalInsights {
    /// Four Challenge numbers representing life obstacles. The 3rd (Main) Challenge lasts for life; the other three are timed approximately with the Pinnacle phases.
    pub challenges: Vec<GenerateNumerologyChartResponseAdditionalInsightsChallengesItem>,
    /// Hidden Passion number. The most frequent number in the name revealing an overwhelming drive or talent.
    #[serde(rename = "hiddenPassion")]
    pub hidden_passion: GenerateNumerologyChartResponseAdditionalInsightsHiddenPassion,
    /// Karmic Debt analysis. Identifies unresolved karma from past lives carried through specific numbers (13, 14, 16, 19).
    #[serde(rename = "karmicDebt")]
    pub karmic_debt: GenerateNumerologyChartResponseAdditionalInsightsKarmicDebt,
    /// Karmic Lessons analysis. Identifies lessons the soul needs to learn based on missing numbers in the birth name.
    #[serde(rename = "karmicLessons")]
    pub karmic_lessons: GenerateNumerologyChartResponseAdditionalInsightsKarmicLessons,
    /// Name letter analysis: Cornerstone, Capstone, and First Vowel.
    #[serde(rename = "nameLetters")]
    pub name_letters: GenerateNumerologyChartResponseAdditionalInsightsNameLetters,
    /// Personal Year forecast with nested Personal Month. Yearly and monthly numerology cycles.
    #[serde(rename = "personalYear")]
    pub personal_year: GenerateNumerologyChartResponseAdditionalInsightsPersonalYear,
    /// Four Pinnacle numbers representing major life phases, master numbers 11, 22 and 33 kept, with age ranges and meanings.
    pub pinnacles: Vec<GenerateNumerologyChartResponseAdditionalInsightsPinnaclesItem>,
    /// Subconscious Self number. Reveals inner confidence and emergency response style.
    #[serde(rename = "subconsciousSelf")]
    pub subconscious_self: GenerateNumerologyChartResponseAdditionalInsightsSubconsciousSelf,
}
/// Subconscious Self number. Reveals inner confidence and emergency response style.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseAdditionalInsightsSubconsciousSelf {
    /// How you handle emergencies and unexpected challenges based on the breadth of numbers in your name.
    pub description: String,
    /// Subconscious Self number (1-9). Count of unique numbers present in the name.
    pub number: f64,
    /// Archetype title for this Subconscious Self level.
    pub title: String,
    /// Which numbers (1-9) are present in the birth name.
    #[serde(rename = "uniqueNumbers")]
    pub unique_numbers: Vec<f64>,
}
/// One entry of `pinnacles`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseAdditionalInsightsPinnaclesItem {
    /// Last whole age of this phase, inclusive. The First Pinnacle ends at 36 minus the Life Path reduced to one digit and each later phase starts the year after; null for the 4th Pinnacle (lasts rest of life).
    #[serde(rename = "endAge")]
    pub end_age: Option<f64>,
    /// Meaning and interpretation for this Pinnacle number.
    pub meaning: GenerateNumerologyChartResponseAdditionalInsightsPinnaclesItemMeaning,
    /// Pinnacle number (1-9, 11, 22, 33). Defines the theme of this life phase.
    pub number: f64,
    /// Pinnacle position (1-4). Four major life phases.
    pub position: f64,
    /// Age when this Pinnacle phase begins.
    #[serde(rename = "startAge")]
    pub start_age: f64,
}
/// Meaning and interpretation for this Pinnacle number.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseAdditionalInsightsPinnaclesItemMeaning {
    /// Challenges to navigate during this phase.
    pub challenges: Vec<String>,
    /// What this Pinnacle phase brings to your life.
    pub description: String,
    /// Key opportunities during this phase.
    pub opportunities: Vec<String>,
    /// Pinnacle phase title.
    pub title: String,
}
/// Personal Year forecast with nested Personal Month. Yearly and monthly numerology cycles.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseAdditionalInsightsPersonalYear {
    /// Strategic guidance for making the most of this Personal Year. Covers timing decisions, areas to focus on, and the mindset that aligns with the current numerological energy.
    pub advice: String,
    /// Potential challenges to navigate during this cycle. Each entry identifies a recurring theme or obstacle and how to work with the energy rather than against it.
    pub challenges: Vec<String>,
    /// Position in the 9-year numerology cycle (e.g., "Year 5 of 9"). Each position carries distinct energy that shapes the entire year.
    pub cycle: String,
    /// Detailed yearly forecast covering what to expect across career, relationships, health, and personal development. Provides month-by-month energy shifts and key turning points.
    pub forecast: String,
    /// Key opportunities available during this Personal Year. Each entry identifies a specific area of life where conditions are favorable for growth and forward momentum.
    pub opportunities: Vec<String>,
    /// Personal Month forecast for the current UTC calendar month, applied to the Personal Year above. With a currentYear other than the current year, it pairs that Personal Year with the current month.
    #[serde(rename = "personalMonth")]
    pub personal_month: GenerateNumerologyChartResponseAdditionalInsightsPersonalYearPersonalMonth,
    /// Personal Year number (1-9). Each year in the 9-year cycle has distinct themes and energies.
    #[serde(rename = "personalYear")]
    pub personal_year: f64,
    /// Central theme and energy defining this Personal Year. Provides a one-line summary of the dominant vibration influencing all areas of life.
    pub theme: String,
}
/// Personal Month forecast for the current UTC calendar month, applied to the Personal Year above. With a currentYear other than the current year, it pairs that Personal Year with the current month.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseAdditionalInsightsPersonalYearPersonalMonth {
    /// Practical focus and guidance for this month.
    pub focus: String,
    /// Personal Month number (1-9): the Personal Year above plus the current UTC calendar month, reduced to one digit.
    #[serde(rename = "personalMonth")]
    pub personal_month: f64,
    /// Central theme for this Personal Month.
    pub theme: String,
}
/// Name letter analysis: Cornerstone, Capstone, and First Vowel.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseAdditionalInsightsNameLetters {
    /// Capstone letter analysis. Reveals completion and follow-through style.
    pub capstone: GenerateNumerologyChartResponseAdditionalInsightsNameLettersCapstone,
    /// Cornerstone letter analysis. Reveals approach to new situations.
    pub cornerstone: GenerateNumerologyChartResponseAdditionalInsightsNameLettersCornerstone,
    /// First Vowel analysis. Reveals instinctive emotional reactions.
    #[serde(rename = "firstVowel")]
    pub first_vowel: GenerateNumerologyChartResponseAdditionalInsightsNameLettersFirstVowel,
}
/// First Vowel analysis. Reveals instinctive emotional reactions.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseAdditionalInsightsNameLettersFirstVowel {
    /// First vowel of the first name (A, E, I, O or U). A first name with none of them takes its Y, the vowel sound of names like Lynn; one with no Y either takes the first A, E, I, O or U of the rest of the name.
    pub letter: String,
    /// Instinctive emotional response and inner reaction style.
    pub meaning: String,
}
/// Cornerstone letter analysis. Reveals approach to new situations.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseAdditionalInsightsNameLettersCornerstone {
    /// First letter of the first name.
    pub letter: String,
    /// How you approach new situations and initiate action.
    pub meaning: String,
    /// Pythagorean number value of the Cornerstone letter.
    pub number: f64,
}
/// Capstone letter analysis. Reveals completion and follow-through style.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseAdditionalInsightsNameLettersCapstone {
    /// Last letter of the first name.
    pub letter: String,
    /// How you complete tasks and handle endings.
    pub meaning: String,
    /// Pythagorean number value of the Capstone letter.
    pub number: f64,
}
/// Karmic Lessons analysis. Identifies lessons the soul needs to learn based on missing numbers in the birth name.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseAdditionalInsightsKarmicLessons {
    /// Detailed karmic lessons for each missing number.
    pub lessons: Vec<
        GenerateNumerologyChartResponseAdditionalInsightsKarmicLessonsLessonsItem,
    >,
    /// Numbers (1-9) missing from the birth name. Each missing number represents a karmic lesson to learn in this lifetime.
    #[serde(rename = "missingNumbers")]
    pub missing_numbers: Vec<f64>,
    /// Count of each number (1-9) present in the birth name. High counts indicate natural strengths.
    #[serde(rename = "presentNumbers")]
    pub present_numbers: GenerateNumerologyChartResponseAdditionalInsightsKarmicLessonsPresentNumbers,
}
/// Count of each number (1-9) present in the birth name. High counts indicate natural strengths.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseAdditionalInsightsKarmicLessonsPresentNumbers {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, f64>,
}
/// One entry of `lessons`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseAdditionalInsightsKarmicLessonsLessonsItem {
    /// What this missing number means for personal growth. Explains the life patterns, recurring situations, and soul-level work required to integrate this energy.
    pub description: String,
    /// Actionable guidance for mastering this karmic lesson. Includes specific behaviors, mindset shifts, and daily practices that build the missing quality over time.
    #[serde(rename = "howToOvercome")]
    pub how_to_overcome: String,
    /// Karmic lesson title identifying the core quality or virtue this soul needs to develop in the current lifetime.
    pub lesson: String,
    /// The missing number representing this karmic lesson.
    pub number: f64,
}
/// Karmic Debt analysis. Identifies unresolved karma from past lives carried through specific numbers (13, 14, 16, 19).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseAdditionalInsightsKarmicDebt {
    /// List of karmic debt numbers found (13=laziness, 14=abuse of freedom, 16=ego destruction, 19=selfishness), each listed once, in core-number order: Life Path, Expression, Soul Urge, Personality, Birth Day.
    #[serde(rename = "debtNumbers")]
    pub debt_numbers: Vec<f64>,
    /// True if any core number reduces through a karmic debt number (13, 14, 16, 19).
    #[serde(rename = "hasKarmicDebt")]
    pub has_karmic_debt: bool,
    /// Detailed meanings for each karmic debt number found.
    pub meanings: Vec<
        GenerateNumerologyChartResponseAdditionalInsightsKarmicDebtMeaningsItem,
    >,
}
/// One entry of `meanings`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseAdditionalInsightsKarmicDebtMeaningsItem {
    /// The central life challenge this debt creates. Identifies the repeating obstacle pattern and the emotional or behavioral trap to watch for.
    pub challenge: String,
    /// What this karmic debt means for your current lifetime. Explains the past-life pattern, how it manifests today, and why certain struggles keep recurring.
    pub description: String,
    /// Karmic debt number (13, 14, 16, or 19). Each represents a specific pattern of unresolved karma from past lives that demands conscious attention.
    pub number: f64,
    /// How to resolve and transcend this karmic debt. Provides the spiritual lesson, practical steps, and the transformative shift that breaks the cycle.
    pub resolution: String,
}
/// Hidden Passion number. The most frequent number in the name revealing an overwhelming drive or talent.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseAdditionalInsightsHiddenPassion {
    /// All numbers tied for highest frequency, in ascending order (usually one, sometimes multiple).
    #[serde(rename = "allPassions")]
    pub all_passions: Vec<f64>,
    /// How many times this number appears in the name.
    pub count: f64,
    /// What this dominant number drive reveals about latent talents and obsessions.
    pub description: String,
    /// Hidden Passion number (1-9). The most frequently occurring number in the birth name; when several tie, the lowest of them.
    pub number: f64,
    /// Archetype title for this Hidden Passion.
    pub title: String,
}
/// One entry of `challenges`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseAdditionalInsightsChallengesItem {
    /// Last whole age of the period, inclusive, approximate as startAge explains. Null for the 3rd (Main) Challenge and the 4th, which last for life.
    #[serde(rename = "endAge")]
    pub end_age: Option<f64>,
    /// Meaning and resolution guidance for this Challenge number.
    pub meaning: GenerateNumerologyChartResponseAdditionalInsightsChallengesItemMeaning,
    /// Challenge number (0-8). Defines the obstacle of this period.
    pub number: f64,
    /// Challenge position (1-4). Four life obstacle periods.
    pub position: f64,
    /// Age when this Challenge is most felt. The 3rd (Main) Challenge starts at 0 and lasts for life; the 1st, 2nd and 4th take the ages of their Pinnacle phase as an approximation, since Challenges have no fixed durations.
    #[serde(rename = "startAge")]
    pub start_age: f64,
}
/// Meaning and resolution guidance for this Challenge number.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartResponseAdditionalInsightsChallengesItemMeaning {
    /// What this Challenge demands you overcome.
    pub description: String,
    /// Actionable guidance for working through this Challenge.
    #[serde(rename = "howToOvercome")]
    pub how_to_overcome: String,
    /// Core lesson to learn during this period.
    pub lesson: String,
    /// Challenge title.
    pub title: String,
}
/// Path and query parameters of `generateNumerologyChart`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateNumerologyChartParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateNumerologyChartParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateNumerologyChartParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `generateNavamsa`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateNavamsaParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateNavamsaParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateNavamsaParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `generateNatalChart`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateNatalChartParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateNatalChartParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateNatalChartParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `generateNameProfile`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNameProfileResponse {
    /// The `chosen` field.
    pub chosen: GenerateNameProfileResponseChosen,
    /// The `conventions` field.
    pub conventions: GenerateNameProfileResponseConventions,
    /// Every Hebrew spelling the name can be written as, greedy parse first. One entry when Hebrew was sent, since there is nothing to choose.
    #[serde(rename = "hebrewForms")]
    pub hebrew_forms: Vec<GenerateNameProfileResponseHebrewFormsItem>,
    /// The `input` field.
    pub input: GenerateNameProfileResponseInput,
    /// The per letter breakdown of the chosen spelling.
    pub letters: Vec<GenerateNameProfileResponseLettersItem>,
    /// Curated words whose standard value equals the name. Empty when nothing matches, which is the ordinary case.
    pub matches: Vec<GenerateNameProfileResponseMatchesItem>,
    /// Where the name lands on the tree. The reduction is a numerical convention, not a rule from any text, and the reading says so.
    pub sephirah: GenerateNameProfileResponseSephirah,
    /// The four readings a name profile leads with. Call the gematria endpoint for the full set and for the substitution transformations.
    pub values: GenerateNameProfileResponseValues,
}
/// The four readings a name profile leads with. Call the gematria endpoint for the full set and for the substitution transformations.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNameProfileResponseValues {
    /// Mispar gadol under the reading the misparGadol convention selected, which is why the convention comes back on the response.
    pub large: f64,
    /// Mispar kidmi, where each letter scores the sum of every standard value up to and including itself, so tav is 1495.
    pub preceding: f64,
    /// Mispar katan, where each letter value has its trailing zeros truncated, so yod is 1 and qof is 1.
    pub small: f64,
    /// Mispar hechrachi, the standard reading, where every letter takes its ordinary value and a final form scores as its base letter.
    pub standard: f64,
}
/// Where the name lands on the tree. The reduction is a numerical convention, not a rule from any text, and the reading says so.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNameProfileResponseSephirah {
    /// The English gloss of the name, in the requested language.
    pub english: String,
    /// The name in Hebrew. Data, identical in every language.
    pub hebrew: String,
    /// Machine identifier of the sephirah the reduced value points at.
    pub id: String,
    /// What the emanation is said to hold, in the requested language.
    pub meaning: String,
    /// Its position in the emanation, 1 to 10.
    pub number: Option<f64>,
    /// The composed sentence that places the name on the tree, in the requested language. It states plainly that the reduction is a numerical convention rather than a classical rule.
    pub reading: String,
    /// The standard value reduced by repeated digit sum, stopping at ten so all ten emanations stay reachable.
    pub reduced: f64,
}
/// One entry of `matches`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNameProfileResponseMatchesItem {
    /// The word in Hebrew. Data, identical in every language.
    pub hebrew: String,
    /// Machine identifier of the entry, an ASCII romanization.
    pub id: String,
    /// What the word means, in the requested language.
    pub meaning: String,
    /// What the tradition says about the equality, in the requested language.
    pub note: String,
    /// Latin transcription of the Hebrew beside it, from the same mechanical letter map.
    pub romanization: String,
    /// Where the value is attested. Every entry in the lexicon carries at least two independent sources, which is why the list is short rather than long.
    pub sources: Vec<String>,
    /// Its value under the standard reading, which is why it matched.
    pub value: f64,
}
/// One entry of `letters`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNameProfileResponseLettersItem {
    /// The letter as it stands in the chosen spelling.
    pub glyph: String,
    /// True when the glyph is the word final form.
    #[serde(rename = "isFinal")]
    pub is_final: bool,
    /// Machine identifier of the letter.
    #[serde(rename = "letterId")]
    pub letter_id: String,
    /// Display name of the letter.
    pub name: String,
    /// What this letter contributed.
    pub value: f64,
}
/// The `input` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNameProfileResponseInput {
    /// Echo of the Latin name sent. Absent when Hebrew was sent instead.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Echo of the Hebrew name sent. Absent when Latin was sent instead.
    #[serde(rename = "nameHebrew", skip_serializing_if = "Option::is_none")]
    pub name_hebrew: Option<String>,
}
/// One entry of `hebrewForms`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNameProfileResponseHebrewFormsItem {
    /// One Hebrew spelling the Latin input can be written as. Data, identical in every language.
    pub hebrew: String,
    /// The per letter breakdown of this spelling under the standard reading.
    pub letters: Vec<GenerateNameProfileResponseHebrewFormsItemLettersItem>,
    /// Latin transcription of the Hebrew beside it, produced by one mechanical letter map. It is a label for reading the string back, never a pronunciation claim.
    pub romanization: String,
    /// Why this spelling came out of the map: the parse rule first, then one sentence for every reading the scheme applied that the letters alone would not show, so a caller can tell the parses apart.
    pub rule: String,
    /// Every computed cipher applied to this spelling, in catalogue order. The rows carry no display name, because they are the same ciphers in the same order for every spelling: read the names off the top level values array once.
    pub values: Vec<GenerateNameProfileResponseHebrewFormsItemValuesItem>,
}
/// One entry of `values`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNameProfileResponseHebrewFormsItemValuesItem {
    /// Other published totals for the same string, ascending. Present only where the cipher is not single valued: letter names have several accepted spellings, so several totals are equally published. Absent otherwise, so a caller can branch on presence.
    #[serde(rename = "alternateValues", skip_serializing_if = "Option::is_none")]
    pub alternate_values: Option<Vec<f64>>,
    /// Machine identifier of the cipher. Call the ciphers endpoint for the definition, the tradition and the sources behind each one.
    pub id: String,
    /// The first published source this cipher was taken from.
    pub source: String,
    /// Provenance class of the cipher, one of rabbinic, renaissance-latin, golden-dawn-transliterated or modern. Always English, so it stays safe to compare against in code.
    pub tradition: String,
    /// The number this cipher gives for the string. Always a number: the one catalogued cipher this API does not compute is absent from this array rather than present without a value, so no row here has to be guarded. Its catalogue entry carries computed false and says why.
    pub value: f64,
}
/// One entry of `letters`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNameProfileResponseHebrewFormsItemLettersItem {
    /// The Hebrew letter as it stands in the string. Data, identical in every language.
    pub glyph: String,
    /// True when the glyph is the word final form. Under the finals-500-900 reading the same letter scores differently in final position, which is why this is on the row.
    #[serde(rename = "isFinal")]
    pub is_final: bool,
    /// Machine identifier of the letter, always English romanization so it stays safe to compare against in code.
    #[serde(rename = "letterId")]
    pub letter_id: String,
    /// Display name of the letter, in the requested language. Branch on letterId, never on this.
    pub name: String,
    /// What this letter contributed under the standard reading, or under the finals reading when one applies.
    pub value: f64,
}
/// The `conventions` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNameProfileResponseConventions {
    /// Which of the two published methods the name mispar gadol was read as.
    #[serde(rename = "misparGadol")]
    pub mispar_gadol: String,
    /// The Latin to Hebrew scheme applied. Absent when the caller sent Hebrew directly.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transliteration: Option<String>,
}
/// The `chosen` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNameProfileResponseChosen {
    /// The spelling the rest of this response was computed from.
    pub hebrew: String,
    /// Latin transcription of the chosen spelling, from the mechanical map.
    pub romanization: String,
    /// Why this spelling was chosen over the others.
    pub rule: String,
}
/// The name to profile. Send name for a Latin input or nameHebrew for a Hebrew one, never both: which one you send decides whether a transliteration step runs at all.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateNameProfileRequest {
    /// Which method the name mispar gadol means, because the sources use it for two. Use finals-500-900 to score the five word final letters as 500 to 900, or milui to score each letter as the value of its own spelled out name.
    #[serde(rename = "misparGadol", skip_serializing_if = "Option::is_none")]
    pub mispar_gadol: Option<GenerateNameProfileRequestMisparGadol>,
    /// The name in Latin script, to be written in Hebrew and then scored. Non Latin scripts are folded to Latin first. Send nameHebrew instead to control the spelling yourself.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// The name already in Hebrew, which skips the transliteration step entirely and scores exactly the spelling you sent.
    #[serde(rename = "nameHebrew", skip_serializing_if = "Option::is_none")]
    pub name_hebrew: Option<String>,
    /// How a Latin name is written in Hebrew before it is scored. Two members. letter-map-mathers is the 1887 Hermetic letter map, with e read as its author practised it: a point inside a word and alef at the start of one. It writes no c, f, w or x, so a name carrying one of them outside a two letter group returns 400 naming the letter. letter-map-modern follows the modern Israeli transcription rules for the sound each Latin letter carries in English and French spelling, covers every Latin letter, drops the geresh and does not double vav or yod, so send textHebrew for the ktiv male form. Every form states the readings it used in rule. Phonetic Ashkenazi and Sephardi schemes are not offered because no two references agree on a rule for that direction.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transliteration: Option<GenerateNameProfileRequestTransliteration>,
}
string_enum! {
    /// How a Latin name is written in Hebrew before it is scored. Two members. letter-map-mathers is the 1887 Hermetic letter map, with e read as its author practised it: a point inside a word and alef at the start of one. It writes no c, f, w or x, so a name carrying one of them outside a two letter group returns 400 naming the letter. letter-map-modern follows the modern Israeli transcription rules for the sound each Latin letter carries in English and French spelling, covers every Latin letter, drops the geresh and does not double vav or yod, so send textHebrew for the ktiv male form. Every form states the readings it used in rule. Phonetic Ashkenazi and Sephardi schemes are not offered because no two references agree on a rule for that direction.
    GenerateNameProfileRequestTransliteration {
        LetterMapMathers = "letter-map-mathers",
        LetterMapModern = "letter-map-modern",
    }
}
string_enum! {
    /// Which method the name mispar gadol means, because the sources use it for two. Use finals-500-900 to score the five word final letters as 500 to 900, or milui to score each letter as the value of its own spelled out name.
    GenerateNameProfileRequestMisparGadol {
        Finals500900 = "finals-500-900",
        Milui = "milui",
    }
}
/// Path and query parameters of `generateNameProfile`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateNameProfileParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateNameProfileParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateNameProfileParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `generateMayanChart`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMayanChartResponse {
    /// The Tzolkin and Haab dates written together, which is how a Classic inscription names a day. The pair repeats every 18,980 days, a little under 52 years, so a Calendar Round alone is ambiguous beyond one lifetime and the Long Count is what disambiguates it.
    #[serde(rename = "calendarRound")]
    pub calendar_round: String,
    /// The conventions this chart was computed under, echoed so the result is self describing. Store both beside any chart you persist.
    pub conventions: GenerateMayanChartResponseConventions,
    /// The Cruz Maya, the five point nawal cross, with source convention. This is a LIVING DAYKEEPER PRACTICE rather than an archaeological reconstruction: no academic source describes a five point cross, and the day offsets here were measured against two independent practitioner calculators that agree. It is published because practitioners use it, and it is labelled because that is what honesty about a source looks like.
    pub cross: Vec<GenerateMayanChartResponseCrossItem>,
    /// Echo of the date the chart was computed from, in proleptic Gregorian.
    pub date: String,
    /// The 365 day vague year: eighteen periods of twenty days plus the five days of Wayebʼ. This is the agricultural year the Tzolkin runs against.
    pub haab: GenerateMayanChartResponseHaab,
    /// The linear day count from the mythological start of the era, written in five positions. Unlike the two round calendars this one never repeats, which is what lets an inscription name an absolute date.
    #[serde(rename = "longCount")]
    pub long_count: GenerateMayanChartResponseLongCount,
    /// The nine day cycle that runs beside the other three. The nine are identified and the cycle is unambiguous, but no source records what the Maya called them, so this API publishes the labels rather than borrowing names from a neighbouring culture.
    #[serde(rename = "lordOfNight")]
    pub lord_of_night: GenerateMayanChartResponseLordOfNight,
    /// One composed sentence placing the day in all three calendars, for a card headline or a chat reply.
    pub summary: String,
    /// The 260 day sacred round: the day sign, its coefficient and the trecena it falls in. This is the cycle a nawal reading is built on.
    pub tzolkin: GenerateMayanChartResponseTzolkin,
    /// The Tzolkin day that names the Haab year this date falls in, under the requested school.
    #[serde(rename = "yearBearer")]
    pub year_bearer: GenerateMayanChartResponseYearBearer,
}
/// The Tzolkin day that names the Haab year this date falls in, under the requested school.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMayanChartResponseYearBearer {
    /// Machine identifier of the day sign carrying the Haab year this date falls in. Only four of the twenty can ever carry a year, and which four depends on the school.
    #[serde(rename = "daySign")]
    pub day_sign: String,
    /// Display name of the bearing sign. A proper noun carried as data.
    #[serde(rename = "daySignName")]
    pub day_sign_name: String,
    /// Coefficient of the bearing day, 1 to 13. The coefficient advances by one each Haab year, which is what makes the bearer and the number together repeat only every 52 years.
    pub number: f64,
    /// One line on the year bearer that names the school it was read under, because the three schools name three different bearers for the same year.
    pub reading: String,
}
/// The 260 day sacred round: the day sign, its coefficient and the trecena it falls in. This is the cycle a nawal reading is built on.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMayanChartResponseTzolkin {
    /// Machine identifier of the Tzolkin day sign, always lowercase ASCII Yucatec whatever the lang parameter says, so it stays safe to compare against in code. The twenty ids run imix, ik, akbal, kan, chikchan, kimi, manik, lamat, muluk, ok, chuwen, eb, ben, ix, men, kib, kaban, etznab, kawak, ajaw.
    #[serde(rename = "daySign")]
    pub day_sign: String,
    /// The sixteenth century Yucatec spelling of the same sign, which is the form most printed reference tables and older sources use. Useful for matching a name a reader copied out of a book.
    #[serde(rename = "daySignClassic")]
    pub day_sign_classic: String,
    /// The Kʼicheʼ name of the same day from the living highland daykeeping tradition, which is the vocabulary a nawal reading in Guatemala uses. A parallel naming tradition rather than a translation, so it is identical under every lang.
    #[serde(rename = "daySignKiche")]
    pub day_sign_kiche: String,
    /// Display name of the day sign in the standard Maya orthography, where the ejective is written with a modifier letter rather than a typewriter quote. A proper noun carried as data, so it is identical under every lang.
    #[serde(rename = "daySignName")]
    pub day_sign_name: String,
    /// The Tzolkin coefficient, 1 to 13. This is the classical day number that runs alongside the twenty signs; it is not a rank and a 13 is not better than a 1. Nine of the thirteen carry a recorded character, which is returned separately.
    pub number: f64,
    /// The composed nawal reading for the Tzolkin day.
    pub reading: GenerateMayanChartResponseTzolkinReading,
    /// The thirteen day period this day belongs to. The trecena is the unit a daykeeper reads a run of days in, and the sign it opens on is what gives the whole period its character.
    pub trecena: GenerateMayanChartResponseTzolkinTrecena,
}
/// The thirteen day period this day belongs to. The trecena is the unit a daykeeper reads a run of days in, and the sign it opens on is what gives the whole period its character.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMayanChartResponseTzolkinTrecena {
    /// Position of this day inside its trecena, 1 to 13. Always equal to the coefficient, because a trecena is exactly one run of the coefficient.
    #[serde(rename = "dayOfTrecena")]
    pub day_of_trecena: f64,
    /// Which of the twenty thirteen day periods this day falls in, 1 to 20. Trecena 1 opens on 1 Imix.
    pub number: f64,
    /// Machine identifier of the day sign the trecena opens on, which the tradition reads as colouring all thirteen of its days.
    #[serde(rename = "rulingSign")]
    pub ruling_sign: String,
    /// Display name of the sign the trecena opens on. A proper noun carried as data.
    #[serde(rename = "rulingSignName")]
    pub ruling_sign_name: String,
}
/// The composed nawal reading for the Tzolkin day.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMayanChartResponseTzolkinReading {
    /// Where the same temperament costs the sign something. Each one is the shadow of a strength above rather than an unrelated flaw.
    pub challenges: Vec<String>,
    /// The one thing worth doing differently under this sign.
    pub guidance: String,
    /// The sign in one composed sentence: its name in both naming traditions, what it is about, and the glyph reading behind it. Composed per request from the sign components rather than stored whole, which is why it stays consistent with every other reading in the response.
    pub keynote: String,
    /// Machine identifier of the recorded character of the coefficient: gentle, indifferent or violent. ABSENT for coefficients 4, 5, 6 and 10, which have no recorded character in any consulted source. Always English so it stays safe to switch on.
    #[serde(rename = "numberBand", skip_serializing_if = "Option::is_none")]
    pub number_band: Option<String>,
    /// What the coefficient contributes. Nine of the thirteen carry a recorded character, banded as gentle, indifferent or violent; the other four carry none and this field says so rather than inventing one. The band ids are the source vocabulary, so violent names the days reserved for strong ceremony and defence and is not a warning.
    #[serde(rename = "numberReading")]
    pub number_reading: String,
    /// What the sign does well, as full sentences rather than keywords.
    pub strengths: Vec<String>,
}
/// The nine day cycle that runs beside the other three. The nine are identified and the cycle is unambiguous, but no source records what the Maya called them, so this API publishes the labels rather than borrowing names from a neighbouring culture.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMayanChartResponseLordOfNight {
    /// Which of the nine Lords of the Night governs this day, G1 to G9. The cycle steps forward one per day and closes every nine.
    pub label: String,
    /// One line on the night lord, including why the nine carry labels rather than names.
    pub reading: String,
}
/// The linear day count from the mythological start of the era, written in five positions. Unlike the two round calendars this one never repeats, which is what lets an inscription name an absolute date.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMayanChartResponseLongCount {
    /// Baktun, the highest of the five positions. One baktun is 144,000 days.
    pub baktun: f64,
    /// The whole Long Count as a single integer count of days from the epoch. Subtracting two of these is the correct way to measure an interval, and it is the number the Tzolkin, the Haab and the night lord are all derived from.
    #[serde(rename = "daysSinceEpoch")]
    pub days_since_epoch: f64,
    /// The dotted Long Count, most significant position first. This is the spelling every reference converter and every inscription uses.
    pub formatted: String,
    /// Julian Day Number of the same day, which is the bridge between this count and any other calendar. Adding the correlation constant to daysSinceEpoch gives exactly this.
    #[serde(rename = "julianDayNumber")]
    pub julian_day_number: f64,
    /// Katun, 0 to 19. One katun is 7,200 days, roughly twenty years.
    pub katun: f64,
    /// Kin, 0 to 19. One kin is one day.
    pub kin: f64,
    /// Tun, 0 to 19. One tun is 360 days, which is why this position sits roughly a year apart.
    pub tun: f64,
    /// Winal, 0 to 17 and never 19. This is the one position that is not base twenty: eighteen winal make a tun, which is what keeps the tun near a solar year.
    pub winal: f64,
}
/// The 365 day vague year: eighteen periods of twenty days plus the five days of Wayebʼ. This is the agricultural year the Tzolkin runs against.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMayanChartResponseHaab {
    /// Day inside the period, 0 to 19, or 0 to 4 in Wayebʼ. Day 0 is a real date and is called the seating of the period, so a Haab month has no day 20. Numbering from 1 instead is the usual way to be one day wrong on every Haab date.
    pub day: f64,
    /// Day of the 365 day Haab year, 0 to 364. The Haab has no leap day at all, so it drifts against the solar year by about a day every four years and there is nothing to correct.
    #[serde(rename = "dayOfYear")]
    pub day_of_year: f64,
    /// Machine identifier of the Haab period, always lowercase ASCII. The nineteen ids run pop, wo, sip, sotz, sek, xul, yaxkin, mol, chen, yax, sak, keh, mak, kankin, muwan, pax, kayab, kumku, wayeb.
    pub month: String,
    /// The sixteenth century Yucatec spelling of the same period, which is the form most printed tables use.
    #[serde(rename = "monthClassic")]
    pub month_classic: String,
    /// Display name of the Haab period in the standard orthography. A proper noun carried as data, so it is identical under every lang.
    #[serde(rename = "monthName")]
    pub month_name: String,
    /// Composed reading of the Haab date, which reads differently on the seating day of a period.
    pub reading: String,
}
/// One entry of `cross`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMayanChartResponseCrossItem {
    /// Machine identifier of the day sign standing at this point.
    #[serde(rename = "daySign")]
    pub day_sign: String,
    /// Kʼicheʼ name of the same sign, which is the vocabulary a cross is normally read in.
    #[serde(rename = "daySignKiche")]
    pub day_sign_kiche: String,
    /// Display name of the sign at this point. A proper noun carried as data.
    #[serde(rename = "daySignName")]
    pub day_sign_name: String,
    /// Coefficient of the day at this point, 1 to 13.
    pub number: f64,
    /// Days from the birth day to this arm. Negative is before the birth day. Conception is minus eight, destiny plus eight, the left arm plus six and the right arm minus six.
    #[serde(rename = "offsetDays")]
    pub offset_days: f64,
    /// Which point of the cross this is: center, conception, destiny, left or right. Always English so it stays safe to switch on. The arms are published as left and right and carry no gender, because the sources that agree on the SIGNS disagree on which arm is masculine and which feminine.
    pub position: String,
    /// One line on what this point of the cross is read as.
    pub reading: String,
}
/// The conventions this chart was computed under, echoed so the result is self describing. Store both beside any chart you persist.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMayanChartResponseConventions {
    /// The correlation constant actually applied, whether it was requested or defaulted. Store this beside any Maya date you persist: the same civil date resolves to a different Long Count under each constant, and a date with no correlation recorded cannot be reproduced.
    pub correlation: String,
    /// The Year Bearer school actually applied. The three schools name three different bearers for the same Haab year, so a bearer stored without this value cannot be checked against anything.
    #[serde(rename = "yearBearerSystem")]
    pub year_bearer_system: String,
}
/// Request body of `generateMayanChart`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMayanChartRequest {
    /// Which correlation constant ties the day count to a civil date. This is the single choice that shifts every value in the response, so it is a parameter rather than a hidden default, and the resolved value comes back under conventions. "gmt-584283" is the commonly accepted constant and the default, and it is the one the major institutional converter runs on. "martinez-hernandez-584281" sits two days earlier, "astronomical-584285" two days later, and "martin-skidmore-584286" three days later, each shifting the Long Count by exactly its difference in days. Four of the eight published constants are offered: the other four sit tens of thousands of days away and are of historical interest only. The 584281 constant is the Martínez Hernández correlation, after Juan Martínez Hernández.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub correlation: Option<GenerateMayanChartRequestCorrelation>,
    /// Date in YYYY-MM-DD format, in the PROLEPTIC GREGORIAN calendar, extended backwards unchanged through the 1582 reform. Years 1 to 4000 are accepted. A reference converter that switches to the Julian calendar below the reform will disagree with a date before 15 October 1582 by ten or eleven days; that is a difference of input convention rather than of arithmetic, and passing the Julian equivalent to such a tool reproduces these values exactly. A single-digit month or day is accepted and zero padded.
    pub date: String,
    /// Which Haab day is read as the start of the year when naming its Year Bearer. Only four of the twenty day signs can ever carry a year, and which four depends entirely on this choice, so the three schools never agree. "classic" reads the seating of Pop and is the default, because it is the set highland daykeepers still use; its four bearers are Ikʼ, Manikʼ, Ebʼ and Kabʼan. "campeche" reads 1 Pop and gives Akʼbʼal, Lamat, Bʼen and Etzʼnabʼ. "colonial-yucatec" reads 2 Pop and gives Kʼan, Muluk, Ix and Kawak. The three sets share no member, so a bearer alone tells you which school produced it.
    #[serde(rename = "yearBearerSystem", skip_serializing_if = "Option::is_none")]
    pub year_bearer_system: Option<GenerateMayanChartRequestYearBearerSystem>,
}
string_enum! {
    /// Which Haab day is read as the start of the year when naming its Year Bearer. Only four of the twenty day signs can ever carry a year, and which four depends entirely on this choice, so the three schools never agree. "classic" reads the seating of Pop and is the default, because it is the set highland daykeepers still use; its four bearers are Ikʼ, Manikʼ, Ebʼ and Kabʼan. "campeche" reads 1 Pop and gives Akʼbʼal, Lamat, Bʼen and Etzʼnabʼ. "colonial-yucatec" reads 2 Pop and gives Kʼan, Muluk, Ix and Kawak. The three sets share no member, so a bearer alone tells you which school produced it.
    GenerateMayanChartRequestYearBearerSystem {
        Classic = "classic",
        Campeche = "campeche",
        ColonialYucatec = "colonial-yucatec",
    }
}
string_enum! {
    /// Which correlation constant ties the day count to a civil date. This is the single choice that shifts every value in the response, so it is a parameter rather than a hidden default, and the resolved value comes back under conventions. "gmt-584283" is the commonly accepted constant and the default, and it is the one the major institutional converter runs on. "martinez-hernandez-584281" sits two days earlier, "astronomical-584285" two days later, and "martin-skidmore-584286" three days later, each shifting the Long Count by exactly its difference in days. Four of the eight published constants are offered: the other four sit tens of thousands of days away and are of historical interest only. The 584281 constant is the Martínez Hernández correlation, after Juan Martínez Hernández.
    GenerateMayanChartRequestCorrelation {
        Gmt584283 = "gmt-584283",
        MartinezHernandez584281 = "martinez-hernandez-584281",
        Astronomical584285 = "astronomical-584285",
        MartinSkidmore584286 = "martin-skidmore-584286",
    }
}
/// Path and query parameters of `generateMayanChart`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateMayanChartParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateMayanChartParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateMayanChartParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `generateMandala`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMandalaResponse {
    /// The nine squares where the six vamsa lines cross. 53.63 asserts nine points and lists none, so these are computed by intersecting the lines rather than transcribed. They are the centre, the four corners of the Brahma block and the four cardinal squares of the second ring. Present only on the 81 pada grid.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub atimarma: Option<Vec<f64>>,
    /// The central block of the mandala. Nine squares on the Paramasayika and four on the Manduka.
    pub brahmasthan: GenerateMandalaResponseBrahmasthan,
    /// Every square of the projected mandala, row-major from the north-west. 81 entries on the Paramasayika and 64 on the Manduka.
    pub cells: Vec<GenerateMandalaResponseCellsItem>,
    /// The switches this projection resolved, echoed so a stored response can be reproduced later.
    pub conventions: GenerateMandalaResponseConventions,
    /// Which division was projected, echoing the resolved value.
    pub grid: String,
    /// The vital spots of the mandala. Present on the 81 pada grid, where 53.57 and 53.64 state the rule and its size. Absent on the 64 pada grid, for which the chapter states neither.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub marma: Option<GenerateMandalaResponseMarma>,
    /// Every verse this projection rests on: the grid and its devatas, the 64 pada structure where that grid was asked for, and the marma and vamsa geometry where it applies.
    pub sources: Vec<GenerateMandalaResponseSourcesItem>,
    /// The six vamsa lines of 53.63, each named in the verse by the devatas at its two ends. Present only on the 81 pada grid: the 64 pada division is told to draw its main diagonals and nothing further is stated, so a six line geometry there would be borrowed from a different text.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vamsa: Option<Vec<GenerateMandalaResponseVamsaItem>>,
}
/// One entry of `vamsa`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMandalaResponseVamsaItem {
    /// Which way the line runs across the grid, northwest-southeast or northeast-southwest. Derived from the endpoint cells rather than stored, so it cannot disagree with the geometry.
    pub axis: String,
    /// Start of the line in plot coordinates, at the centre of its square.
    pub from: GenerateMandalaResponseVamsaItemFrom,
    /// Identifier of the devata at that end. Always English transliteration, safe to compare against.
    #[serde(rename = "fromDevata")]
    pub from_devata: String,
    /// Square the line starts at, named in 53.63 by the devata holding it.
    #[serde(rename = "fromSquare")]
    pub from_square: f64,
    /// Whether this is one of the two corner to corner diagonals. The other four run parallel to them, two cells either side.
    #[serde(rename = "isMainDiagonal")]
    pub is_main_diagonal: bool,
    /// End of the line in plot coordinates, at the centre of its square.
    pub to: GenerateMandalaResponseVamsaItemTo,
    /// Identifier of the devata at that end.
    #[serde(rename = "toDevata")]
    pub to_devata: String,
    /// Square the line ends at, named in 53.63 by the devata holding it.
    #[serde(rename = "toSquare")]
    pub to_square: f64,
}
/// End of the line in plot coordinates, at the centre of its square.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMandalaResponseVamsaItemTo {
    /// Distance east of the plot origin, in the same unit as the plot. The x axis runs east.
    pub x: f64,
    /// Distance north of the plot origin, in the same unit as the plot. The y axis runs north.
    pub y: f64,
}
/// Start of the line in plot coordinates, at the centre of its square.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMandalaResponseVamsaItemFrom {
    /// Distance east of the plot origin, in the same unit as the plot. The x axis runs east.
    pub x: f64,
    /// Distance north of the plot origin, in the same unit as the plot. The y axis runs north.
    pub y: f64,
}
/// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMandalaResponseSourcesItem {
    /// Why a convention rule says what it says. Present only when text is convention, and it names the tradition the rule comes from rather than a verse.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub basis: Option<String>,
    /// Chapter of the primary text. Absent on a convention, which has no chapter to cite.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chapter: Option<f64>,
    /// Whether the cited edition is in the public domain. True on the 1884 Brihat Samhita edition, whose verses are quoted. False on the 1933 Manasara edition behind the Ayadi formulas, from which only the multipliers, divisors and names are taken, never a sentence.
    #[serde(rename = "publicDomain", skip_serializing_if = "Option::is_none")]
    pub public_domain: Option<bool>,
    /// The primary text this verdict rests on, or the literal value convention where no verse states the rule. Always English, safe to compare against.
    pub text: String,
    /// Translator of the edition the verse was read in. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation: Option<String>,
    /// Verse or verse range inside the chapter. Absent on a convention. A range is written with a hyphen, as in 115-117.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub verse: Option<String>,
    /// Publication year of that edition. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<f64>,
}
/// The vital spots of the mandala. Present on the 81 pada grid, where 53.57 and 53.64 state the rule and its size. Absent on the 64 pada grid, for which the chapter states neither.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMandalaResponseMarma {
    /// Area of one marma spot in the square of the plot unit. 53.64 sets it at one eighth of the area of a square, so it scales with the plot.
    #[serde(rename = "areaEach")]
    pub area_each: f64,
    /// The centre of every square, which 53.57 calls a marmasthala and forbids raising a pillar over.
    pub points: Vec<GenerateMandalaResponseMarmaPointsItem>,
}
/// One entry of `points`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMandalaResponseMarmaPointsItem {
    /// Distance east of the plot origin, in the same unit as the plot. The x axis runs east.
    pub x: f64,
    /// Distance north of the plot origin, in the same unit as the plot. The y axis runs north.
    pub y: f64,
}
/// The switches this projection resolved, echoed so a stored response can be reproduced later.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMandalaResponseConventions {
    /// Which division of the ground was projected. Echoes the resolved value whether it was sent or defaulted.
    pub grid: String,
    /// Unit every distance and area in the response is measured in, areas in its square. Echoes the resolved value whether it was sent or defaulted.
    pub unit: GenerateMandalaResponseConventionsUnit,
}
string_enum! {
    /// Unit every distance and area in the response is measured in, areas in its square. Echoes the resolved value whether it was sent or defaulted.
    GenerateMandalaResponseConventionsUnit {
        Feet = "feet",
        Metres = "metres",
    }
}
/// One entry of `cells`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMandalaResponseCellsItem {
    /// Centre of the square in plot coordinates. This point is the marmasthala of the square, the vital spot 53.57 forbids raising a pillar on.
    pub center: GenerateMandalaResponseCellsItemCenter,
    /// Which ring of the mandala the devata belongs to: perimeter for the outer 32, innerRing for the eight around Brahma, innerCorner for the four on the inner diagonals, center for Brahma. Present only on the 81 pada grid.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub class: Option<GenerateMandalaResponseCellsItemClass>,
    /// Column of the grid, 1 at the western edge and 9 or 8 at the eastern one.
    #[serde(rename = "columnFromWest")]
    pub column_from_west: f64,
    /// Identifier of the devata holding this square. Always English transliteration, safe to compare against. Present only on the 81 pada grid, since the chapter names no devata on the 64 pada division.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub devata: Option<String>,
    /// Display name of that devata. A Sanskrit proper noun: romanised with the diacritics the transliteration carries in every language, and written in Devanagari as the Sanskrit text prints it when lang is hi. Present only on the 81 pada grid.
    #[serde(rename = "devataName", skip_serializing_if = "Option::is_none")]
    pub devata_name: Option<String>,
    /// How many squares the devata holds under the classification of 53.49 to 50: padika for one, dvipada for two, tripada for three. Absent for Brahma, which those verses leave outside the scheme, and on the 64 pada grid.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub group: Option<String>,
    /// The structural role 53.55 to 56 gives this square of the 64 pada division: brahma, halved-inner-corner, halved-outer-corner, around-brahma, dvipada or outer. Present only on the 64 pada grid, which is the only thing that chapter states about it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub role: Option<GenerateMandalaResponseCellsItemRole>,
    /// Row of the grid, 1 at the northern edge and 9 or 8 at the southern one.
    #[serde(rename = "rowFromNorth")]
    pub row_from_north: f64,
    /// Square number, 1 to 81 on the Paramasayika and 1 to 64 on the Manduka. Squares run row-major over the printed plate, which puts 1 in the north-east, 9 in the south-east, 73 in the north-west and 81 in the south-west on the 81 pada grid.
    pub square: f64,
    /// Whether the centre of this square falls inside the plot outline. False where an irregular plot has a corner cut away, which is how a missing quarter of the mandala shows up as data rather than as a missing row.
    #[serde(rename = "withinPlot")]
    pub within_plot: bool,
}
string_enum! {
    /// The structural role 53.55 to 56 gives this square of the 64 pada division: brahma, halved-inner-corner, halved-outer-corner, around-brahma, dvipada or outer. Present only on the 64 pada grid, which is the only thing that chapter states about it.
    GenerateMandalaResponseCellsItemRole {
        Brahma = "brahma",
        HalvedInnerCorner = "halved-inner-corner",
        HalvedOuterCorner = "halved-outer-corner",
        AroundBrahma = "around-brahma",
        Dvipada = "dvipada",
        Outer = "outer",
    }
}
string_enum! {
    /// Which ring of the mandala the devata belongs to: perimeter for the outer 32, innerRing for the eight around Brahma, innerCorner for the four on the inner diagonals, center for Brahma. Present only on the 81 pada grid.
    GenerateMandalaResponseCellsItemClass {
        Perimeter = "perimeter",
        InnerRing = "innerRing",
        InnerCorner = "innerCorner",
        Center = "center",
    }
}
/// Centre of the square in plot coordinates. This point is the marmasthala of the square, the vital spot 53.57 forbids raising a pillar on.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMandalaResponseCellsItemCenter {
    /// Distance east of the plot origin, in the same unit as the plot. The x axis runs east.
    pub x: f64,
    /// Distance north of the plot origin, in the same unit as the plot. The y axis runs north.
    pub y: f64,
}
/// The central block of the mandala. Nine squares on the Paramasayika and four on the Manduka.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMandalaResponseBrahmasthan {
    /// Area of the brahmasthan in the square of the plot unit, so a report can quote how much ground it covers.
    pub area: f64,
    /// The brahmasthan as four corners in plot coordinates, so it can be drawn straight onto a plan. It is the block a house is kept clear of, and the chapter destroys the family of a house whose gate faces it.
    pub polygon: Vec<GenerateMandalaResponseBrahmasthanPolygonItem>,
    /// The squares Brahma holds: the nine central squares on the 81 pada grid, the four on the 64 pada grid.
    pub squares: Vec<f64>,
}
/// One entry of `polygon`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMandalaResponseBrahmasthanPolygonItem {
    /// Distance east of the plot origin, in the same unit as the plot. The x axis runs east.
    pub x: f64,
    /// Distance north of the plot origin, in the same unit as the plot. The y axis runs north.
    pub y: f64,
}
/// Request body of `generateMandala`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMandalaRequest {
    /// Which division of the ground to read: 81-pada is the Paramasayika of Brihat Samhita 53.42, the grid the chapter numbers and names every devata on, and 64-pada is the Manduka of 53.55, for which the chapter gives structure only and no devata names. Defaults to 81-pada.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub grid: Option<GenerateMandalaRequestGrid>,
    /// The ground the mandala is projected over. Send width and depth for a compass-aligned rectangle, or polygon for anything else. The x axis runs east and the y axis north, and the mandala is aligned to the compass rather than to the building.
    pub plot: GenerateMandalaRequestPlot,
}
/// The ground the mandala is projected over. Send width and depth for a compass-aligned rectangle, or polygon for anything else. The x axis runs east and the y axis north, and the mandala is aligned to the compass rather than to the building.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateMandalaRequestPlot {
    /// North-south extent of a rectangular plot, in the unit given. Send this with width for a rectangle, or send polygon instead.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub depth: Option<f64>,
    /// The plot outline as 3 to 16 vertices in plot coordinates, x east and y north, in either winding order. Use this instead of width and depth for a plot with a cut corner, an extension or an irregular boundary.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub polygon: Option<Vec<GenerateMandalaRequestPlotPolygonItem>>,
    /// Unit the plot dimensions are given in. Every distance the response returns is in this same unit. The mandala projection is scale free, so this affects the areas and the marma size and nothing else.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub unit: Option<GenerateMandalaRequestPlotUnit>,
    /// East-west extent of a rectangular plot, in the unit given. Send this with depth for a rectangle, or send polygon instead.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub width: Option<f64>,
}
string_enum! {
    /// Unit the plot dimensions are given in. Every distance the response returns is in this same unit. The mandala projection is scale free, so this affects the areas and the marma size and nothing else.
    GenerateMandalaRequestPlotUnit {
        Feet = "feet",
        Metres = "metres",
    }
}
/// One entry of `polygon`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateMandalaRequestPlotPolygonItem {
    /// Distance east of the plot origin, in the same unit as the plot. The x axis runs east.
    pub x: f64,
    /// Distance north of the plot origin, in the same unit as the plot. The y axis runs north.
    pub y: f64,
}
string_enum! {
    /// Which division of the ground to read: 81-pada is the Paramasayika of Brihat Samhita 53.42, the grid the chapter numbers and names every devata on, and 64-pada is the Manduka of 53.55, for which the chapter gives structure only and no devata names. Defaults to 81-pada.
    GenerateMandalaRequestGrid {
        Variant81Pada = "81-pada",
        Variant64Pada = "64-pada",
    }
}
/// Path and query parameters of `generateMandala`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateMandalaParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateMandalaParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateMandalaParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `generateLunarReturn`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateLunarReturnResponse {
    /// Original birth date used for natal Moon longitude calculation.
    #[serde(rename = "birthDate")]
    pub birth_date: String,
    /// Full tropical zodiac chart erected for the lunar return moment. Contains planetary positions, house cusps, aspects, Ascendant, and Midheaven.
    pub chart: GenerateLunarReturnResponseChart,
    /// Lunar return interpretation with monthly forecast. Lunar returns reveal emotional patterns, domestic focus, and intuitive themes for the upcoming ~27-day cycle.
    pub interpretation: GenerateLunarReturnResponseInterpretation,
    /// Location used for the lunar return chart house and Ascendant calculations.
    pub location: GenerateLunarReturnResponseLocation,
    /// Exact lunar return moment, when the transiting Moon conjuncts the natal Moon longitude. Adjusted to requested timezone. Occurs approximately every 27.3 days (one sidereal month).
    #[serde(rename = "lunarReturnDate")]
    pub lunar_return_date: String,
    /// Original natal Moon position that the transiting Moon returns to. This conjunction defines the lunar return moment.
    #[serde(rename = "natalMoonPosition")]
    pub natal_moon_position: GenerateLunarReturnResponseNatalMoonPosition,
}
/// Original natal Moon position that the transiting Moon returns to. This conjunction defines the lunar return moment.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateLunarReturnResponseNatalMoonPosition {
    /// Degree within the zodiac sign (0-29.999).
    pub degree: f64,
    /// Natal Moon ecliptic longitude in degrees (0-360). The transiting Moon returns to this position each month.
    pub longitude: f64,
    /// Tropical zodiac sign of the natal Moon.
    pub sign: String,
}
/// Location used for the lunar return chart house and Ascendant calculations.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateLunarReturnResponseLocation {
    /// Observer latitude used for house cusp calculation in the lunar return chart.
    pub latitude: f64,
    /// Observer longitude used for local sidereal time and Midheaven in the return chart.
    pub longitude: f64,
    /// Timezone offset from UTC applied to output datetime formatting.
    pub timezone: f64,
}
/// Lunar return interpretation with monthly forecast. Lunar returns reveal emotional patterns, domestic focus, and intuitive themes for the upcoming ~27-day cycle.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateLunarReturnResponseInterpretation {
    /// Key emotional patterns, domestic themes, and self-care priorities for this lunar month.
    #[serde(rename = "keyThemes")]
    pub key_themes: Vec<String>,
    /// Explanation of how to use lunar return charts for monthly emotional forecasting and self-care planning.
    pub purpose: String,
    /// Narrative overview of the monthly emotional themes and lunar cycle focus areas.
    pub summary: String,
}
/// Full tropical zodiac chart erected for the lunar return moment. Contains planetary positions, house cusps, aspects, Ascendant, and Midheaven.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateLunarReturnResponseChart {
    /// All planetary aspects found in this chart with orbs, strength, and applying/separating status.
    pub aspects: Vec<GenerateLunarReturnResponseChartAspectsItem>,
    /// Birth details used to generate this chart.
    #[serde(rename = "birthDetails")]
    pub birth_details: GenerateLunarReturnResponseChartBirthDetails,
    /// House system used for this chart (placidus, whole-sign, equal, or koch).
    #[serde(rename = "houseSystem")]
    pub house_system: GenerateLunarReturnResponseChartHouseSystem,
    /// All 12 house cusps calculated using the selected house system.
    pub houses: Vec<GenerateLunarReturnResponseChartHousesItem>,
    /// Part of Fortune (Lot of Fortune). A point derived from the Ascendant and the two luminaries that marks an area of ease, vitality, and material wellbeing in the chart.
    #[serde(rename = "partOfFortune")]
    pub part_of_fortune: GenerateLunarReturnResponseChartPartOfFortune,
    /// All 14 celestial bodies in the tropical zodiac with house placements: the 10 classical planets (Sun through Pluto), the lunar nodes (North Node, South Node, in the requested `nodeType` convention), Chiron, and Black Moon Lilith. Chiron is included for charts from 1600 to 2500 and omitted outside that range.
    pub planets: Vec<GenerateLunarReturnResponseChartPlanetsItem>,
    /// Vertex. The western intersection of the prime vertical with the ecliptic, often read as a point of fated encounters and turning-point relationships. The opposite point is the Anti-Vertex.
    pub vertex: GenerateLunarReturnResponseChartVertex,
}
/// Vertex. The western intersection of the prime vertical with the ecliptic, often read as a point of fated encounters and turning-point relationships. The opposite point is the Anti-Vertex.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateLunarReturnResponseChartVertex {
    /// Degree within the Vertex sign (0-29.999).
    pub degree: f64,
    /// House containing this point, resolved against the same cusps as `planets[].house` and using the requested house system. Read this field rather than inferring a house from the sign: the two disagree whenever a house spans more than one sign, which is most of the time outside Whole Sign.
    pub house: i64,
    /// Absolute ecliptic longitude of the Vertex (0-360).
    pub longitude: f64,
    /// Zodiac sign holding the Vertex.
    pub sign: String,
}
/// One entry of `planets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateLunarReturnResponseChartPlanetsItem {
    /// Degree within the zodiac sign (0-29.999). Indicates how far the planet has progressed through the sign.
    pub degree: f64,
    /// House placement (1-12). Determined by the selected house system and birth location.
    pub house: i64,
    /// Whether the planet appears to move backward from Earth perspective. Retrograde periods signal review and introspection.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Apparent geocentric ecliptic latitude of date, in degrees. Near zero for most planets, varies for the Moon and Pluto, and reaches up to about 5 degrees for Black Moon Lilith (projected from the inclined mean lunar orbit).
    pub latitude: f64,
    /// Apparent geocentric tropical longitude on the true ecliptic of date, in degrees (0-360): light time and aberration applied, nutation included, the convention desktop chart software and the NASA JPL Horizons observer tables print, so it compares directly with either. Primary coordinate for zodiac sign and aspect calculations.
    pub longitude: f64,
    /// Body name. One of the 10 classical planets (Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto), the lunar nodes (North Node, South Node), Chiron, or Black Moon Lilith (the mean lunar apogee). The lunar nodes follow the request nodeType, which defaults to the true (osculating) node; pass "mean" for the smoothed node. The two differ by up to about 1.8 degrees and no other body is affected.
    pub name: GenerateLunarReturnResponseChartPlanetsItemName,
    /// Tropical zodiac sign this planet occupies. Determined by 30-degree divisions of ecliptic longitude.
    pub sign: String,
    /// Daily motion in degrees per day. Negative values indicate retrograde motion.
    pub speed: f64,
}
string_enum! {
    /// Body name. One of the 10 classical planets (Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto), the lunar nodes (North Node, South Node), Chiron, or Black Moon Lilith (the mean lunar apogee). The lunar nodes follow the request nodeType, which defaults to the true (osculating) node; pass "mean" for the smoothed node. The two differ by up to about 1.8 degrees and no other body is affected.
    GenerateLunarReturnResponseChartPlanetsItemName {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
/// Part of Fortune (Lot of Fortune). A point derived from the Ascendant and the two luminaries that marks an area of ease, vitality, and material wellbeing in the chart.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateLunarReturnResponseChartPartOfFortune {
    /// Degree within the Part of Fortune sign (0-29.999).
    pub degree: f64,
    /// House containing this point, resolved against the same cusps as `planets[].house` and using the requested house system. Read this field rather than inferring a house from the sign: the two disagree whenever a house spans more than one sign, which is most of the time outside Whole Sign.
    pub house: i64,
    /// Absolute ecliptic longitude of the Part of Fortune (0-360).
    pub longitude: f64,
    /// Chart sect used for the calculation. Day (diurnal) when the Sun is above the horizon, night (nocturnal) when below. Day charts use Ascendant plus Moon minus Sun, night charts use Ascendant plus Sun minus Moon.
    pub sect: GenerateLunarReturnResponseChartPartOfFortuneSect,
    /// Zodiac sign holding the Part of Fortune.
    pub sign: String,
}
string_enum! {
    /// Chart sect used for the calculation. Day (diurnal) when the Sun is above the horizon, night (nocturnal) when below. Day charts use Ascendant plus Moon minus Sun, night charts use Ascendant plus Sun minus Moon.
    GenerateLunarReturnResponseChartPartOfFortuneSect {
        Day = "day",
        Night = "night",
    }
}
/// One entry of `houses`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateLunarReturnResponseChartHousesItem {
    /// Degree within the zodiac sign on this cusp (0-29.999).
    pub degree: f64,
    /// Ecliptic longitude of this house cusp in degrees (0-360).
    pub longitude: f64,
    /// House number (1-12). Each house governs specific life themes in Western astrology.
    pub number: i64,
    /// Zodiac sign on this house cusp. Colors the themes of this life area.
    pub sign: String,
}
string_enum! {
    /// House system used for this chart (placidus, whole-sign, equal, or koch).
    GenerateLunarReturnResponseChartHouseSystem {
        Placidus = "placidus",
        WholeSign = "whole-sign",
        Equal = "equal",
        Koch = "koch",
    }
}
/// Birth details used to generate this chart.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateLunarReturnResponseChartBirthDetails {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone offset from UTC in decimal hours, resolved for the birth date. Examples: New York = -5 in winter and -4 in summer, London = 0, India = 5.5, Tokyo = 9.
    pub timezone: f64,
}
/// One entry of `aspects`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateLunarReturnResponseChartAspectsItem {
    /// Exact angular separation that defines this aspect type in degrees.
    pub angle: f64,
    /// Aspect nature. Harmonious (trine, sextile) flows easily. Challenging (square, opposition) creates tension and growth. Neutral (conjunction) blends energies. Always English, whatever the lang parameter says: it is an identifier consumers switch and style on. Use interpretationLocalized for anything a reader sees.
    pub interpretation: GenerateLunarReturnResponseChartAspectsItemInterpretation,
    /// Whether the aspect is applying (planets moving toward exact) or separating (moving apart). Applying aspects grow stronger.
    #[serde(rename = "isApplying")]
    pub is_applying: bool,
    /// Deviation from exact aspect in degrees. Tighter orb means stronger influence.
    pub orb: f64,
    /// First planet in the aspect pair.
    pub planet1: GenerateLunarReturnResponseChartAspectsItemPlanet1,
    /// Second planet in the aspect pair.
    pub planet2: GenerateLunarReturnResponseChartAspectsItemPlanet2,
    /// Aspect strength percentage (0-100). Based on orb tightness relative to the allowed maximum.
    pub strength: f64,
    /// Aspect type. Major: conjunction (0), opposition (180), trine (120), square (90), sextile (60). Minor: semi-sextile, quincunx, semi-square, sesquiquadrate.
    pub r#type: GenerateLunarReturnResponseChartAspectsItemType,
}
string_enum! {
    /// Aspect type. Major: conjunction (0), opposition (180), trine (120), square (90), sextile (60). Minor: semi-sextile, quincunx, semi-square, sesquiquadrate.
    GenerateLunarReturnResponseChartAspectsItemType {
        Conjunction = "CONJUNCTION",
        Opposition = "OPPOSITION",
        Trine = "TRINE",
        Square = "SQUARE",
        Sextile = "SEXTILE",
        SemiSextile = "SEMI_SEXTILE",
        Quincunx = "QUINCUNX",
        SemiSquare = "SEMI_SQUARE",
        Sesquiquadrate = "SESQUIQUADRATE",
    }
}
string_enum! {
    /// Second planet in the aspect pair.
    GenerateLunarReturnResponseChartAspectsItemPlanet2 {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
string_enum! {
    /// First planet in the aspect pair.
    GenerateLunarReturnResponseChartAspectsItemPlanet1 {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
string_enum! {
    /// Aspect nature. Harmonious (trine, sextile) flows easily. Challenging (square, opposition) creates tension and growth. Neutral (conjunction) blends energies. Always English, whatever the lang parameter says: it is an identifier consumers switch and style on. Use interpretationLocalized for anything a reader sees.
    GenerateLunarReturnResponseChartAspectsItemInterpretation {
        Harmonious = "harmonious",
        Challenging = "challenging",
        Neutral = "neutral",
    }
}
/// Request body of `generateLunarReturn`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateLunarReturnRequest {
    /// Original birth date in YYYY-MM-DD format. Used to determine natal Moon longitude for the lunar return calculation.
    #[serde(rename = "birthDate")]
    pub birth_date: String,
    /// Original birth time in 24-hour HH:MM:SS format. Determines exact natal Moon position for monthly return timing.
    #[serde(rename = "birthTime")]
    pub birth_time: String,
    /// House system for the lunar return chart. Placidus (default), Whole Sign, Equal, or Koch.
    #[serde(rename = "houseSystem", skip_serializing_if = "Option::is_none")]
    pub house_system: Option<GenerateLunarReturnRequestHouseSystem>,
    /// Latitude of the lunar return location in decimal degrees (-90 to 90). Affects the Ascendant and house cusps of the return chart.
    pub latitude: f64,
    /// Longitude of the lunar return location in decimal degrees (-180 to 180). Determines local sidereal time for house calculations.
    pub longitude: f64,
    /// Approximate date near the desired lunar return (YYYY-MM-DD). The Moon returns to its natal position every ~27.3 days, so provide a date within a few days of the expected return.
    #[serde(rename = "returnDate")]
    pub return_date: String,
    /// Decimal hours from UTC OR IANA name (e.g. "America/New_York"). IANA resolved to the DST-correct offset for the birthDate. Output datetime is adjusted to this timezone.
    pub timezone: GenerateLunarReturnRequestTimezone,
}
/// Decimal hours from UTC OR IANA name (e.g. "America/New_York"). IANA resolved to the DST-correct offset for the birthDate. Output datetime is adjusted to this timezone.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GenerateLunarReturnRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// House system for the lunar return chart. Placidus (default), Whole Sign, Equal, or Koch.
    GenerateLunarReturnRequestHouseSystem {
        Placidus = "placidus",
        WholeSign = "whole-sign",
        Equal = "equal",
        Koch = "koch",
    }
}
/// Path and query parameters of `generateLunarReturn`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateLunarReturnParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateLunarReturnParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateLunarReturnParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Request body of `generateLocalSpace`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateLocalSpaceRequest {
    /// Birth date in YYYY-MM-DD format. Combined with time and timezone it fixes the birth instant whose planetary positions are projected onto the local horizon.
    pub date: String,
    /// Birthplace latitude in decimal degrees (-90 to 90). This is the origin point of every local space line and the observer latitude used to turn each body into an azimuth and altitude.
    pub latitude: f64,
    /// Birthplace longitude in decimal degrees (-180 to 180). Sets the local horizon orientation and the starting point from which the directional lines radiate.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Time is essential: the local horizon rotates a full circle each day, so the azimuth (compass direction) of every body depends on the exact birth time.
    pub time: String,
    /// Decimal hours from UTC (e.g. -5 for EST, 5.5 for IST, 9 for JST) OR IANA name (e.g. "America/New_York"). IANA resolved to the offset in force at the birth date and time.
    pub timezone: GenerateLocalSpaceRequestTimezone,
}
/// Decimal hours from UTC (e.g. -5 for EST, 5.5 for IST, 9 for JST) OR IANA name (e.g. "America/New_York"). IANA resolved to the offset in force at the birth date and time.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GenerateLocalSpaceRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
/// Path and query parameters of `generateLocalSpace`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateLocalSpaceParams {
    /// Optional comma-separated extra bodies to add beyond the 10 classical planets. Allowed values: north-node, chiron, lilith. north-node is the mean lunar node. Omit to return the 10 classical planets only.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub include: Option<String>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateLocalSpaceParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateLocalSpaceParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `generateLilith`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateLilithParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateLilithParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateLilithParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `generateKpChart`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateKpChartParams {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<GenerateKpChartParamsFocus>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateKpChartParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateKpChartParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    GenerateKpChartParamsFocus {
        General = "general",
        Finance = "finance",
    }
}
/// Response body of `generateFlyingStarChart`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateFlyingStarChartResponse {
    /// The `facing` field.
    pub facing: GenerateFlyingStarChartResponseFacing,
    /// Echo of the bearing sent, when one was sent. Absent when the facing was named as a mountain instead.
    #[serde(rename = "facingDegrees", skip_serializing_if = "Option::is_none")]
    pub facing_degrees: Option<f64>,
    /// Flying star number, 1 to 9. The number IS the identifier of the star: 8 is always the Eight White Earth star whichever plate it appears on.
    #[serde(rename = "mountainCenterStar")]
    pub mountain_center_star: f64,
    /// Whether the mountain plate flew forward or in reverse, decided by the polarity of the mountain the centre star answers to. Published because it is the step that separates two charts that otherwise look alike.
    #[serde(rename = "mountainFlight")]
    pub mountain_flight: String,
    /// All nine palaces, centre first and then along the Lo Shu flight path. Each of the nine stars appears exactly once on each plate, which is the property that makes a chart checkable.
    pub palaces: Vec<GenerateFlyingStarChartResponsePalacesItem>,
    /// The period this chart was built for. Echoes the period requested, or the period in force now when it was omitted.
    pub period: f64,
    /// The `sitting` field.
    pub sitting: GenerateFlyingStarChartResponseSitting,
    /// Whether the bearing fell in the outer 3 degrees of its mountain rather than the central 9. A bearing there calls for the substitute gua construction, which is a different chart; this chart is always the down gua one, so a true value means the result needs a specialist rather than this endpoint. Always false when the facing was named as a mountain, since naming a mountain expresses no bearing.
    pub straddling: bool,
    /// The `structure` field.
    pub structure: GenerateFlyingStarChartResponseStructure,
    /// Flying star number, 1 to 9. The number IS the identifier of the star: 8 is always the Eight White Earth star whichever plate it appears on.
    #[serde(rename = "waterCenterStar")]
    pub water_center_star: f64,
    /// Whether the water plate flew forward or in reverse, decided the same way against the facing mountain.
    #[serde(rename = "waterFlight")]
    pub water_flight: String,
}
/// The `structure` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateFlyingStarChartResponseStructure {
    /// Chinese name of the structure. Data, identical in every language.
    pub chinese: String,
    /// The classical verdict on the chart: prosperous-mountain-prosperous-water, reversed, double-facing or double-sitting. Always English, safe to switch on.
    pub id: String,
    /// What the structure means and what the classical correction for it is.
    pub meaning: String,
    /// Display name of the structure, TRANSLATED IN PLACE under the lang parameter. Switch on structure.id, which is the stable machine value in every language. Unlike the star and formation names beside it, this field has no nameLocalized sibling.
    pub name: String,
}
/// The `sitting` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateFlyingStarChartResponseSitting {
    /// Chinese character for the mountain. Data, identical in every language.
    pub chinese: String,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against in code and against the same value on the I-Ching trigram endpoints.
    pub direction: String,
    /// End of the 15 degree span, in compass degrees.
    #[serde(rename = "endDegree")]
    pub end_degree: f64,
    /// Mountain id, the pinyin of the stem, branch or trigram that names it. Always English pinyin, safe to compare against.
    pub id: String,
    /// Compass label of the mountain, sector plus position 1 to 3 clockwise. The form a facing is usually quoted in.
    pub label: String,
    /// Tone-marked pinyin for the mountain. Data, identical in every language.
    pub pinyin: String,
    /// San Yuan polarity of the mountain, yang or yin, which decides whether a plate entering the centre flies forward or in reverse. This is NOT the natural polarity of the stem or branch and the two differ on eight of the 24 mountains.
    pub polarity: String,
    /// Start of the 15 degree span, in compass degrees. Wraps past 360 for the two northernmost mountains.
    #[serde(rename = "startDegree")]
    pub start_degree: f64,
    /// Which of the three dragons the mountain holds inside its sector: earth for the first mountain clockwise, heaven for the middle, human for the last. The heaven and human dragons share a polarity, which is why they share a chart.
    pub yuan: String,
}
/// One entry of `palaces`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateFlyingStarChartResponsePalacesItem {
    /// Flying star number, 1 to 9. The number IS the identifier of the star: 8 is always the Eight White Earth star whichever plate it appears on.
    pub base: f64,
    /// The named classical formation for this mountain and water pair. Absent for the pairs the tradition does not name, where the composed reading carries the meaning instead.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub combination: Option<GenerateFlyingStarChartResponsePalacesItemCombination>,
    /// Flying star number, 1 to 9. The number IS the identifier of the star: 8 is always the Eight White Earth star whichever plate it appears on.
    pub mountain: f64,
    /// Palace of the Lo Shu grid: one of the eight compass sectors, or Center. Always English, safe to compare against and to key a grid cell on.
    pub palace: String,
    /// Flying star number, 1 to 9. The number IS the identifier of the star: 8 is always the Eight White Earth star whichever plate it appears on.
    pub period: f64,
    /// What this palace means, composed from the two stars and the phase relation between them. Named formations return their own passage; the rest are built from the star pair.
    pub reading: String,
    /// Flying star number, 1 to 9. The number IS the identifier of the star: 8 is always the Eight White Earth star whichever plate it appears on.
    pub water: f64,
}
/// The named classical formation for this mountain and water pair. Absent for the pairs the tradition does not name, where the composed reading carries the meaning instead.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateFlyingStarChartResponsePalacesItemCombination {
    /// Chinese name of the formation. Data, identical in every language.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chinese: Option<String>,
    /// Canonical key for the pair, lower number first, so a palace holding mountain 9 and water 8 resolves to the same entry as one holding mountain 8 and water 9.
    pub id: String,
    /// Name of the formation. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Formation name in the requested language, for display only. Present only when lang is set to a language other than English.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Whether the formation helps or harms.
    pub nature: String,
}
/// The `facing` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateFlyingStarChartResponseFacing {
    /// Chinese character for the mountain. Data, identical in every language.
    pub chinese: String,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against in code and against the same value on the I-Ching trigram endpoints.
    pub direction: String,
    /// End of the 15 degree span, in compass degrees.
    #[serde(rename = "endDegree")]
    pub end_degree: f64,
    /// Mountain id, the pinyin of the stem, branch or trigram that names it. Always English pinyin, safe to compare against.
    pub id: String,
    /// Compass label of the mountain, sector plus position 1 to 3 clockwise. The form a facing is usually quoted in.
    pub label: String,
    /// Tone-marked pinyin for the mountain. Data, identical in every language.
    pub pinyin: String,
    /// San Yuan polarity of the mountain, yang or yin, which decides whether a plate entering the centre flies forward or in reverse. This is NOT the natural polarity of the stem or branch and the two differ on eight of the 24 mountains.
    pub polarity: String,
    /// Start of the 15 degree span, in compass degrees. Wraps past 360 for the two northernmost mountains.
    #[serde(rename = "startDegree")]
    pub start_degree: f64,
    /// Which of the three dragons the mountain holds inside its sector: earth for the first mountain clockwise, heaven for the middle, human for the last. The heaven and human dragons share a polarity, which is why they share a chart.
    pub yuan: String,
}
/// Request body of `generateFlyingStarChart`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateFlyingStarChartRequest {
    /// The mountain the front of the building faces, by id or by compass label such as S2. Send this or facingDegrees, not neither. The facing side is the open, active, public side, which is not always the side with the front door.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub facing: Option<GenerateFlyingStarChartRequestFacing>,
    /// The compass bearing the front of the building faces, 0 to 360 degrees, measured looking out from inside. Resolved to one of the 24 mountains. Send this or facing, not neither.
    #[serde(
        rename = "facingDegrees",
        skip_serializing_if = "Option::is_none",
        default,
        deserialize_with = "tri_state_serde::deserialize"
    )]
    pub facing_degrees: Option<Option<f64>>,
    /// Construction period of the building, 1 to 9. This is the twenty year cycle the building was completed in, or last renovated heavily enough to reset, and it is fixed for the life of the building. Periods change at Li Chun in early February, so a building finished in January 2024 is a Period 8 building. Defaults to the period in force now.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub period: Option<i64>,
}
string_enum! {
    /// The mountain the front of the building faces, by id or by compass label such as S2. Send this or facingDegrees, not neither. The facing side is the open, active, public side, which is not always the side with the front door.
    GenerateFlyingStarChartRequestFacing {
        Ren = "ren",
        Zi = "zi",
        Gui = "gui",
        Chou = "chou",
        Gen = "gen",
        Yin = "yin",
        Jia = "jia",
        Mao = "mao",
        Yi = "yi",
        Chen = "chen",
        Xun = "xun",
        Si = "si",
        Bing = "bing",
        Wu = "wu",
        Ding = "ding",
        Wei = "wei",
        Kun = "kun",
        Shen = "shen",
        Geng = "geng",
        You = "you",
        Xin = "xin",
        Xu = "xu",
        Qian = "qian",
        Hai = "hai",
        N1 = "N1",
        N2 = "N2",
        N3 = "N3",
        Ne1 = "NE1",
        Ne2 = "NE2",
        Ne3 = "NE3",
        E1 = "E1",
        E2 = "E2",
        E3 = "E3",
        Se1 = "SE1",
        Se2 = "SE2",
        Se3 = "SE3",
        S1 = "S1",
        S2 = "S2",
        S3 = "S3",
        Sw1 = "SW1",
        Sw2 = "SW2",
        Sw3 = "SW3",
        W1 = "W1",
        W2 = "W2",
        W3 = "W3",
        Nw1 = "NW1",
        Nw2 = "NW2",
        Nw3 = "NW3",
    }
}
/// Path and query parameters of `generateFlyingStarChart`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateFlyingStarChartParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateFlyingStarChartParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateFlyingStarChartParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Request body of `generateFixedStars`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateFixedStarsRequest {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<GenerateFixedStarsRequestNodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
    pub timezone: GenerateFixedStarsRequestTimezone,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GenerateFixedStarsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    GenerateFixedStarsRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Path and query parameters of `generateFixedStars`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateFixedStarsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateFixedStarsParamsLang>,
    /// Conjunction orb in degrees, the maximum separation for a star to count as conjunct a chart point. Defaults to 1, maximum 3. Widen it to surface looser contacts or tighten it for only the closest hits.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub orb: Option<f64>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateFixedStarsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `generateEightMansions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateEightMansionsResponse {
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against in code and against the same value on the I-Ching trigram endpoints.
    #[serde(rename = "bestSector")]
    pub best_sector: String,
    /// The `conventions` field.
    pub conventions: GenerateEightMansionsResponseConventions,
    /// The classification of the sector sent as facing. Absent when no facing was sent.
    #[serde(rename = "facingSector", skip_serializing_if = "Option::is_none")]
    pub facing_sector: Option<GenerateEightMansionsResponseFacingSector>,
    /// Life group, east or west. Always English, safe to compare against and to key styling on.
    pub group: String,
    /// The Kua number this map was built for.
    pub kua: f64,
    /// All eight sectors, ordered best to worst rather than by compass, because the question this map answers is which sector to use next. Read down the list until you reach one the building actually has.
    pub sectors: Vec<GenerateEightMansionsResponseSectorsItem>,
    /// The `trigram` field.
    pub trigram: GenerateEightMansionsResponseTrigram,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against in code and against the same value on the I-Ching trigram endpoints.
    #[serde(rename = "worstSector")]
    pub worst_sector: String,
}
/// The `trigram` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateEightMansionsResponseTrigram {
    /// Three lines bottom to top, 1 for yang and 0 for yin. The Eight Mansions classification of any sector is decided by which of these three lines differ from your own trigram.
    pub binary: String,
    /// Chinese character for the trigram. Data, identical in every language.
    pub chinese: String,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against in code and against the same value on the I-Ching trigram endpoints.
    pub direction: String,
    /// Compass sector in the requested language, for display only, the same word the composed readings use. Present only when lang is set to a language other than English. Never compare against this value.
    #[serde(rename = "directionLocalized", skip_serializing_if = "Option::is_none")]
    pub direction_localized: Option<String>,
    /// Five phase of this entry: Wood, Fire, Earth, Metal or Water. Always English so it stays safe to compare against and to key styling on. The full cycles live on the Chinese astrology elements endpoint.
    pub element: String,
    /// Five phase name in the requested language, for display only. Present only when lang is set to a language other than English. Never compare against this value.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// English name of the trigram, byte identical to the English value the I-Ching trigram endpoints publish for this number. Always English here, whatever the lang parameter says, so it stays safe to compare against. Use nameLocalized for anything a reader sees.
    pub english: String,
    /// Family role of the trigram. Read alongside an affliction to know which member of the household a sector points at. Always English, and it carries no localized sibling: no vocabulary this package ships names the eight family roles.
    #[serde(rename = "familyMember")]
    pub family_member: String,
    /// Trigram name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat english exactly. Never compare against this value.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Trigram number, 1 to 8, the same identifier the I-Ching trigram endpoints use. It is a lookup key, not a ranking.
    pub number: f64,
    /// Tone-marked pinyin for the trigram. Data, identical in every language.
    pub pinyin: String,
    /// Unicode trigram symbol, for rendering a Bagua diagram without an icon set.
    pub symbol: String,
}
/// One entry of `sectors`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateEightMansionsResponseSectorsItem {
    /// Chinese characters for the star. Data, identical in every language.
    pub chinese: String,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against in code and against the same value on the I-Ching trigram endpoints.
    pub direction: String,
    /// The life domain this sector governs, in a few words, written in the requested language.
    pub domain: String,
    /// Whether the sector helps or harms: auspicious or inauspicious.
    pub nature: String,
    /// Tone-marked pinyin for the star. Data, identical in every language.
    pub pinyin: String,
    /// Order within its nature, 1 to 4. Among auspicious sectors 1 is the strongest; among inauspicious sectors 1 is the mildest and 4 the most serious.
    pub rank: f64,
    /// Composed reading for this sector: which star it holds, where that star ranks for this Kua, and what the star means in practice.
    pub reading: String,
    /// Eight Mansions star for this sector. Always English, safe to compare against and to key styling on.
    pub star: String,
    /// Display name of the star. Always English, whatever the lang parameter says. Use starNameLocalized for anything a reader sees.
    #[serde(rename = "starName")]
    pub star_name: String,
    /// Star name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat starName exactly. Never compare against this value.
    #[serde(rename = "starNameLocalized", skip_serializing_if = "Option::is_none")]
    pub star_name_localized: Option<String>,
    /// The `trigram` field.
    pub trigram: GenerateEightMansionsResponseSectorsItemTrigram,
}
/// The `trigram` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateEightMansionsResponseSectorsItemTrigram {
    /// Three lines bottom to top, 1 for yang and 0 for yin. The Eight Mansions classification of any sector is decided by which of these three lines differ from your own trigram.
    pub binary: String,
    /// Chinese character for the trigram. Data, identical in every language.
    pub chinese: String,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against in code and against the same value on the I-Ching trigram endpoints.
    pub direction: String,
    /// Compass sector in the requested language, for display only, the same word the composed readings use. Present only when lang is set to a language other than English. Never compare against this value.
    #[serde(rename = "directionLocalized", skip_serializing_if = "Option::is_none")]
    pub direction_localized: Option<String>,
    /// Five phase of this entry: Wood, Fire, Earth, Metal or Water. Always English so it stays safe to compare against and to key styling on. The full cycles live on the Chinese astrology elements endpoint.
    pub element: String,
    /// Five phase name in the requested language, for display only. Present only when lang is set to a language other than English. Never compare against this value.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// English name of the trigram, byte identical to the English value the I-Ching trigram endpoints publish for this number. Always English here, whatever the lang parameter says, so it stays safe to compare against. Use nameLocalized for anything a reader sees.
    pub english: String,
    /// Family role of the trigram. Read alongside an affliction to know which member of the household a sector points at. Always English, and it carries no localized sibling: no vocabulary this package ships names the eight family roles.
    #[serde(rename = "familyMember")]
    pub family_member: String,
    /// Trigram name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat english exactly. Never compare against this value.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Trigram number, 1 to 8, the same identifier the I-Ching trigram endpoints use. It is a lookup key, not a ranking.
    pub number: f64,
    /// Tone-marked pinyin for the trigram. Data, identical in every language.
    pub pinyin: String,
    /// Unicode trigram symbol, for rendering a Bagua diagram without an icon set.
    pub symbol: String,
}
/// The classification of the sector sent as facing. Absent when no facing was sent.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateEightMansionsResponseFacingSector {
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against in code and against the same value on the I-Ching trigram endpoints.
    pub direction: String,
    /// Whether the facing sector helps or harms for this Kua.
    pub nature: String,
    /// Eight Mansions star sitting on the facing sector.
    pub star: String,
}
/// The `conventions` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateEightMansionsResponseConventions {
    /// Which boundary decided the Chinese year for this calculation. li-chun starts the year at the astronomical start of spring, in early February, and is the classical position that feng shui uses throughout. lunar-new-year starts it at the first day of the lunar year, which is usually two to four weeks later and is what most popular zodiac tables use. Echoes the resolved value, whether it was sent or defaulted.
    #[serde(rename = "yearBoundary")]
    pub year_boundary: String,
}
/// Send either a kua number, or a date and gender to derive one. Sending neither is a 400.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateEightMansionsRequest {
    /// Birth date in YYYY-MM-DD format, used to derive the Kua when no kua is sent. Requires gender alongside it. A date is read at the start of its day, so a birth date landing exactly on the year boundary is placed in the outgoing year.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Optional compass sector the main door faces, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. When sent, the response names the star sitting on that sector so a caller can judge an entrance without scanning the whole map.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub facing: Option<GenerateEightMansionsRequestFacing>,
    /// Selects the Kua formula variant. Required when the Kua is being derived from a birth date.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub gender: Option<GenerateEightMansionsRequestGender>,
    /// Kua number to build the map for, if you already have one. Send this OR date and gender, not neither. A Kua of 5 is read as the Kua 2 chart, since 5 has no direction of its own.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kua: Option<f64>,
    /// Which boundary starts the Chinese year when the Kua is derived from a birth date. Defaults to li-chun, the classical position. Ignored when a kua is sent directly, and echoed back either way.
    #[serde(rename = "yearBoundary", skip_serializing_if = "Option::is_none")]
    pub year_boundary: Option<GenerateEightMansionsRequestYearBoundary>,
}
string_enum! {
    /// Which boundary starts the Chinese year when the Kua is derived from a birth date. Defaults to li-chun, the classical position. Ignored when a kua is sent directly, and echoed back either way.
    GenerateEightMansionsRequestYearBoundary {
        LiChun = "li-chun",
        LunarNewYear = "lunar-new-year",
    }
}
string_enum! {
    /// Selects the Kua formula variant. Required when the Kua is being derived from a birth date.
    GenerateEightMansionsRequestGender {
        Male = "male",
        Female = "female",
    }
}
string_enum! {
    /// Optional compass sector the main door faces, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. When sent, the response names the star sitting on that sector so a caller can judge an entrance without scanning the whole map.
    GenerateEightMansionsRequestFacing {
        North = "North",
        Northeast = "Northeast",
        East = "East",
        Southeast = "Southeast",
        South = "South",
        Southwest = "Southwest",
        West = "West",
        Northwest = "Northwest",
    }
}
/// Path and query parameters of `generateEightMansions`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateEightMansionsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateEightMansionsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateEightMansionsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `generateDivisionalChart`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateDivisionalChartParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateDivisionalChartParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateDivisionalChartParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `generateDigest`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateDigestResponse {
    /// Echo of the birth subject this digest was built for.
    #[serde(rename = "birthData")]
    pub birth_data: GenerateDigestResponseBirthData,
    /// Last day of the resolved 90 day horizon the timeline was built over before slicing.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Start anchor every window is measured from.
    #[serde(rename = "startDate")]
    pub start_date: String,
    /// The four rollups in ascending window length: next 24h, 7d, 30d, and 90d from the start anchor.
    pub windows: Vec<GenerateDigestResponseWindowsItem>,
}
/// One entry of `windows`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateDigestResponseWindowsItem {
    /// Count of events in this window broken down by domain. Only domains with at least one event in the window are present. The values sum to count.
    #[serde(rename = "byDomain")]
    pub by_domain: GenerateDigestResponseWindowsItemByDomain,
    /// Count of events in this window broken down by event type. Only types with at least one event in the window are present. The values sum to count.
    #[serde(rename = "byType")]
    pub by_type: GenerateDigestResponseWindowsItemByType,
    /// Number of events whose datetime falls inside this window.
    pub count: f64,
    /// Length of this window in days forward from the start anchor. One of 1, 7, 30, 90.
    pub days: f64,
    /// Inclusive lower bound of the window as an ISO-8601 UTC datetime, the start anchor.
    pub from: String,
    /// Exclusive upper bound of the window as an ISO-8601 UTC datetime, the start anchor plus the window length.
    pub to: String,
    /// The highest-significance events in this window, most significant first, up to the requested top count. The same TimelineEvent shape as the timeline endpoints.
    pub top: Vec<GenerateDigestResponseWindowsItemTopItem>,
}
/// One entry of `top`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateDigestResponseWindowsItemTopItem {
    /// For a transit-aspect, the angular relationship. One of conjunction, sextile, square, trine, opposition. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub aspect: Option<String>,
    /// Primary subject of the event. A transiting planet for western events, Sun for a solar eclipse, Moon for a lunar eclipse or a new or full moon, or the critical cycle for biorhythm days. For a dasha-change, the Vimshottari lords outermost first, joined by a hyphen, then one space and the level: Saturn Mahadasha, Saturn-Mercury Antardasha, Saturn-Mercury-Ketu Pratyantardasha. Lords are always one of Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury. Never localized.
    pub body: String,
    /// Calendar date of the event in YYYY-MM-DD (UTC).
    pub date: String,
    /// Exact instant of the event as an ISO-8601 UTC datetime, to the nearest second. Astronomical events are refined to this instant by search, not reported at a daily sample point; a dasha-change is the period boundary itself, counted from the birth instant.
    pub datetime: String,
    /// Plain-language summary of the event, suitable for direct display. The only localized field: when lang is set this sentence, and the body, target, and aspect names within it, render in the requested language while the structured fields stay English.
    pub description: String,
    /// Forecast domain. western covers transit aspects, sign ingresses, retrograde stations, eclipses, and new and full moons. vedic covers Vimshottari mahadasha, antardasha, and pratyantardasha boundaries. biorhythm covers critical days. A stable machine value, never localized, so consumers can branch on it under any language.
    pub domain: GenerateDigestResponseWindowsItemTopItemDomain,
    /// For an eclipse, its classification. total and penumbral apply to lunar eclipses, partial applies to both, annular and total apply to solar eclipses. A stable machine value, never localized. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kind: Option<GenerateDigestResponseWindowsItemTopItemKind>,
    /// For a lunar eclipse, the peak fraction from 0 to 1 of the Moon disc covered by Earth umbra. 1 for a total lunar eclipse, between 0 and 1 for a partial, 0 for a penumbral. Absent for solar eclipses and other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub obscuration: Option<f64>,
    /// For a transit-aspect, the separation in degrees from the exact aspect at the reported instant, rounded to three decimals. The instant is the moment the aspect perfects, so this reads 0. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub orb: Option<f64>,
    /// For a lunar-phase event, which syzygy it is: new-moon (Sun-Moon conjunction) or full-moon (Sun-Moon opposition). The intermediate quarters are not emitted. A stable machine value, never localized. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phase: Option<GenerateDigestResponseWindowsItemTopItemPhase>,
    /// Importance score from 0 to 100. Outer-planet exact transit aspects and mahadasha changes score highest; fast Moon events and biorhythm critical days score lower. When domainWeights is supplied this is the weighted score, rounded and clamped to 0 to 100, which is the same value the significance floor and the event cap acted on.
    pub significance: f64,
    /// For a retrograde-station, whether the planet turns retrograde or direct. A stable machine value, never localized. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub station: Option<GenerateDigestResponseWindowsItemTopItemStation>,
    /// For a transit-aspect, the natal body the transit aspects. For a sign-ingress, the zodiac sign entered, and for a lunar-phase, the zodiac sign of the New or Full Moon. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub target: Option<String>,
    /// Event kind. transit-aspect, sign-ingress, retrograde-station, eclipse, and lunar-phase are western, dasha-change is vedic Vimshottari, critical-day is biorhythm. A stable machine value, never localized, so consumers can branch on it under any language.
    pub r#type: GenerateDigestResponseWindowsItemTopItemType,
}
string_enum! {
    /// Event kind. transit-aspect, sign-ingress, retrograde-station, eclipse, and lunar-phase are western, dasha-change is vedic Vimshottari, critical-day is biorhythm. A stable machine value, never localized, so consumers can branch on it under any language.
    GenerateDigestResponseWindowsItemTopItemType {
        TransitAspect = "transit-aspect",
        SignIngress = "sign-ingress",
        RetrogradeStation = "retrograde-station",
        Eclipse = "eclipse",
        LunarPhase = "lunar-phase",
        DashaChange = "dasha-change",
        CriticalDay = "critical-day",
    }
}
string_enum! {
    /// For a retrograde-station, whether the planet turns retrograde or direct. A stable machine value, never localized. Absent for other event types.
    GenerateDigestResponseWindowsItemTopItemStation {
        Retrograde = "retrograde",
        Direct = "direct",
    }
}
string_enum! {
    /// For a lunar-phase event, which syzygy it is: new-moon (Sun-Moon conjunction) or full-moon (Sun-Moon opposition). The intermediate quarters are not emitted. A stable machine value, never localized. Absent for other event types.
    GenerateDigestResponseWindowsItemTopItemPhase {
        NewMoon = "new-moon",
        FullMoon = "full-moon",
    }
}
string_enum! {
    /// For an eclipse, its classification. total and penumbral apply to lunar eclipses, partial applies to both, annular and total apply to solar eclipses. A stable machine value, never localized. Absent for other event types.
    GenerateDigestResponseWindowsItemTopItemKind {
        Penumbral = "penumbral",
        Partial = "partial",
        Annular = "annular",
        Total = "total",
    }
}
string_enum! {
    /// Forecast domain. western covers transit aspects, sign ingresses, retrograde stations, eclipses, and new and full moons. vedic covers Vimshottari mahadasha, antardasha, and pratyantardasha boundaries. biorhythm covers critical days. A stable machine value, never localized, so consumers can branch on it under any language.
    GenerateDigestResponseWindowsItemTopItemDomain {
        Western = "western",
        Vedic = "vedic",
        Biorhythm = "biorhythm",
    }
}
/// Count of events in this window broken down by event type. Only types with at least one event in the window are present. The values sum to count.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateDigestResponseWindowsItemByType {
    /// Number of events in this window of this event type. Absent when the type did not occur, so a zero is never written.
    #[serde(rename = "critical-day", skip_serializing_if = "Option::is_none")]
    pub critical_day: Option<f64>,
    /// Number of events in this window of this event type. Absent when the type did not occur, so a zero is never written.
    #[serde(rename = "dasha-change", skip_serializing_if = "Option::is_none")]
    pub dasha_change: Option<f64>,
    /// Number of events in this window of this event type. Absent when the type did not occur, so a zero is never written.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub eclipse: Option<f64>,
    /// Number of events in this window of this event type. Absent when the type did not occur, so a zero is never written.
    #[serde(rename = "lunar-phase", skip_serializing_if = "Option::is_none")]
    pub lunar_phase: Option<f64>,
    /// Number of events in this window of this event type. Absent when the type did not occur, so a zero is never written.
    #[serde(rename = "retrograde-station", skip_serializing_if = "Option::is_none")]
    pub retrograde_station: Option<f64>,
    /// Number of events in this window of this event type. Absent when the type did not occur, so a zero is never written.
    #[serde(rename = "sign-ingress", skip_serializing_if = "Option::is_none")]
    pub sign_ingress: Option<f64>,
    /// Number of events in this window of this event type. Absent when the type did not occur, so a zero is never written.
    #[serde(rename = "transit-aspect", skip_serializing_if = "Option::is_none")]
    pub transit_aspect: Option<f64>,
}
/// Count of events in this window broken down by domain. Only domains with at least one event in the window are present. The values sum to count.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateDigestResponseWindowsItemByDomain {
    /// Number of events in this window produced by this forecast domain. Absent when the domain contributed nothing, so a zero is never written.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub biorhythm: Option<f64>,
    /// Number of events in this window produced by this forecast domain. Absent when the domain contributed nothing, so a zero is never written.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vedic: Option<f64>,
    /// Number of events in this window produced by this forecast domain. Absent when the domain contributed nothing, so a zero is never written.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub western: Option<f64>,
}
/// Echo of the birth subject this digest was built for.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateDigestResponseBirthData {
    /// Birth date in YYYY-MM-DD format. Anchors the natal chart and the Vimshottari dasha sequence.
    pub date: String,
    /// Birth latitude in decimal degrees. Optional and does not affect the timeline. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Optional and does not affect the timeline. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Birth time in 24-hour HH:MM:SS format. Precision matters for the natal positions the transit aspects are measured against.
    pub time: String,
    /// Decimal UTC offset the forecast was computed with, resolved from whatever the request sent. An IANA name is resolved to the offset in force at the birth date and time, so this is the literal number applied, never the name.
    pub timezone: f64,
}
/// Request body of `generateDigest`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateDigestRequest {
    /// The single birth subject this digest is built for. One object only, never an array.
    #[serde(rename = "birthData")]
    pub birth_data: GenerateDigestRequestBirthData,
    /// Per-domain significance multipliers applied before the significance floor and event cap. Bias which domains survive filtering and the cap. Omitted domains default to a weight of 1. Valid keys are western, vedic, and biorhythm.
    #[serde(rename = "domainWeights", skip_serializing_if = "Option::is_none")]
    pub domain_weights: Option<GenerateDigestRequestDomainWeights>,
    /// Which forecast domains to include before rolling up the windows. Defaults to all three.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub domains: Option<Vec<GenerateDigestRequestDomainsItem>>,
    /// Drop events scoring below this significance threshold from 0 to 100 before the rollup. Defaults to 0.
    #[serde(rename = "minSignificance", skip_serializing_if = "Option::is_none")]
    pub min_significance: Option<f64>,
    /// Start anchor for every window in YYYY-MM-DD format. The next 24h, 7d, 30d, and 90d windows are measured forward from this date at 00:00:00 UTC. Defaults to today in UTC.
    #[serde(rename = "startDate", skip_serializing_if = "Option::is_none")]
    pub start_date: Option<String>,
    /// Number of highest-significance events to surface per window. Defaults to 3, capped at 20.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub top: Option<i64>,
}
string_enum! {
    /// Forecast domain. western covers transit aspects, sign ingresses, retrograde stations, eclipses, and new and full moons. vedic covers Vimshottari mahadasha, antardasha, and pratyantardasha boundaries. biorhythm covers critical days.
    GenerateDigestRequestDomainsItem {
        Western = "western",
        Vedic = "vedic",
        Biorhythm = "biorhythm",
    }
}
/// Per-domain significance multipliers applied before the significance floor and event cap. Bias which domains survive filtering and the cap. Omitted domains default to a weight of 1. Valid keys are western, vedic, and biorhythm.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateDigestRequestDomainWeights {
    /// Multiplier for this domain significance. 1 leaves it unchanged, above 1 promotes the domain, below 1 demotes it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub biorhythm: Option<f64>,
    /// Multiplier for this domain significance. 1 leaves it unchanged, above 1 promotes the domain, below 1 demotes it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vedic: Option<f64>,
    /// Multiplier for this domain significance. 1 leaves it unchanged, above 1 promotes the domain, below 1 demotes it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub western: Option<f64>,
}
/// The single birth subject this digest is built for. One object only, never an array.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateDigestRequestBirthData {
    /// Birth date in YYYY-MM-DD format. Anchors the natal chart and the Vimshottari dasha sequence.
    pub date: String,
    /// Birth latitude in decimal degrees. Optional and does not affect the timeline. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Optional and does not affect the timeline. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Birth time in 24-hour HH:MM:SS format. Precision matters for the natal positions the transit aspects are measured against.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: GenerateDigestRequestBirthDataTimezone,
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GenerateDigestRequestBirthDataTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
/// Path and query parameters of `generateDigest`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateDigestParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateDigestParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateDigestParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `generateCompositeChart`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateCompositeChartResponse {
    /// Aspects between composite planets. Reveals the internal dynamics and energy patterns within the relationship.
    pub aspects: Vec<GenerateCompositeChartResponseAspectsItem>,
    /// Composite Ascendant. Represents how the relationship presents itself to the outside world.
    #[serde(rename = "compositeAscendant")]
    pub composite_ascendant: GenerateCompositeChartResponseCompositeAscendant,
    /// Composite house cusps, each the midpoint of the two natal cusps. Each house represents shared life areas in the relationship.
    #[serde(rename = "compositeHouses")]
    pub composite_houses: Vec<GenerateCompositeChartResponseCompositeHousesItem>,
    /// Composite Midheaven (MC). Represents shared goals, public image, and the direction the relationship grows toward.
    #[serde(rename = "compositeMidheaven")]
    pub composite_midheaven: GenerateCompositeChartResponseCompositeMidheaven,
    /// Composite planetary positions calculated as midpoints between both charts. Each planet represents a shared energy in the relationship.
    #[serde(rename = "compositePlanets")]
    pub composite_planets: Vec<GenerateCompositeChartResponseCompositePlanetsItem>,
    /// Composite chart interpretation with relationship strengths, challenges, and overall assessment.
    pub interpretation: GenerateCompositeChartResponseInterpretation,
    /// First person birth details.
    pub person1: GenerateCompositeChartResponsePerson1,
    /// Second person birth details.
    pub person2: GenerateCompositeChartResponsePerson2,
}
/// Second person birth details.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateCompositeChartResponsePerson2 {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone offset from UTC in decimal hours, resolved for the birth date. Examples: New York = -5 in winter and -4 in summer, London = 0, India = 5.5, Tokyo = 9.
    pub timezone: f64,
}
/// First person birth details.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateCompositeChartResponsePerson1 {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone offset from UTC in decimal hours, resolved for the birth date. Examples: New York = -5 in winter and -4 in summer, London = 0, India = 5.5, Tokyo = 9.
    pub timezone: f64,
}
/// Composite chart interpretation with relationship strengths, challenges, and overall assessment.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateCompositeChartResponseInterpretation {
    /// Potential friction points and growth opportunities in the relationship.
    pub challenges: Vec<String>,
    /// Areas where the relationship naturally thrives.
    pub strengths: Vec<String>,
    /// Overall relationship interpretation based on composite chart analysis.
    pub summary: String,
}
/// One entry of `compositePlanets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateCompositeChartResponseCompositePlanetsItem {
    /// Composite interpretation for this planet in the relationship chart.
    #[serde(rename = "compositeInterpretation", skip_serializing_if = "Option::is_none")]
    pub composite_interpretation: Option<
        GenerateCompositeChartResponseCompositePlanetsItemCompositeInterpretation,
    >,
    /// Degree within the zodiac sign (0-29.999). Indicates how far the planet has progressed through the sign.
    pub degree: f64,
    /// House placement (1-12). Determined by the selected house system and birth location.
    pub house: i64,
    /// Whether the planet appears to move backward from Earth perspective. Retrograde periods signal review and introspection.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Apparent geocentric ecliptic latitude of date, in degrees. Near zero for most planets, varies for the Moon and Pluto, and reaches up to about 5 degrees for Black Moon Lilith (projected from the inclined mean lunar orbit).
    pub latitude: f64,
    /// Apparent geocentric tropical longitude on the true ecliptic of date, in degrees (0-360): light time and aberration applied, nutation included, the convention desktop chart software and the NASA JPL Horizons observer tables print, so it compares directly with either. Primary coordinate for zodiac sign and aspect calculations.
    pub longitude: f64,
    /// Body name. One of the 10 classical planets (Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto), the lunar nodes (North Node, South Node), Chiron, or Black Moon Lilith (the mean lunar apogee). The lunar nodes follow the request nodeType, which defaults to the true (osculating) node; pass "mean" for the smoothed node. The two differ by up to about 1.8 degrees and no other body is affected.
    pub name: GenerateCompositeChartResponseCompositePlanetsItemName,
    /// Tropical zodiac sign this planet occupies. Determined by 30-degree divisions of ecliptic longitude.
    pub sign: String,
    /// Daily motion in degrees per day. Negative values indicate retrograde motion.
    pub speed: f64,
}
string_enum! {
    /// Body name. One of the 10 classical planets (Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto), the lunar nodes (North Node, South Node), Chiron, or Black Moon Lilith (the mean lunar apogee). The lunar nodes follow the request nodeType, which defaults to the true (osculating) node; pass "mean" for the smoothed node. The two differ by up to about 1.8 degrees and no other body is affected.
    GenerateCompositeChartResponseCompositePlanetsItemName {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
/// Composite interpretation for this planet in the relationship chart.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateCompositeChartResponseCompositePlanetsItemCompositeInterpretation {
    /// Key themes associated with this composite placement.
    pub keywords: Vec<String>,
    /// What this planet represents in the context of the relationship.
    #[serde(rename = "relationshipMeaning")]
    pub relationship_meaning: String,
    /// Narrative interpretation of this composite planet placement.
    pub summary: String,
}
/// Composite Midheaven (MC). Represents shared goals, public image, and the direction the relationship grows toward.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateCompositeChartResponseCompositeMidheaven {
    /// Degree within the sign (0-29.999).
    pub degree: f64,
    /// Absolute ecliptic longitude in degrees (0-360).
    pub longitude: f64,
    /// Zodiac sign on the composite Midheaven.
    pub sign: String,
}
/// One entry of `compositeHouses`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateCompositeChartResponseCompositeHousesItem {
    /// Degree within the zodiac sign (0-29.999).
    pub degree: f64,
    /// Absolute ecliptic longitude in degrees (0-360).
    pub longitude: f64,
    /// House number (1-12) in the composite chart.
    pub number: f64,
    /// Zodiac sign on the composite house cusp.
    pub sign: String,
}
/// Composite Ascendant. Represents how the relationship presents itself to the outside world.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateCompositeChartResponseCompositeAscendant {
    /// Degree within the sign (0-29.999).
    pub degree: f64,
    /// Absolute ecliptic longitude in degrees (0-360).
    pub longitude: f64,
    /// Zodiac sign on the composite Ascendant.
    pub sign: String,
}
/// One entry of `aspects`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateCompositeChartResponseAspectsItem {
    /// Exact angular separation that defines this aspect type in degrees.
    pub angle: f64,
    /// Aspect nature. Harmonious (trine, sextile) flows easily. Challenging (square, opposition) creates tension and growth. Neutral (conjunction) blends energies. Always English, whatever the lang parameter says: it is an identifier consumers switch and style on. Use interpretationLocalized for anything a reader sees.
    pub interpretation: GenerateCompositeChartResponseAspectsItemInterpretation,
    /// Whether the aspect is applying (planets moving toward exact) or separating (moving apart). Applying aspects grow stronger.
    #[serde(rename = "isApplying")]
    pub is_applying: bool,
    /// Deviation from exact aspect in degrees. Tighter orb means stronger influence.
    pub orb: f64,
    /// First planet in the aspect pair.
    pub planet1: GenerateCompositeChartResponseAspectsItemPlanet1,
    /// Second planet in the aspect pair.
    pub planet2: GenerateCompositeChartResponseAspectsItemPlanet2,
    /// Aspect strength percentage (0-100). Based on orb tightness relative to the allowed maximum.
    pub strength: f64,
    /// Aspect type. Major: conjunction (0), opposition (180), trine (120), square (90), sextile (60). Minor: semi-sextile, quincunx, semi-square, sesquiquadrate.
    pub r#type: GenerateCompositeChartResponseAspectsItemType,
}
string_enum! {
    /// Aspect type. Major: conjunction (0), opposition (180), trine (120), square (90), sextile (60). Minor: semi-sextile, quincunx, semi-square, sesquiquadrate.
    GenerateCompositeChartResponseAspectsItemType {
        Conjunction = "CONJUNCTION",
        Opposition = "OPPOSITION",
        Trine = "TRINE",
        Square = "SQUARE",
        Sextile = "SEXTILE",
        SemiSextile = "SEMI_SEXTILE",
        Quincunx = "QUINCUNX",
        SemiSquare = "SEMI_SQUARE",
        Sesquiquadrate = "SESQUIQUADRATE",
    }
}
string_enum! {
    /// Second planet in the aspect pair.
    GenerateCompositeChartResponseAspectsItemPlanet2 {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
string_enum! {
    /// First planet in the aspect pair.
    GenerateCompositeChartResponseAspectsItemPlanet1 {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
string_enum! {
    /// Aspect nature. Harmonious (trine, sextile) flows easily. Challenging (square, opposition) creates tension and growth. Neutral (conjunction) blends energies. Always English, whatever the lang parameter says: it is an identifier consumers switch and style on. Use interpretationLocalized for anything a reader sees.
    GenerateCompositeChartResponseAspectsItemInterpretation {
        Harmonious = "harmonious",
        Challenging = "challenging",
        Neutral = "neutral",
    }
}
/// Request body of `generateCompositeChart`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateCompositeChartRequest {
    /// House system for the composite chart. Placidus (default), Whole Sign, Equal, or Koch.
    #[serde(rename = "houseSystem", skip_serializing_if = "Option::is_none")]
    pub house_system: Option<GenerateCompositeChartRequestHouseSystem>,
    /// First person birth details (date, time, location, timezone).
    pub person1: GenerateCompositeChartRequestPerson1,
    /// Second person birth details (date, time, location, timezone).
    pub person2: GenerateCompositeChartRequestPerson2,
}
/// Second person birth details (date, time, location, timezone).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateCompositeChartRequestPerson2 {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<GenerateCompositeChartRequestPerson2NodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
    pub timezone: GenerateCompositeChartRequestPerson2Timezone,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GenerateCompositeChartRequestPerson2Timezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    GenerateCompositeChartRequestPerson2NodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// First person birth details (date, time, location, timezone).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateCompositeChartRequestPerson1 {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<GenerateCompositeChartRequestPerson1NodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
    pub timezone: GenerateCompositeChartRequestPerson1Timezone,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GenerateCompositeChartRequestPerson1Timezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    GenerateCompositeChartRequestPerson1NodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// House system for the composite chart. Placidus (default), Whole Sign, Equal, or Koch.
    GenerateCompositeChartRequestHouseSystem {
        Placidus = "placidus",
        WholeSign = "whole-sign",
        Equal = "equal",
        Koch = "koch",
    }
}
/// Path and query parameters of `generateCompositeChart`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateCompositeChartParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateCompositeChartParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateCompositeChartParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `generateBodygraph`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBodygraphResponse {
    /// The aura mechanic of the type: how the energy field itself operates, for example open and enveloping, or closed and repelling.
    pub aura: String,
    /// Inner authority for decision making. One of Emotional, Sacral, Splenic, Ego, Self-Projected, Mental, Lunar. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use authorityLocalized for anything a reader sees.
    pub authority: String,
    /// How the decision is made, the timing it requires, and the characteristic trap. Inner authority is the most actionable output of a Human Design chart, so this is the field to lean on when grounding a reading.
    #[serde(rename = "authorityDescription")]
    pub authority_description: String,
    /// Inner authority name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "authorityLocalized", skip_serializing_if = "Option::is_none")]
    pub authority_localized: Option<String>,
    /// All nine centers with their defined state and active gates.
    pub centers: Vec<GenerateBodygraphResponseCentersItem>,
    /// The defined channels where both gates are activated.
    pub channels: Vec<GenerateBodygraphResponseChannelsItem>,
    /// Definition type from the number of connected components among defined centers. One of None, Single, Split, Triple Split, Quadruple Split. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use definitionLocalized for anything a reader sees.
    pub definition: String,
    /// How energy flows through the defined centers in this configuration, and what the configuration needs. For a split, this is where the bridging gates of other people matter.
    #[serde(rename = "definitionDescription")]
    pub definition_description: String,
    /// Definition type name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "definitionLocalized", skip_serializing_if = "Option::is_none")]
    pub definition_localized: Option<String>,
    /// The Design moment as an ISO 8601 UTC instant: the exact time the Sun stood 88 degrees of solar arc before its natal longitude, and the instant every Design activation was computed at. Compare it with the Design date a reference tool prints to validate the chart on the moment itself.
    #[serde(rename = "designInstantUtc")]
    pub design_instant_utc: String,
    /// All 26 activations, 13 Personality and 13 Design.
    pub gates: Vec<GenerateBodygraphResponseGatesItem>,
    /// The incarnation cross built from the four cardinal gates and the profile angle.
    #[serde(rename = "incarnationCross")]
    pub incarnation_cross: GenerateBodygraphResponseIncarnationCross,
    /// The not-self theme, the recurring feeling that signals being out of alignment. Always English, whatever the lang parameter says. Use notSelfLocalized for anything a reader sees.
    #[serde(rename = "notSelf")]
    pub not_self: String,
    /// Not-self theme name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "notSelfLocalized", skip_serializing_if = "Option::is_none")]
    pub not_self_localized: Option<String>,
    /// Profile in conscious/unconscious form from the Personality Sun line over the Design Sun line.
    pub profile: String,
    /// Meaning of the combined profile. A profile is not the sum of its two lines: 6/2 has its own meaning that neither the line 6 nor the line 2 keynote carries alone.
    #[serde(rename = "profileDescription")]
    pub profile_description: String,
    /// The two line keynotes the profile is built from, conscious over unconscious, so the profile is readable without a separate lookup.
    #[serde(rename = "profileKeynotes")]
    pub profile_keynotes: GenerateBodygraphResponseProfileKeynotes,
    /// What the two chart sides are: personality is the conscious mind side, design is the unconscious body side computed 88 degrees of solar arc before birth. Returned once at the top level rather than repeated across all 26 activations.
    pub sides: GenerateBodygraphResponseSides,
    /// The signature feeling of living in alignment with the type. Always English, whatever the lang parameter says. Use signatureLocalized for anything a reader sees.
    pub signature: String,
    /// Signature theme name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signatureLocalized", skip_serializing_if = "Option::is_none")]
    pub signature_localized: Option<String>,
    /// The aura strategy for engaging life correctly for this type. Always English, whatever the lang parameter says. Use strategyLocalized for anything a reader sees.
    pub strategy: String,
    /// How to actually apply the strategy. The strategy field alone is a bare label such as Respond or Inform; this is the operating instruction behind it.
    #[serde(rename = "strategyDescription")]
    pub strategy_description: String,
    /// Strategy name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "strategyLocalized", skip_serializing_if = "Option::is_none")]
    pub strategy_localized: Option<String>,
    /// Human Design energy type. One of Manifestor, Generator, Manifesting Generator, Projector, Reflector. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use typeLocalized for anything a reader sees.
    pub r#type: String,
    /// What the aura of this type does and how it is designed to engage life. The grounding text for the type label, so a consuming agent does not have to supply the meaning itself.
    #[serde(rename = "typeDescription")]
    pub type_description: String,
    /// Energy type name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "typeLocalized", skip_serializing_if = "Option::is_none")]
    pub type_localized: Option<String>,
}
/// What the two chart sides are: personality is the conscious mind side, design is the unconscious body side computed 88 degrees of solar arc before birth. Returned once at the top level rather than repeated across all 26 activations.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBodygraphResponseSides {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, String>,
}
/// The two line keynotes the profile is built from, conscious over unconscious, so the profile is readable without a separate lookup.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBodygraphResponseProfileKeynotes {
    /// Keynote of the unconscious Design line. The half of the life role others see operating in the body, which the person does not directly experience.
    pub design: String,
    /// Line number 1 to 6 of the unconscious Design Sun, the second digit of the profile.
    #[serde(rename = "designLine")]
    pub design_line: f64,
    /// Keynote of the conscious Personality line. The half of the life role the person is aware of and can speak to.
    pub personality: String,
    /// Line number 1 to 6 of the conscious Personality Sun, the first digit of the profile.
    #[serde(rename = "personalityLine")]
    pub personality_line: f64,
}
/// The incarnation cross built from the four cardinal gates and the profile angle.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBodygraphResponseIncarnationCross {
    /// Cross angle. One of Right Angle, Juxtaposition, Left Angle. Always English, whatever the lang parameter says. Use angleLocalized for anything a reader sees.
    pub angle: String,
    /// Short code for the angle. One of RAX, JXT, LAX.
    #[serde(rename = "angleCode")]
    pub angle_code: String,
    /// Cross angle name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "angleLocalized", skip_serializing_if = "Option::is_none")]
    pub angle_localized: Option<String>,
    /// The life theme of the cross, synthesized from its four gates and the orientation the angle gives them. The same Sun gate under a different angle is a genuinely different theme: Right Angle is personal destiny, Left Angle is worked out through other people, Juxtaposition is a fixed fate.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// The four cardinal gates of the cross: Personality Sun, Personality Earth, Design Sun, Design Earth.
    pub gates: Vec<f64>,
    /// Canonical published name of the incarnation cross, determined by the Personality Sun gate and the angle. All 192 crosses (64 Personality Sun gates times three angles) carry their published name, numbered variants included, so this is never a composed placeholder. Always begins with the angle followed by Cross of. Always English, whatever the lang parameter says.
    pub name: String,
}
/// One entry of `gates`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBodygraphResponseGatesItem {
    /// Human Design gate number from 1 to 64 that this activation falls in.
    pub gate: f64,
    /// Bodygraph function of the gate: what it does in the center it sits in and the channel it forms. This is NOT the meaning of the I-Ching hexagram that shares its number. They share a number, not a definition.
    #[serde(rename = "gateDescription")]
    pub gate_description: String,
    /// Human Design keynote name of the gate, describing its bodygraph function. Always English, whatever the lang parameter says. Use gateNameLocalized for anything a reader sees.
    #[serde(rename = "gateName")]
    pub gate_name: String,
    /// Gate keynote name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "gateNameLocalized", skip_serializing_if = "Option::is_none")]
    pub gate_name_localized: Option<String>,
    /// Cross-reference to the I-Ching hexagram that shares this gate number.
    #[serde(rename = "ichingHexagram")]
    pub iching_hexagram: GenerateBodygraphResponseGatesItemIchingHexagram,
    /// Line number from 1 to 6 within the gate, setting the line keynote and the profile.
    pub line: f64,
    /// Meaning of this gate at this specific line, one of 384. The finest interpretive layer in the chart and the one that makes a reading specific rather than generic. This is not the six abstract line archetypes: gate 41 line 3 carries its own meaning that neither the gate keynote nor the line-3 archetype holds alone.
    #[serde(rename = "lineMeaning")]
    pub line_meaning: String,
    /// Activating body. One of Sun, Earth, Moon, North Node, South Node, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto. Always English, whatever the lang parameter says, so it stays safe to compare against in code and to key a glyph table on. Use planetLocalized for anything a reader sees.
    pub planet: String,
    /// What this planetary activation contributes in Human Design specifically, which is not its meaning in western astrology.
    #[serde(rename = "planetDescription")]
    pub planet_description: String,
    /// Activating body name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "planetLocalized", skip_serializing_if = "Option::is_none")]
    pub planet_localized: Option<String>,
    /// Chart side. personality is the conscious birth-moment activation, design is the unconscious activation 88 degrees of solar arc before birth.
    pub side: String,
}
/// Cross-reference to the I-Ching hexagram that shares this gate number.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBodygraphResponseGatesItemIchingHexagram {
    /// English name of the corresponding I-Ching hexagram.
    pub english: String,
    /// I-Ching hexagram number, identical to the gate number it corresponds to.
    pub number: f64,
}
/// One entry of `channels`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBodygraphResponseChannelsItem {
    /// The two centers this channel connects and defines.
    pub centers: Vec<String>,
    /// Circuit family of the channel. One of Individual, Collective, Tribal. Always English, whatever the lang parameter says. Use circuitLocalized for anything a reader sees.
    pub circuit: String,
    /// What the circuit family of this channel governs.
    #[serde(rename = "circuitDescription")]
    pub circuit_description: String,
    /// Circuit family name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "circuitLocalized", skip_serializing_if = "Option::is_none")]
    pub circuit_localized: Option<String>,
    /// What this channel wires between its two centers and the nature of the energy it carries.
    pub description: String,
    /// First gate of the channel.
    #[serde(rename = "gateA")]
    pub gate_a: f64,
    /// Second gate of the channel.
    #[serde(rename = "gateB")]
    pub gate_b: f64,
    /// Name of the defined channel. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Channel name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
}
/// One entry of `centers`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBodygraphResponseCentersItem {
    /// Whether this is an awareness center. The three awareness centers are Ajna, Solar Plexus, and Spleen.
    pub awareness: bool,
    /// The gland, organ, or system this center corresponds to in the body.
    pub biology: String,
    /// Whether the center is defined. A defined center is a consistent source of energy or awareness; an undefined center is open and conditioned by others.
    pub defined: bool,
    /// Active gate numbers that sit in this center.
    pub gates: Vec<f64>,
    /// Center identifier. One of head, ajna, throat, g, heart, sacral, solar-plexus, spleen, root.
    pub id: String,
    /// Whether this is a motor center (energy source). The four motors are Heart, Sacral, Solar Plexus, and Root.
    pub motor: bool,
    /// Display name of the center. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Center name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// The conditioning trap of this center when it is open. Returned on every center so a consumer can surface it the moment `defined` is false, which is where the not-self operates.
    #[serde(rename = "notSelfQuestion")]
    pub not_self_question: String,
    /// Theme text describing the center in its current defined or undefined state.
    pub theme: String,
}
/// Request body of `generateBodygraph`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBodygraphRequest {
    /// Birth date in YYYY-MM-DD format. The anchor for both the Personality activations at birth and the Design activations 88 degrees of solar arc earlier.
    pub date: String,
    /// Birth latitude in decimal degrees. Optional and does not affect the bodygraph, which depends only on ecliptic longitudes. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Optional and does not affect the bodygraph. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<GenerateBodygraphRequestNodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Precision matters: the profile lines and gate boundaries shift with the exact minute of birth.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: GenerateBodygraphRequestTimezone,
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GenerateBodygraphRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    GenerateBodygraphRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Path and query parameters of `generateBodygraph`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateBodygraphParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateBodygraphParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateBodygraphParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `generateBirthProfile`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBirthProfileResponse {
    /// The three names: two read from the day of birth by two different cycles, and one from the hour. All three are described, never invoked.
    pub angels: Vec<GenerateBirthProfileResponseAngelsItem>,
    /// The birth moment this answer was computed from.
    #[serde(rename = "birthData")]
    pub birth_data: GenerateBirthProfileResponseBirthData,
    /// The conventions this answer was computed under, echoed so it can be reproduced.
    pub conventions: GenerateBirthProfileResponseConventions,
    /// The next Hebrew birthday. Three Hebrew dates are missing from some years, and where the anniversary moves to is a matter of community practice rather than arithmetic, so the field is null with a note rather than a guess.
    #[serde(rename = "hebrewBirthday")]
    pub hebrew_birthday: GenerateBirthProfileResponseHebrewBirthday,
    /// The Hebrew date of the birth.
    #[serde(rename = "hebrewDate")]
    pub hebrew_date: GenerateBirthProfileResponseHebrewDate,
    /// The sephirah reached from the value of the Hebrew date written in letters. A numerical convention rather than a classical rule, offered as a way into the tree.
    pub sephirah: GenerateBirthProfileResponseSephirah,
}
/// The sephirah reached from the value of the Hebrew date written in letters. A numerical convention rather than a classical rule, offered as a way into the tree.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBirthProfileResponseSephirah {
    /// The English gloss of the name, in the requested language.
    pub english: String,
    /// The name in Hebrew. Data, identical in every language.
    pub hebrew: String,
    /// Machine identifier of the sephirah of the birth day.
    pub id: String,
    /// What the emanation is said to hold, in the requested language.
    pub meaning: String,
    /// Its position in the emanation, 1 to 10.
    pub number: Option<f64>,
    /// Latin transcription of the Hebrew, from the mechanical letter map.
    pub romanization: String,
}
/// The Hebrew date of the birth.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBirthProfileResponseHebrewDate {
    /// Echo of the sunset flag. The Hebrew day begins in the evening, so a moment after nightfall already belongs to the next date and this says whether that was applied.
    #[serde(rename = "afterSunset")]
    pub after_sunset: bool,
    /// Day of the Hebrew month, 1 to 30.
    pub day: f64,
    /// The date written the way it is printed, with the day and the year in Hebrew letters. Data, identical in every language.
    pub hebrew: String,
    /// True in the seven years of each nineteen that carry a second Adar.
    #[serde(rename = "leapYear")]
    pub leap_year: bool,
    /// Hebrew month name. A leap year carries Adar I and Adar II in place of Adar, which is why the name is returned rather than only a number.
    pub month: String,
    /// Month number in the published algorithm order, Nisan first. Adar II is 13.
    #[serde(rename = "monthNumber")]
    pub month_number: f64,
    /// Hebrew year.
    pub year: f64,
}
/// The next Hebrew birthday. Three Hebrew dates are missing from some years, and where the anniversary moves to is a matter of community practice rather than arithmetic, so the field is null with a note rather than a guess.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBirthProfileResponseHebrewBirthday {
    /// The next Gregorian date the Hebrew birthday falls on, or null when that Hebrew date does not exist in the year it would fall in.
    pub date: Option<String>,
    /// The Hebrew year the anniversary was looked for in.
    #[serde(rename = "hebrewYear")]
    pub hebrew_year: f64,
    /// Present only when the date is null, saying why. Absent otherwise, so a caller can branch on presence.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
}
/// The conventions this answer was computed under, echoed so it can be reproduced.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBirthProfileResponseConventions {
    /// Whether the Hebrew date was advanced for nightfall.
    #[serde(rename = "afterSunset")]
    pub after_sunset: bool,
    /// Which construction dated the name of the day.
    #[serde(rename = "angelDating")]
    pub angel_dating: String,
    /// Where 29 February was read as falling.
    #[serde(rename = "leapDayPolicy")]
    pub leap_day_policy: String,
    /// Where the civil wheel opened. Reported even under solar-longitude, where it selects nothing, so a stored response records every input.
    #[serde(rename = "yearStart")]
    pub year_start: String,
}
/// The birth moment this answer was computed from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBirthProfileResponseBirthData {
    /// Echo of the birth date.
    pub date: String,
    /// The birth time used, which is noon when none was sent.
    pub time: String,
    /// The timezone resolved to a decimal offset in hours. An IANA name sent on the request is resolved against the birth date, so a summer birth carries its summer offset.
    pub timezone: f64,
}
/// One entry of `angels`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBirthProfileResponseAngelsItem {
    /// The angelic choir the name belongs to under the published Renaissance table.
    pub choir: String,
    /// The name in Hebrew. Data, identical in every language.
    pub name: String,
    /// Index of the name, 1 to 72.
    pub number: f64,
    /// What the tradition says this name is read for, in the requested language.
    pub reading: String,
    /// What this name is read from: body and character both come from the day of birth by two different cycles, and spirit comes from the hour. Always English, so it stays safe to compare against in code.
    pub role: String,
    /// Latin transcription of the Hebrew, from the one mechanical letter map.
    pub romanization: String,
    /// The Latin spelling the published tables print, which is the searchable name.
    #[serde(rename = "traditionalName")]
    pub traditional_name: String,
    /// The window that selected this name, in the terms of its own cycle: an arc of longitude, a span of civil days, or a twenty minute interval of the clock.
    pub window: String,
}
/// Request body of `generateBirthProfile`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBirthProfileRequest {
    /// Set true when the moment falls after nightfall, which advances the Hebrew date by one day because the Hebrew day begins in the evening. It is a caller assertion rather than a computation, since sunset depends on a place and this conversion takes none.
    #[serde(rename = "afterSunset", skip_serializing_if = "Option::is_none")]
    pub after_sunset: Option<bool>,
    /// How the name of the day is found. Use solar-longitude for the exact five degree arc the Sun stood in at the birth moment, or lenain-blocks for the fixed civil calendar of five day periods. The Sun does not move at a constant rate, so the two drift apart by up to about three days by early August and were never reconciled.
    #[serde(rename = "angelDating", skip_serializing_if = "Option::is_none")]
    pub angel_dating: Option<GenerateBirthProfileRequestAngelDating>,
    /// Birth date in YYYY-MM-DD, proleptic Gregorian. Dates before the 1582 reform are read on the same proleptic reckoning rather than switched to the Julian calendar.
    pub date: String,
    /// Where 29 February falls. The civil wheel was built for a 365 day year and has no slot for it, so published tables differ: extend-previous reads the day as part of the period ending 28 February, next-angel reads it as the opening of the period starting 1 March. Ignored when angelDating is solar-longitude.
    #[serde(rename = "leapDayPolicy", skip_serializing_if = "Option::is_none")]
    pub leap_day_policy: Option<GenerateBirthProfileRequestLeapDayPolicy>,
    /// Birth time in HH:MM:SS local to the timezone field. Defaults to noon when omitted, which is stated because the name read from the hour changes every twenty minutes and a defaulted time cannot be precise.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub time: Option<String>,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: GenerateBirthProfileRequestTimezone,
    /// Which date the civil wheel of five day periods opens on. Both are conventions rather than facts: the equinox itself moves inside a window that covers both days, and it fell on 20 March in 2026. march-21 is the pinned published wheel and march-20 is that wheel shifted one day. Ignored when angelDating is solar-longitude.
    #[serde(rename = "yearStart", skip_serializing_if = "Option::is_none")]
    pub year_start: Option<GenerateBirthProfileRequestYearStart>,
}
string_enum! {
    /// Which date the civil wheel of five day periods opens on. Both are conventions rather than facts: the equinox itself moves inside a window that covers both days, and it fell on 20 March in 2026. march-21 is the pinned published wheel and march-20 is that wheel shifted one day. Ignored when angelDating is solar-longitude.
    GenerateBirthProfileRequestYearStart {
        March21 = "march-21",
        March20 = "march-20",
    }
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GenerateBirthProfileRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Where 29 February falls. The civil wheel was built for a 365 day year and has no slot for it, so published tables differ: extend-previous reads the day as part of the period ending 28 February, next-angel reads it as the opening of the period starting 1 March. Ignored when angelDating is solar-longitude.
    GenerateBirthProfileRequestLeapDayPolicy {
        ExtendPrevious = "extend-previous",
        NextAngel = "next-angel",
    }
}
string_enum! {
    /// How the name of the day is found. Use solar-longitude for the exact five degree arc the Sun stood in at the birth moment, or lenain-blocks for the fixed civil calendar of five day periods. The Sun does not move at a constant rate, so the two drift apart by up to about three days by early August and were never reconciled.
    GenerateBirthProfileRequestAngelDating {
        SolarLongitude = "solar-longitude",
        LenainBlocks = "lenain-blocks",
    }
}
/// Path and query parameters of `generateBirthProfile`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateBirthProfileParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateBirthProfileParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateBirthProfileParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `generateBirthChart`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateBirthChartParams {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<GenerateBirthChartParamsFocus>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateBirthChartParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateBirthChartParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    GenerateBirthChartParamsFocus {
        General = "general",
        Finance = "finance",
    }
}
/// Response body of `generateBaziChart`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBaziChartResponse {
    /// Echo of the birth moment the chart was computed from.
    #[serde(rename = "birthData")]
    pub birth_data: GenerateBaziChartResponseBirthData,
    /// The three school conventions this result was computed under. Returned on every BaZi response so a chart is self-describing: two calculators can produce different pillars for one birth and both be correct, and this object says which reading you are holding.
    pub conventions: GenerateBaziChartResponseConventions,
    /// The day stem, which is the subject of the whole chart. Everything else in the response is named by what it does to this one.
    #[serde(rename = "dayMaster")]
    pub day_master: GenerateBaziChartResponseDayMaster,
    /// Element balance across the eight chart characters, one entry per phase, with the reading for how represented each one is.
    #[serde(rename = "fiveElements")]
    pub five_elements: Vec<GenerateBaziChartResponseFiveElementsItem>,
    /// Combinations, clashes, harms and punishments running between the four pillars. An empty array means the four pillars stand independently of each other, which is common and is not a defect.
    pub interactions: Vec<GenerateBaziChartResponseInteractionsItem>,
    /// The four pillars, year first. Each carries its stem, its branch, the hidden stems stored in the branch, the Ten God relation to the Day Master, and the Na Yin sound element of the pair.
    pub pillars: Vec<GenerateBaziChartResponsePillarsItem>,
    /// One-paragraph reading composed from the Day Master nature and the seasonal state of its element in the birth month. The narrative entry point for a chart, for a consumer that renders one block before the detail.
    pub summary: String,
    /// Zodiac animal of the year branch, under the year boundary this request applied. Always English, whatever the lang parameter says. Use zodiacAnimalLocalized for anything a reader sees.
    #[serde(rename = "zodiacAnimal")]
    pub zodiac_animal: String,
    /// Zodiac animal name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "zodiacAnimalLocalized", skip_serializing_if = "Option::is_none")]
    pub zodiac_animal_localized: Option<String>,
}
/// One entry of `pillars`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBaziChartResponsePillarsItem {
    /// The Earthly Branch of this pillar.
    pub branch: GenerateBaziChartResponsePillarsItemBranch,
    /// Stems stored inside the branch, principal first. These carry the qi a branch holds without showing it, and they are where a Day Master finds a root.
    #[serde(rename = "hiddenStems")]
    pub hidden_stems: Vec<GenerateBaziChartResponsePillarsItemHiddenStemsItem>,
    /// Pillar identifier, the stem id and the branch id joined by a hyphen. Always English pinyin, whatever the lang parameter says.
    pub id: String,
    /// Na Yin sound element of the pillar, an older elemental reading assigned to each of the 30 stem-and-branch pairs. The hanzi name sits beside it in naYinChinese.
    #[serde(rename = "naYin")]
    pub na_yin: String,
    /// The Na Yin name in hanzi. Identical under every lang.
    #[serde(rename = "naYinChinese")]
    pub na_yin_chinese: String,
    /// Element the Na Yin resolves to. Independent of the stem element and often different from it, which is why it is reported separately rather than folded in. Always English, whatever the lang parameter says. Use naYinElementLocalized for anything a reader sees.
    #[serde(rename = "naYinElement")]
    pub na_yin_element: String,
    /// Na Yin element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "naYinElementLocalized", skip_serializing_if = "Option::is_none")]
    pub na_yin_element_localized: Option<String>,
    /// Position of this pillar in the sexagenary cycle, 1 to 60, where jia-zi is 1. The cycle runs stems and branches together, which is why only 60 of the 120 possible pairings occur.
    pub number: f64,
    /// Which of the four pillars this is. One of year, month, day, hour. The year pillar reads ancestry and early life, the month career and parents, the day the self and the partner, the hour later life and children.
    pub position: String,
    /// The Heavenly Stem of this pillar.
    pub stem: GenerateBaziChartResponsePillarsItemStem,
    /// Relation the pillar STEM holds to the Day Master. The day pillar carries day-master instead, because the day stem is the reference point every other position is measured from rather than a relation to itself.
    #[serde(rename = "tenGod")]
    pub ten_god: GenerateBaziChartResponsePillarsItemTenGod,
}
/// Relation the pillar STEM holds to the Day Master. The day pillar carries day-master instead, because the day stem is the reference point every other position is measured from rather than a relation to itself.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBaziChartResponsePillarsItemTenGod {
    /// Which of the five cycle relations this belongs to. peer is the same element as the Day Master, output is what the Day Master generates, wealth is what it controls, influence is what controls it, resource is what generates it, and self marks the Day Master itself. Always English, whatever the lang parameter says.
    pub category: String,
    /// The relation in traditional hanzi. Identical under every lang.
    pub chinese: String,
    /// Ten God identifier. One of friend, rob-wealth, eating-god, hurting-officer, indirect-wealth, direct-wealth, seven-killings, direct-officer, indirect-resource, direct-resource, plus day-master in the day-stem position. Always English, whatever the lang parameter says.
    pub id: String,
    /// One-line summary of what this relation contributes, for a compact rendering that has no room for the full meaning.
    pub keynote: String,
    /// Display name of the relation. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Ten God name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone-marked pinyin for the relation. Identical under every lang.
    pub pinyin: String,
}
/// The Heavenly Stem of this pillar.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBaziChartResponsePillarsItemStem {
    /// The stem in hanzi. Data rather than display copy, so it is identical under every lang.
    pub chinese: String,
    /// Five-phase element of the stem. One of Wood, Fire, Earth, Metal, Water. Always English, whatever the lang parameter says. Use elementLocalized for anything a reader sees.
    pub element: String,
    /// Element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Heavenly Stem identifier. One of jia, yi, bing, ding, wu, ji, geng, xin, ren, gui. Always English pinyin, whatever the lang parameter says, so it stays safe to compare against in code and to key a glyph table on.
    pub id: String,
    /// Tone-marked pinyin for the stem. Identical under every lang.
    pub pinyin: String,
    /// Polarity of the stem, yang or yin. The five odd stems are yang and the five even ones are yin, and this is half of what decides every Ten God relation in the chart.
    pub polarity: String,
}
/// One entry of `hiddenStems`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBaziChartResponsePillarsItemHiddenStemsItem {
    /// Rank of this stem inside the branch, by the classical day-count that divides a thirty-day month 18, 9 and 3 days between the stems a branch holds. principal is the first-ranked stem and always matches the branch element; middle is the second-ranked; residual is the third. A branch holds one to three, always returned in rank order. What each rank CONTAINS depends on the branch family: on a storage branch the second-ranked stem is the seasonal carryover from the month before and the third is the stem that branch stores as the close of its trine, while on a growth branch the second-ranked stem is the one beginning its long-life phase there and the third is the carryover. Some schools name the same three positions by that function rather than by rank, which swaps the second and third labels on the four storage branches, so compare on rank rather than assuming a name.
    pub role: String,
    /// The stem stored in the branch.
    pub stem: GenerateBaziChartResponsePillarsItemHiddenStemsItemStem,
    /// Relation this hidden stem holds to the Day Master.
    #[serde(rename = "tenGod")]
    pub ten_god: GenerateBaziChartResponsePillarsItemHiddenStemsItemTenGod,
}
/// Relation this hidden stem holds to the Day Master.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBaziChartResponsePillarsItemHiddenStemsItemTenGod {
    /// Which of the five cycle relations this belongs to. peer is the same element as the Day Master, output is what the Day Master generates, wealth is what it controls, influence is what controls it, resource is what generates it, and self marks the Day Master itself. Always English, whatever the lang parameter says.
    pub category: String,
    /// The relation in traditional hanzi. Identical under every lang.
    pub chinese: String,
    /// Ten God identifier. One of friend, rob-wealth, eating-god, hurting-officer, indirect-wealth, direct-wealth, seven-killings, direct-officer, indirect-resource, direct-resource, plus day-master in the day-stem position. Always English, whatever the lang parameter says.
    pub id: String,
    /// One-line summary of what this relation contributes, for a compact rendering that has no room for the full meaning.
    pub keynote: String,
    /// Display name of the relation. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Ten God name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone-marked pinyin for the relation. Identical under every lang.
    pub pinyin: String,
}
/// The stem stored in the branch.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBaziChartResponsePillarsItemHiddenStemsItemStem {
    /// The stem in hanzi. Data rather than display copy, so it is identical under every lang.
    pub chinese: String,
    /// Five-phase element of the stem. One of Wood, Fire, Earth, Metal, Water. Always English, whatever the lang parameter says. Use elementLocalized for anything a reader sees.
    pub element: String,
    /// Element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Heavenly Stem identifier. One of jia, yi, bing, ding, wu, ji, geng, xin, ren, gui. Always English pinyin, whatever the lang parameter says, so it stays safe to compare against in code and to key a glyph table on.
    pub id: String,
    /// Tone-marked pinyin for the stem. Identical under every lang.
    pub pinyin: String,
    /// Polarity of the stem, yang or yin. The five odd stems are yang and the five even ones are yin, and this is half of what decides every Ten God relation in the chart.
    pub polarity: String,
}
/// The Earthly Branch of this pillar.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBaziChartResponsePillarsItemBranch {
    /// Zodiac animal of the branch. One of rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, pig. Always English, whatever the lang parameter says. Use animalLocalized for anything a reader sees.
    pub animal: String,
    /// Zodiac animal name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "animalLocalized", skip_serializing_if = "Option::is_none")]
    pub animal_localized: Option<String>,
    /// The branch in hanzi. Identical under every lang.
    pub chinese: String,
    /// Five-phase element of the branch. Always English, whatever the lang parameter says. Use elementLocalized for anything a reader sees.
    pub element: String,
    /// Element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Earthly Branch identifier. One of zi, chou, yin, mao, chen, si, wu, wei, shen, you, xu, hai. Always English pinyin, whatever the lang parameter says. Note that "wu" is also a stem identifier: they never share a field, so a branch id is only ever read out of a branch position.
    pub id: String,
    /// Tone-marked pinyin for the branch. Identical under every lang.
    pub pinyin: String,
    /// Polarity of the branch, yang or yin.
    pub polarity: String,
}
/// One entry of `interactions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBaziChartResponseInteractionsItem {
    /// The interaction named in hanzi. Identical under every lang.
    pub chinese: String,
    /// Punishments only. True when the third branch of the group is also present in the chart, which is what a complete three-punishment means. False marks the partial case, where only two of the three are in play.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub complete: Option<bool>,
    /// Identifier of the pairing itself, the member ids joined by hyphens in canonical order.
    pub id: String,
    /// What this kind of interaction does between the positions it joins.
    pub meaning: String,
    /// The stem or branch ids taking part, in the same order as positions.
    pub members: Vec<String>,
    /// Tone-marked pinyin for the interaction. Identical under every lang.
    pub pinyin: String,
    /// The chart positions taking part, in the same order as members. On a two-person reading these are prefixed with the subject, for example personA.day.
    pub positions: Vec<String>,
    /// Whether the interaction binds or breaks. harmonious for combinations and trines, challenging for clashes, harms and punishments. Always English, whatever the lang parameter says.
    pub quality: String,
    /// Element the formation resolves to. Present on stem combinations and on complete trines, absent on everything else. Branch six combinations deliberately carry none: the classical sources assign transformed elements to the stem pairs and not to these, and one of the six is contested between schools.
    #[serde(rename = "transformsTo", skip_serializing_if = "Option::is_none")]
    pub transforms_to: Option<String>,
    /// Kind of interaction. stem-combination and six-combination bind two positions, trine binds three, and clash, harm, punishment and stem-clash break them. Always English, whatever the lang parameter says.
    pub r#type: String,
    /// Class of a punishment, present on punishments only. ungrateful is the tiger, snake and monkey group, bullying the ox, dog and goat group, discourteous the rat and rabbit pair, and self a branch doubled against itself.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub variety: Option<String>,
}
/// One entry of `fiveElements`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBaziChartResponseFiveElementsItem {
    /// How many of the eight chart characters carry this element, counting the four stems and the four branch elements one point each. Hidden stems are deliberately not counted here: a weighted total is a different quantity and mixing the two produces a number that matches no other calculator.
    pub count: f64,
    /// Five-phase element. Always English, whatever the lang parameter says. Use elementLocalized for anything a reader sees.
    pub element: String,
    /// Element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// How represented the element is. deficient means absent from all eight characters, excess means three or more, balanced is one or two. Always English, whatever the lang parameter says.
    pub level: String,
    /// What this level of representation means for the chart.
    pub reading: String,
}
/// The day stem, which is the subject of the whole chart. Everything else in the response is named by what it does to this one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBaziChartResponseDayMaster {
    /// The Day Master stem in hanzi. Identical under every lang.
    pub chinese: String,
    /// Five-phase element of the Day Master. Every Ten God in the chart is measured from this element and this polarity. Always English, whatever the lang parameter says. Use elementLocalized for anything a reader sees.
    pub element: String,
    /// Element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// What this particular stem is like as a Day Master, in the imagery the tradition uses to distinguish the two stems of each element. The yang and yin forms of one element behave very differently and this is where that difference lives.
    pub nature: String,
    /// Tone-marked pinyin for the Day Master stem.
    pub pinyin: String,
    /// Polarity of the Day Master, yang or yin.
    pub polarity: String,
    /// Day stem identifier, which IS the Day Master. Always English pinyin, whatever the lang parameter says.
    pub stem: String,
}
/// The three school conventions this result was computed under. Returned on every BaZi response so a chart is self-describing: two calculators can produce different pillars for one birth and both be correct, and this object says which reading you are holding.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBaziChartResponseConventions {
    /// Day-boundary school actually applied. Echoes the request, or the default when it was omitted. Always English, whatever the lang parameter says, so it stays safe to compare against in code.
    #[serde(rename = "dayBoundary")]
    pub day_boundary: GenerateBaziChartResponseConventionsDayBoundary,
    /// Hour clock actually applied. Echoes the request, or the default when omitted.
    #[serde(rename = "hourClock")]
    pub hour_clock: GenerateBaziChartResponseConventionsHourClock,
    /// Year-boundary school actually applied. Echoes the request, or the default when it was omitted.
    #[serde(rename = "yearBoundary")]
    pub year_boundary: GenerateBaziChartResponseConventionsYearBoundary,
}
string_enum! {
    /// Year-boundary school actually applied. Echoes the request, or the default when it was omitted.
    GenerateBaziChartResponseConventionsYearBoundary {
        LiChun = "li-chun",
        LunarNewYear = "lunar-new-year",
    }
}
string_enum! {
    /// Hour clock actually applied. Echoes the request, or the default when omitted.
    GenerateBaziChartResponseConventionsHourClock {
        Clock = "clock",
        LocalMean = "local-mean",
        Solar = "solar",
    }
}
string_enum! {
    /// Day-boundary school actually applied. Echoes the request, or the default when it was omitted. Always English, whatever the lang parameter says, so it stays safe to compare against in code.
    GenerateBaziChartResponseConventionsDayBoundary {
        SplitZi = "split-zi",
        Midnight = "midnight",
        EarlyZi = "early-zi",
    }
}
/// Echo of the birth moment the chart was computed from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBaziChartResponseBirthData {
    /// Birth date in YYYY-MM-DD format. Sets the year, month and day pillars. The year pillar turns at Beginning of Spring rather than on 1 January, and the month pillar turns at each of the twelve minor solar terms rather than at a calendar month boundary.
    pub date: String,
    /// Birth latitude in decimal degrees. Accepted for consistency with the other birth-data endpoints and does not affect any part of a BaZi chart. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Positive is East, negative is West. Required when hourClock is "local-mean" or "solar", which shift the hour branch to the sun over the birth place; omitting it in either case returns 400. Ignored when hourClock is "clock".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Birth time in 24-hour HH:MM:SS format. Sets the hour pillar, which is one of the four and carries the whole picture of later life and offspring. Each Earthly Branch covers two hours, so a birth within a few minutes of an odd hour can land in either. All four pillars are read in the local clock of the birth, and the day boundary is applied in that same clock; only the lunisolar calendar date itself is a world constant, fixed at UTC plus 8 so one instant has one Chinese date everywhere.
    pub time: String,
    /// Decimal UTC offset the chart was computed with, resolved from whatever the request sent. An IANA name is resolved to the offset in force at the birth, so this is the literal number applied and never the name. A local time that never happened (the skipped hour of a daylight-saving change) is moved forward past the gap, and date, time and timezone then echo the clock that was running, which the day and hour pillars are read from.
    pub timezone: f64,
}
/// Request body of `generateBaziChart`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateBaziChartRequest {
    /// Birth date in YYYY-MM-DD format. Sets the year, month and day pillars. The year pillar turns at Beginning of Spring rather than on 1 January, and the month pillar turns at each of the twelve minor solar terms rather than at a calendar month boundary.
    pub date: String,
    /// Which instant starts the sexagenary DAY, which only matters for a birth between 23:00 and 23:59. "midnight" is the classical position of the Ming compendium San Ming Tong Hui: the day turns at 00:00 and 23:00 to 23:59 is the late zi hour of the day that is ending, so the hour stem is taken from that day. "early-zi" turns the whole day at 23:00, the practice in Hong Kong, Taiwan and much of South East Asia. "split-zi" is the compromise most software implements and the default here: the day still turns at 00:00, but the hour stem is taken from the next day. The three give three different answers for a late-evening birth and identical answers for every other birth.
    #[serde(rename = "dayBoundary", skip_serializing_if = "Option::is_none")]
    pub day_boundary: Option<GenerateBaziChartRequestDayBoundary>,
    /// Which clock the day boundary and the hour branch are read from, so a correction that carries a birth across midnight moves the day pillar with the hour. "clock" is civil time exactly as a birth certificate records it, which is what most calculators use and the default here. "local-mean" shifts to the mean sun over the birth longitude, a correction of up to 59 minutes at the edge of a wide time zone. "solar" adds the equation of time on top of that, up to a further 16 minutes. Both non-civil options need "longitude" in the request and return 400 without it.
    #[serde(rename = "hourClock", skip_serializing_if = "Option::is_none")]
    pub hour_clock: Option<GenerateBaziChartRequestHourClock>,
    /// Birth latitude in decimal degrees. Accepted for consistency with the other birth-data endpoints and does not affect any part of a BaZi chart. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Positive is East, negative is West. Required when hourClock is "local-mean" or "solar", which shift the hour branch to the sun over the birth place; omitting it in either case returns 400. Ignored when hourClock is "clock".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Birth time in 24-hour HH:MM:SS format. Sets the hour pillar, which is one of the four and carries the whole picture of later life and offspring. Each Earthly Branch covers two hours, so a birth within a few minutes of an odd hour can land in either. All four pillars are read in the local clock of the birth, and the day boundary is applied in that same clock; only the lunisolar calendar date itself is a world constant, fixed at UTC plus 8 so one instant has one Chinese date everywhere.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: GenerateBaziChartRequestTimezone,
    /// Which instant starts the sexagenary YEAR. "li-chun" is Beginning of Spring, around 4 February, and is the classical rule every BaZi text uses, so it is the default on this endpoint. "lunar-new-year" is the folk rule people mean when they say which animal they are, and it falls between late January and late February. The two disagree for any birth in the weeks between them: 14 February 2026 is a Wood Snake year under lunar-new-year and a Fire Horse year under li-chun.
    #[serde(rename = "yearBoundary", skip_serializing_if = "Option::is_none")]
    pub year_boundary: Option<GenerateBaziChartRequestYearBoundary>,
}
string_enum! {
    /// Which instant starts the sexagenary YEAR. "li-chun" is Beginning of Spring, around 4 February, and is the classical rule every BaZi text uses, so it is the default on this endpoint. "lunar-new-year" is the folk rule people mean when they say which animal they are, and it falls between late January and late February. The two disagree for any birth in the weeks between them: 14 February 2026 is a Wood Snake year under lunar-new-year and a Fire Horse year under li-chun.
    GenerateBaziChartRequestYearBoundary {
        LiChun = "li-chun",
        LunarNewYear = "lunar-new-year",
    }
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GenerateBaziChartRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Which clock the day boundary and the hour branch are read from, so a correction that carries a birth across midnight moves the day pillar with the hour. "clock" is civil time exactly as a birth certificate records it, which is what most calculators use and the default here. "local-mean" shifts to the mean sun over the birth longitude, a correction of up to 59 minutes at the edge of a wide time zone. "solar" adds the equation of time on top of that, up to a further 16 minutes. Both non-civil options need "longitude" in the request and return 400 without it.
    GenerateBaziChartRequestHourClock {
        Clock = "clock",
        LocalMean = "local-mean",
        Solar = "solar",
    }
}
string_enum! {
    /// Which instant starts the sexagenary DAY, which only matters for a birth between 23:00 and 23:59. "midnight" is the classical position of the Ming compendium San Ming Tong Hui: the day turns at 00:00 and 23:00 to 23:59 is the late zi hour of the day that is ending, so the hour stem is taken from that day. "early-zi" turns the whole day at 23:00, the practice in Hong Kong, Taiwan and much of South East Asia. "split-zi" is the compromise most software implements and the default here: the day still turns at 00:00, but the hour stem is taken from the next day. The three give three different answers for a late-evening birth and identical answers for every other birth.
    GenerateBaziChartRequestDayBoundary {
        SplitZi = "split-zi",
        Midnight = "midnight",
        EarlyZi = "early-zi",
    }
}
/// Path and query parameters of `generateBaziChart`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateBaziChartParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateBaziChartParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateBaziChartParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Request body of `generateAstrocartography`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateAstrocartographyRequest {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<GenerateAstrocartographyRequestNodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
    pub timezone: GenerateAstrocartographyRequestTimezone,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum GenerateAstrocartographyRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    GenerateAstrocartographyRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Path and query parameters of `generateAstrocartography`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateAstrocartographyParams {
    /// Optional comma separated list of extra bodies to plot beyond the ten classical planets. Allowed values: north-node, chiron, lilith. north-node is the mean lunar node. Unknown values are ignored. Defaults to none.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub include: Option<String>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateAstrocartographyParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateAstrocartographyParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `generateAsteroids`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GenerateAsteroidsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<GenerateAsteroidsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    GenerateAsteroidsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `forecastTransits`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ForecastTransitsResponse {
    /// Echo of the birth subject this forecast was built for.
    #[serde(rename = "birthData")]
    pub birth_data: ForecastTransitsResponseBirthData,
    /// Number of events in the timeline after deduplication, filtering, and the event cap.
    pub count: f64,
    /// Last day of the resolved forecast window after the horizon clamp.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// The merged, time-ordered forecast events across the requested domains.
    pub events: Vec<ForecastTransitsResponseEventsItem>,
    /// First day of the resolved forecast window.
    #[serde(rename = "startDate")]
    pub start_date: String,
}
/// One entry of `events`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ForecastTransitsResponseEventsItem {
    /// For a transit-aspect, the angular relationship. One of conjunction, sextile, square, trine, opposition. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub aspect: Option<String>,
    /// Primary subject of the event. A transiting planet for western events, Sun for a solar eclipse, Moon for a lunar eclipse or a new or full moon, or the critical cycle for biorhythm days. For a dasha-change, the Vimshottari lords outermost first, joined by a hyphen, then one space and the level: Saturn Mahadasha, Saturn-Mercury Antardasha, Saturn-Mercury-Ketu Pratyantardasha. Lords are always one of Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury. Never localized.
    pub body: String,
    /// Calendar date of the event in YYYY-MM-DD (UTC).
    pub date: String,
    /// Exact instant of the event as an ISO-8601 UTC datetime, to the nearest second. Astronomical events are refined to this instant by search, not reported at a daily sample point; a dasha-change is the period boundary itself, counted from the birth instant.
    pub datetime: String,
    /// Plain-language summary of the event, suitable for direct display. The only localized field: when lang is set this sentence, and the body, target, and aspect names within it, render in the requested language while the structured fields stay English.
    pub description: String,
    /// Forecast domain. western covers transit aspects, sign ingresses, retrograde stations, eclipses, and new and full moons. vedic covers Vimshottari mahadasha, antardasha, and pratyantardasha boundaries. biorhythm covers critical days. A stable machine value, never localized, so consumers can branch on it under any language.
    pub domain: ForecastTransitsResponseEventsItemDomain,
    /// For an eclipse, its classification. total and penumbral apply to lunar eclipses, partial applies to both, annular and total apply to solar eclipses. A stable machine value, never localized. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kind: Option<ForecastTransitsResponseEventsItemKind>,
    /// For a lunar eclipse, the peak fraction from 0 to 1 of the Moon disc covered by Earth umbra. 1 for a total lunar eclipse, between 0 and 1 for a partial, 0 for a penumbral. Absent for solar eclipses and other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub obscuration: Option<f64>,
    /// For a transit-aspect, the separation in degrees from the exact aspect at the reported instant, rounded to three decimals. The instant is the moment the aspect perfects, so this reads 0. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub orb: Option<f64>,
    /// For a lunar-phase event, which syzygy it is: new-moon (Sun-Moon conjunction) or full-moon (Sun-Moon opposition). The intermediate quarters are not emitted. A stable machine value, never localized. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phase: Option<ForecastTransitsResponseEventsItemPhase>,
    /// Importance score from 0 to 100. Outer-planet exact transit aspects and mahadasha changes score highest; fast Moon events and biorhythm critical days score lower. When domainWeights is supplied this is the weighted score, rounded and clamped to 0 to 100, which is the same value the significance floor and the event cap acted on.
    pub significance: f64,
    /// For a retrograde-station, whether the planet turns retrograde or direct. A stable machine value, never localized. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub station: Option<ForecastTransitsResponseEventsItemStation>,
    /// For a transit-aspect, the natal body the transit aspects. For a sign-ingress, the zodiac sign entered, and for a lunar-phase, the zodiac sign of the New or Full Moon. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub target: Option<String>,
    /// Event kind. transit-aspect, sign-ingress, retrograde-station, eclipse, and lunar-phase are western, dasha-change is vedic Vimshottari, critical-day is biorhythm. A stable machine value, never localized, so consumers can branch on it under any language.
    pub r#type: ForecastTransitsResponseEventsItemType,
}
string_enum! {
    /// Event kind. transit-aspect, sign-ingress, retrograde-station, eclipse, and lunar-phase are western, dasha-change is vedic Vimshottari, critical-day is biorhythm. A stable machine value, never localized, so consumers can branch on it under any language.
    ForecastTransitsResponseEventsItemType {
        TransitAspect = "transit-aspect",
        SignIngress = "sign-ingress",
        RetrogradeStation = "retrograde-station",
        Eclipse = "eclipse",
        LunarPhase = "lunar-phase",
        DashaChange = "dasha-change",
        CriticalDay = "critical-day",
    }
}
string_enum! {
    /// For a retrograde-station, whether the planet turns retrograde or direct. A stable machine value, never localized. Absent for other event types.
    ForecastTransitsResponseEventsItemStation {
        Retrograde = "retrograde",
        Direct = "direct",
    }
}
string_enum! {
    /// For a lunar-phase event, which syzygy it is: new-moon (Sun-Moon conjunction) or full-moon (Sun-Moon opposition). The intermediate quarters are not emitted. A stable machine value, never localized. Absent for other event types.
    ForecastTransitsResponseEventsItemPhase {
        NewMoon = "new-moon",
        FullMoon = "full-moon",
    }
}
string_enum! {
    /// For an eclipse, its classification. total and penumbral apply to lunar eclipses, partial applies to both, annular and total apply to solar eclipses. A stable machine value, never localized. Absent for other event types.
    ForecastTransitsResponseEventsItemKind {
        Penumbral = "penumbral",
        Partial = "partial",
        Annular = "annular",
        Total = "total",
    }
}
string_enum! {
    /// Forecast domain. western covers transit aspects, sign ingresses, retrograde stations, eclipses, and new and full moons. vedic covers Vimshottari mahadasha, antardasha, and pratyantardasha boundaries. biorhythm covers critical days. A stable machine value, never localized, so consumers can branch on it under any language.
    ForecastTransitsResponseEventsItemDomain {
        Western = "western",
        Vedic = "vedic",
        Biorhythm = "biorhythm",
    }
}
/// Echo of the birth subject this forecast was built for.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ForecastTransitsResponseBirthData {
    /// Birth date in YYYY-MM-DD format. Anchors the natal chart and the Vimshottari dasha sequence.
    pub date: String,
    /// Birth latitude in decimal degrees. Optional and does not affect the timeline. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Optional and does not affect the timeline. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Birth time in 24-hour HH:MM:SS format. Precision matters for the natal positions the transit aspects are measured against.
    pub time: String,
    /// Decimal UTC offset the forecast was computed with, resolved from whatever the request sent. An IANA name is resolved to the offset in force at the birth date and time, so this is the literal number applied, never the name.
    pub timezone: f64,
}
/// Request body of `forecastTransits`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ForecastTransitsRequest {
    /// The single birth subject this transit forecast is built for. One object only, never an array.
    #[serde(rename = "birthData")]
    pub birth_data: ForecastTransitsRequestBirthData,
    /// Last day of the transit window in YYYY-MM-DD format. Defaults to startDate plus 30 days. Clamped to a maximum of 90 days from startDate.
    #[serde(rename = "endDate", skip_serializing_if = "Option::is_none")]
    pub end_date: Option<String>,
    /// Drop transit events scoring below this significance threshold from 0 to 100. Defaults to 0.
    #[serde(rename = "minSignificance", skip_serializing_if = "Option::is_none")]
    pub min_significance: Option<f64>,
    /// First day of the transit window in YYYY-MM-DD format. Defaults to today in UTC.
    #[serde(rename = "startDate", skip_serializing_if = "Option::is_none")]
    pub start_date: Option<String>,
}
/// The single birth subject this transit forecast is built for. One object only, never an array.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ForecastTransitsRequestBirthData {
    /// Birth date in YYYY-MM-DD format. Anchors the natal chart and the Vimshottari dasha sequence.
    pub date: String,
    /// Birth latitude in decimal degrees. Optional and does not affect the timeline. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Optional and does not affect the timeline. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Birth time in 24-hour HH:MM:SS format. Precision matters for the natal positions the transit aspects are measured against.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: ForecastTransitsRequestBirthDataTimezone,
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum ForecastTransitsRequestBirthDataTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
/// Path and query parameters of `forecastTransits`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ForecastTransitsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ForecastTransitsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ForecastTransitsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `forecastSolarReturn`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ForecastSolarReturnResponse {
    /// Echo of the birth date used to find the natal Sun longitude.
    #[serde(rename = "birthDate")]
    pub birth_date: String,
    /// Full chart erected for the solar return moment: all bodies with house placements, the 12 house cusps, aspects, Part of Fortune, and Vertex in the tropical zodiac.
    pub chart: ForecastSolarReturnResponseChart,
    /// Location the return chart was cast for. The Ascendant and house cusps change with this location, the basis of the relocated solar return technique.
    pub location: ForecastSolarReturnResponseLocation,
    /// The natal Sun position whose annual return defines this chart.
    #[serde(rename = "natalSunPosition")]
    pub natal_sun_position: ForecastSolarReturnResponseNatalSunPosition,
    /// Exact solar return moment, when the transiting Sun returns to the natal Sun longitude, formatted in the requested timezone. The astrological birthday for the year.
    #[serde(rename = "solarReturnDate")]
    pub solar_return_date: String,
    /// Year of this solar return. The chart covers the period to the next birthday.
    #[serde(rename = "solarReturnYear")]
    pub solar_return_year: f64,
}
/// The natal Sun position whose annual return defines this chart.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ForecastSolarReturnResponseNatalSunPosition {
    /// Degree within the sign from 0 to 29.999 that the Sun returns to.
    pub degree: f64,
    /// Natal Sun ecliptic longitude in degrees from 0 to 360 that the Sun returns to.
    pub longitude: f64,
    /// Tropical zodiac sign of the natal Sun.
    pub sign: String,
}
/// Location the return chart was cast for. The Ascendant and house cusps change with this location, the basis of the relocated solar return technique.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ForecastSolarReturnResponseLocation {
    /// Latitude used for the return chart house cusps and Ascendant.
    pub latitude: f64,
    /// Longitude used for local sidereal time and the Midheaven.
    pub longitude: f64,
    /// Decimal timezone offset applied to the output datetime.
    pub timezone: f64,
}
/// Full chart erected for the solar return moment: all bodies with house placements, the 12 house cusps, aspects, Part of Fortune, and Vertex in the tropical zodiac.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ForecastSolarReturnResponseChart {
    /// All planetary aspects found in this chart with orbs, strength, and applying/separating status.
    pub aspects: Vec<ForecastSolarReturnResponseChartAspectsItem>,
    /// Birth details used to generate this chart.
    #[serde(rename = "birthDetails")]
    pub birth_details: ForecastSolarReturnResponseChartBirthDetails,
    /// House system used for this chart (placidus, whole-sign, equal, or koch).
    #[serde(rename = "houseSystem")]
    pub house_system: ForecastSolarReturnResponseChartHouseSystem,
    /// All 12 house cusps calculated using the selected house system.
    pub houses: Vec<ForecastSolarReturnResponseChartHousesItem>,
    /// Part of Fortune (Lot of Fortune). A point derived from the Ascendant and the two luminaries that marks an area of ease, vitality, and material wellbeing in the chart.
    #[serde(rename = "partOfFortune")]
    pub part_of_fortune: ForecastSolarReturnResponseChartPartOfFortune,
    /// All 14 celestial bodies in the tropical zodiac with house placements: the 10 classical planets (Sun through Pluto), the lunar nodes (North Node, South Node, in the requested `nodeType` convention), Chiron, and Black Moon Lilith. Chiron is included for charts from 1600 to 2500 and omitted outside that range.
    pub planets: Vec<ForecastSolarReturnResponseChartPlanetsItem>,
    /// Vertex. The western intersection of the prime vertical with the ecliptic, often read as a point of fated encounters and turning-point relationships. The opposite point is the Anti-Vertex.
    pub vertex: ForecastSolarReturnResponseChartVertex,
}
/// Vertex. The western intersection of the prime vertical with the ecliptic, often read as a point of fated encounters and turning-point relationships. The opposite point is the Anti-Vertex.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ForecastSolarReturnResponseChartVertex {
    /// Degree within the Vertex sign (0-29.999).
    pub degree: f64,
    /// House containing this point, resolved against the same cusps as `planets[].house` and using the requested house system. Read this field rather than inferring a house from the sign: the two disagree whenever a house spans more than one sign, which is most of the time outside Whole Sign.
    pub house: i64,
    /// Absolute ecliptic longitude of the Vertex (0-360).
    pub longitude: f64,
    /// Zodiac sign holding the Vertex.
    pub sign: String,
}
/// One entry of `planets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ForecastSolarReturnResponseChartPlanetsItem {
    /// Degree within the zodiac sign (0-29.999). Indicates how far the planet has progressed through the sign.
    pub degree: f64,
    /// House placement (1-12). Determined by the selected house system and birth location.
    pub house: i64,
    /// Whether the planet appears to move backward from Earth perspective. Retrograde periods signal review and introspection.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Apparent geocentric ecliptic latitude of date, in degrees. Near zero for most planets, varies for the Moon and Pluto, and reaches up to about 5 degrees for Black Moon Lilith (projected from the inclined mean lunar orbit).
    pub latitude: f64,
    /// Apparent geocentric tropical longitude on the true ecliptic of date, in degrees (0-360): light time and aberration applied, nutation included, the convention desktop chart software and the NASA JPL Horizons observer tables print, so it compares directly with either. Primary coordinate for zodiac sign and aspect calculations.
    pub longitude: f64,
    /// Body name. One of the 10 classical planets (Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto), the lunar nodes (North Node, South Node), Chiron, or Black Moon Lilith (the mean lunar apogee). The lunar nodes follow the request nodeType, which defaults to the true (osculating) node; pass "mean" for the smoothed node. The two differ by up to about 1.8 degrees and no other body is affected.
    pub name: ForecastSolarReturnResponseChartPlanetsItemName,
    /// Tropical zodiac sign this planet occupies. Determined by 30-degree divisions of ecliptic longitude.
    pub sign: String,
    /// Daily motion in degrees per day. Negative values indicate retrograde motion.
    pub speed: f64,
}
string_enum! {
    /// Body name. One of the 10 classical planets (Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto), the lunar nodes (North Node, South Node), Chiron, or Black Moon Lilith (the mean lunar apogee). The lunar nodes follow the request nodeType, which defaults to the true (osculating) node; pass "mean" for the smoothed node. The two differ by up to about 1.8 degrees and no other body is affected.
    ForecastSolarReturnResponseChartPlanetsItemName {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
/// Part of Fortune (Lot of Fortune). A point derived from the Ascendant and the two luminaries that marks an area of ease, vitality, and material wellbeing in the chart.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ForecastSolarReturnResponseChartPartOfFortune {
    /// Degree within the Part of Fortune sign (0-29.999).
    pub degree: f64,
    /// House containing this point, resolved against the same cusps as `planets[].house` and using the requested house system. Read this field rather than inferring a house from the sign: the two disagree whenever a house spans more than one sign, which is most of the time outside Whole Sign.
    pub house: i64,
    /// Absolute ecliptic longitude of the Part of Fortune (0-360).
    pub longitude: f64,
    /// Chart sect used for the calculation. Day (diurnal) when the Sun is above the horizon, night (nocturnal) when below. Day charts use Ascendant plus Moon minus Sun, night charts use Ascendant plus Sun minus Moon.
    pub sect: ForecastSolarReturnResponseChartPartOfFortuneSect,
    /// Zodiac sign holding the Part of Fortune.
    pub sign: String,
}
string_enum! {
    /// Chart sect used for the calculation. Day (diurnal) when the Sun is above the horizon, night (nocturnal) when below. Day charts use Ascendant plus Moon minus Sun, night charts use Ascendant plus Sun minus Moon.
    ForecastSolarReturnResponseChartPartOfFortuneSect {
        Day = "day",
        Night = "night",
    }
}
/// One entry of `houses`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ForecastSolarReturnResponseChartHousesItem {
    /// Degree within the zodiac sign on this cusp (0-29.999).
    pub degree: f64,
    /// Ecliptic longitude of this house cusp in degrees (0-360).
    pub longitude: f64,
    /// House number (1-12). Each house governs specific life themes in Western astrology.
    pub number: i64,
    /// Zodiac sign on this house cusp. Colors the themes of this life area.
    pub sign: String,
}
string_enum! {
    /// House system used for this chart (placidus, whole-sign, equal, or koch).
    ForecastSolarReturnResponseChartHouseSystem {
        Placidus = "placidus",
        WholeSign = "whole-sign",
        Equal = "equal",
        Koch = "koch",
    }
}
/// Birth details used to generate this chart.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ForecastSolarReturnResponseChartBirthDetails {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone offset from UTC in decimal hours, resolved for the birth date. Examples: New York = -5 in winter and -4 in summer, London = 0, India = 5.5, Tokyo = 9.
    pub timezone: f64,
}
/// One entry of `aspects`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ForecastSolarReturnResponseChartAspectsItem {
    /// Exact angular separation that defines this aspect type in degrees.
    pub angle: f64,
    /// Aspect nature. Harmonious (trine, sextile) flows easily. Challenging (square, opposition) creates tension and growth. Neutral (conjunction) blends energies. Always English, whatever the lang parameter says: it is an identifier consumers switch and style on. Use interpretationLocalized for anything a reader sees.
    pub interpretation: ForecastSolarReturnResponseChartAspectsItemInterpretation,
    /// Whether the aspect is applying (planets moving toward exact) or separating (moving apart). Applying aspects grow stronger.
    #[serde(rename = "isApplying")]
    pub is_applying: bool,
    /// Deviation from exact aspect in degrees. Tighter orb means stronger influence.
    pub orb: f64,
    /// First planet in the aspect pair.
    pub planet1: ForecastSolarReturnResponseChartAspectsItemPlanet1,
    /// Second planet in the aspect pair.
    pub planet2: ForecastSolarReturnResponseChartAspectsItemPlanet2,
    /// Aspect strength percentage (0-100). Based on orb tightness relative to the allowed maximum.
    pub strength: f64,
    /// Aspect type. Major: conjunction (0), opposition (180), trine (120), square (90), sextile (60). Minor: semi-sextile, quincunx, semi-square, sesquiquadrate.
    pub r#type: ForecastSolarReturnResponseChartAspectsItemType,
}
string_enum! {
    /// Aspect type. Major: conjunction (0), opposition (180), trine (120), square (90), sextile (60). Minor: semi-sextile, quincunx, semi-square, sesquiquadrate.
    ForecastSolarReturnResponseChartAspectsItemType {
        Conjunction = "CONJUNCTION",
        Opposition = "OPPOSITION",
        Trine = "TRINE",
        Square = "SQUARE",
        Sextile = "SEXTILE",
        SemiSextile = "SEMI_SEXTILE",
        Quincunx = "QUINCUNX",
        SemiSquare = "SEMI_SQUARE",
        Sesquiquadrate = "SESQUIQUADRATE",
    }
}
string_enum! {
    /// Second planet in the aspect pair.
    ForecastSolarReturnResponseChartAspectsItemPlanet2 {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
string_enum! {
    /// First planet in the aspect pair.
    ForecastSolarReturnResponseChartAspectsItemPlanet1 {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
string_enum! {
    /// Aspect nature. Harmonious (trine, sextile) flows easily. Challenging (square, opposition) creates tension and growth. Neutral (conjunction) blends energies. Always English, whatever the lang parameter says: it is an identifier consumers switch and style on. Use interpretationLocalized for anything a reader sees.
    ForecastSolarReturnResponseChartAspectsItemInterpretation {
        Harmonious = "harmonious",
        Challenging = "challenging",
        Neutral = "neutral",
    }
}
/// Request body of `forecastSolarReturn`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ForecastSolarReturnRequest {
    /// Birth date in YYYY-MM-DD format. Anchors the natal Sun longitude the transiting Sun returns to each year.
    pub date: String,
    /// House system for the return chart. placidus is the Western default. whole-sign, equal, and koch are also supported.
    #[serde(rename = "houseSystem", skip_serializing_if = "Option::is_none")]
    pub house_system: Option<ForecastSolarReturnRequestHouseSystem>,
    /// Latitude of the solar return location in decimal degrees. The solar return is location-sensitive: use the birthplace to anchor the chart to natal geography, or the current city for a relocated solar return.
    pub latitude: f64,
    /// Longitude of the solar return location in decimal degrees. Sets the local sidereal time, so it drives the Ascendant, Midheaven, and house cusps of the return chart.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Pins the exact natal Sun position that defines the solar return moment.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: ForecastSolarReturnRequestTimezone,
    /// Year to cast the solar return for. The chart is erected for the moment in this year when the transiting Sun returns to the natal Sun longitude, on or within a day of the birthday.
    pub year: i64,
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum ForecastSolarReturnRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// House system for the return chart. placidus is the Western default. whole-sign, equal, and koch are also supported.
    ForecastSolarReturnRequestHouseSystem {
        Placidus = "placidus",
        WholeSign = "whole-sign",
        Equal = "equal",
        Koch = "koch",
    }
}
/// Path and query parameters of `forecastSolarReturn`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ForecastSolarReturnParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ForecastSolarReturnParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ForecastSolarReturnParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `generateFixedStars`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FixedStarsResponse {
    /// Echo of the birth moment and place used to precess every star.
    #[serde(rename = "birthDetails")]
    pub birth_details: FixedStarsResponseBirthDetails,
    /// Flat list of every star to natal point conjunction, sorted tightest first, each with an interpretation. The high-value summary of where fixed stars touch the chart.
    pub conjunctions: Vec<FixedStarsResponseConjunctionsItem>,
    /// Conjunction orb in degrees applied to detect contacts between stars and natal points.
    pub orb: f64,
    /// Every catalog star with its precessed tropical position, magnitude, traditional nature, and any conjunctions to the natal chart.
    pub stars: Vec<FixedStarsResponseStarsItem>,
    /// Short overview of the fixed-star report for previews and report intros.
    pub summary: String,
}
/// One entry of `stars`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FixedStarsResponseStarsItem {
    /// Natal points within the chosen orb of this star. Empty when no planet or angle contacts the star.
    pub conjunctions: Vec<FixedStarsResponseStarsItemConjunctionsItem>,
    /// Degree within the zodiac sign (0-29.999).
    pub degree: f64,
    /// Lowercase identifier for the fixed star.
    pub id: String,
    /// Traditional astrological keywords associated with the star.
    pub keywords: Vec<String>,
    /// Tropical ecliptic longitude of the star in degrees (0-360), precessed from its J2000 position to the chart date.
    pub longitude: f64,
    /// Apparent visual magnitude. Lower is brighter, and the brightest stars are negative.
    pub magnitude: f64,
    /// Proper name of the fixed star.
    pub name: String,
    /// Traditional planetary nature of the star in classical astrology.
    pub nature: String,
    /// Tropical zodiac sign the star currently occupies.
    pub sign: String,
}
/// One entry of `conjunctions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FixedStarsResponseStarsItemConjunctionsItem {
    /// Angular separation in degrees between the star and the natal point. Smaller means a tighter, stronger contact.
    pub orb: f64,
    /// Natal point conjunct this star: a planet name, or the chart angles MC and ASC. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use pointLocalized for anything a reader sees.
    pub point: String,
    /// Natal point name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "pointLocalized", skip_serializing_if = "Option::is_none")]
    pub point_localized: Option<String>,
    /// Tropical ecliptic longitude of the natal point in degrees (0-360).
    #[serde(rename = "pointLongitude")]
    pub point_longitude: f64,
}
/// One entry of `conjunctions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FixedStarsResponseConjunctionsItem {
    /// Plain language meaning of this star contact, blending the star traditional nature with the chart point. Localized to the requested language.
    pub interpretation: String,
    /// Angular separation in degrees between the star and the natal point.
    pub orb: f64,
    /// Natal point conjunct the star: a planet name, or the chart angles MC and ASC. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use pointLocalized for anything a reader sees.
    pub point: String,
    /// Natal point name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "pointLocalized", skip_serializing_if = "Option::is_none")]
    pub point_localized: Option<String>,
    /// Proper name of the conjunct fixed star.
    pub star: String,
}
/// Echo of the birth moment and place used to precess every star.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FixedStarsResponseBirthDetails {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone offset from UTC in decimal hours, resolved for the birth date. Examples: New York = -5 in winter and -4 in summer, London = 0, India = 5.5, Tokyo = 9.
    pub timezone: f64,
}
/// Response body of `findSignificantDates`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FindSignificantDatesResponse {
    /// Echo of the birth subject this forecast was built for.
    #[serde(rename = "birthData")]
    pub birth_data: FindSignificantDatesResponseBirthData,
    /// Number of events in the timeline after deduplication, filtering, and the event cap.
    pub count: f64,
    /// Last day of the resolved forecast window after the horizon clamp.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// The merged, time-ordered forecast events across the requested domains.
    pub events: Vec<FindSignificantDatesResponseEventsItem>,
    /// First day of the resolved forecast window.
    #[serde(rename = "startDate")]
    pub start_date: String,
}
/// One entry of `events`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FindSignificantDatesResponseEventsItem {
    /// For a transit-aspect, the angular relationship. One of conjunction, sextile, square, trine, opposition. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub aspect: Option<String>,
    /// Primary subject of the event. A transiting planet for western events, Sun for a solar eclipse, Moon for a lunar eclipse or a new or full moon, or the critical cycle for biorhythm days. For a dasha-change, the Vimshottari lords outermost first, joined by a hyphen, then one space and the level: Saturn Mahadasha, Saturn-Mercury Antardasha, Saturn-Mercury-Ketu Pratyantardasha. Lords are always one of Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury. Never localized.
    pub body: String,
    /// Calendar date of the event in YYYY-MM-DD (UTC).
    pub date: String,
    /// Exact instant of the event as an ISO-8601 UTC datetime, to the nearest second. Astronomical events are refined to this instant by search, not reported at a daily sample point; a dasha-change is the period boundary itself, counted from the birth instant.
    pub datetime: String,
    /// Plain-language summary of the event, suitable for direct display. The only localized field: when lang is set this sentence, and the body, target, and aspect names within it, render in the requested language while the structured fields stay English.
    pub description: String,
    /// Forecast domain. western covers transit aspects, sign ingresses, retrograde stations, eclipses, and new and full moons. vedic covers Vimshottari mahadasha, antardasha, and pratyantardasha boundaries. biorhythm covers critical days. A stable machine value, never localized, so consumers can branch on it under any language.
    pub domain: FindSignificantDatesResponseEventsItemDomain,
    /// For an eclipse, its classification. total and penumbral apply to lunar eclipses, partial applies to both, annular and total apply to solar eclipses. A stable machine value, never localized. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub kind: Option<FindSignificantDatesResponseEventsItemKind>,
    /// For a lunar eclipse, the peak fraction from 0 to 1 of the Moon disc covered by Earth umbra. 1 for a total lunar eclipse, between 0 and 1 for a partial, 0 for a penumbral. Absent for solar eclipses and other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub obscuration: Option<f64>,
    /// For a transit-aspect, the separation in degrees from the exact aspect at the reported instant, rounded to three decimals. The instant is the moment the aspect perfects, so this reads 0. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub orb: Option<f64>,
    /// For a lunar-phase event, which syzygy it is: new-moon (Sun-Moon conjunction) or full-moon (Sun-Moon opposition). The intermediate quarters are not emitted. A stable machine value, never localized. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phase: Option<FindSignificantDatesResponseEventsItemPhase>,
    /// Importance score from 0 to 100. Outer-planet exact transit aspects and mahadasha changes score highest; fast Moon events and biorhythm critical days score lower. When domainWeights is supplied this is the weighted score, rounded and clamped to 0 to 100, which is the same value the significance floor and the event cap acted on.
    pub significance: f64,
    /// For a retrograde-station, whether the planet turns retrograde or direct. A stable machine value, never localized. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub station: Option<FindSignificantDatesResponseEventsItemStation>,
    /// For a transit-aspect, the natal body the transit aspects. For a sign-ingress, the zodiac sign entered, and for a lunar-phase, the zodiac sign of the New or Full Moon. Absent for other event types.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub target: Option<String>,
    /// Event kind. transit-aspect, sign-ingress, retrograde-station, eclipse, and lunar-phase are western, dasha-change is vedic Vimshottari, critical-day is biorhythm. A stable machine value, never localized, so consumers can branch on it under any language.
    pub r#type: FindSignificantDatesResponseEventsItemType,
}
string_enum! {
    /// Event kind. transit-aspect, sign-ingress, retrograde-station, eclipse, and lunar-phase are western, dasha-change is vedic Vimshottari, critical-day is biorhythm. A stable machine value, never localized, so consumers can branch on it under any language.
    FindSignificantDatesResponseEventsItemType {
        TransitAspect = "transit-aspect",
        SignIngress = "sign-ingress",
        RetrogradeStation = "retrograde-station",
        Eclipse = "eclipse",
        LunarPhase = "lunar-phase",
        DashaChange = "dasha-change",
        CriticalDay = "critical-day",
    }
}
string_enum! {
    /// For a retrograde-station, whether the planet turns retrograde or direct. A stable machine value, never localized. Absent for other event types.
    FindSignificantDatesResponseEventsItemStation {
        Retrograde = "retrograde",
        Direct = "direct",
    }
}
string_enum! {
    /// For a lunar-phase event, which syzygy it is: new-moon (Sun-Moon conjunction) or full-moon (Sun-Moon opposition). The intermediate quarters are not emitted. A stable machine value, never localized. Absent for other event types.
    FindSignificantDatesResponseEventsItemPhase {
        NewMoon = "new-moon",
        FullMoon = "full-moon",
    }
}
string_enum! {
    /// For an eclipse, its classification. total and penumbral apply to lunar eclipses, partial applies to both, annular and total apply to solar eclipses. A stable machine value, never localized. Absent for other event types.
    FindSignificantDatesResponseEventsItemKind {
        Penumbral = "penumbral",
        Partial = "partial",
        Annular = "annular",
        Total = "total",
    }
}
string_enum! {
    /// Forecast domain. western covers transit aspects, sign ingresses, retrograde stations, eclipses, and new and full moons. vedic covers Vimshottari mahadasha, antardasha, and pratyantardasha boundaries. biorhythm covers critical days. A stable machine value, never localized, so consumers can branch on it under any language.
    FindSignificantDatesResponseEventsItemDomain {
        Western = "western",
        Vedic = "vedic",
        Biorhythm = "biorhythm",
    }
}
/// Echo of the birth subject this forecast was built for.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FindSignificantDatesResponseBirthData {
    /// Birth date in YYYY-MM-DD format. Anchors the natal chart and the Vimshottari dasha sequence.
    pub date: String,
    /// Birth latitude in decimal degrees. Optional and does not affect the timeline. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Optional and does not affect the timeline. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Birth time in 24-hour HH:MM:SS format. Precision matters for the natal positions the transit aspects are measured against.
    pub time: String,
    /// Decimal UTC offset the forecast was computed with, resolved from whatever the request sent. An IANA name is resolved to the offset in force at the birth date and time, so this is the literal number applied, never the name.
    pub timezone: f64,
}
/// Request body of `findSignificantDates`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FindSignificantDatesRequest {
    /// The single birth subject this forecast is built for. One object only, never an array.
    #[serde(rename = "birthData")]
    pub birth_data: FindSignificantDatesRequestBirthData,
    /// Per-domain significance multipliers applied before the significance floor and event cap. Bias which domains survive filtering and the cap. Omitted domains default to a weight of 1. Valid keys are western, vedic, and biorhythm.
    #[serde(rename = "domainWeights", skip_serializing_if = "Option::is_none")]
    pub domain_weights: Option<FindSignificantDatesRequestDomainWeights>,
    /// Which forecast domains to consider before filtering by significance. Defaults to all three.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub domains: Option<Vec<FindSignificantDatesRequestDomainsItem>>,
    /// Last day of the window in YYYY-MM-DD format. Defaults to startDate plus 30 days. Clamped to a maximum of 90 days from startDate.
    #[serde(rename = "endDate", skip_serializing_if = "Option::is_none")]
    pub end_date: Option<String>,
    /// Significance floor from 0 to 100 for what counts as a significant date. Defaults to 70.
    #[serde(rename = "minSignificance", skip_serializing_if = "Option::is_none")]
    pub min_significance: Option<f64>,
    /// First day of the window in YYYY-MM-DD format. Defaults to today in UTC.
    #[serde(rename = "startDate", skip_serializing_if = "Option::is_none")]
    pub start_date: Option<String>,
}
string_enum! {
    /// Forecast domain. western covers transit aspects, sign ingresses, retrograde stations, eclipses, and new and full moons. vedic covers Vimshottari mahadasha, antardasha, and pratyantardasha boundaries. biorhythm covers critical days.
    FindSignificantDatesRequestDomainsItem {
        Western = "western",
        Vedic = "vedic",
        Biorhythm = "biorhythm",
    }
}
/// Per-domain significance multipliers applied before the significance floor and event cap. Bias which domains survive filtering and the cap. Omitted domains default to a weight of 1. Valid keys are western, vedic, and biorhythm.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct FindSignificantDatesRequestDomainWeights {
    /// Multiplier for this domain significance. 1 leaves it unchanged, above 1 promotes the domain, below 1 demotes it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub biorhythm: Option<f64>,
    /// Multiplier for this domain significance. 1 leaves it unchanged, above 1 promotes the domain, below 1 demotes it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vedic: Option<f64>,
    /// Multiplier for this domain significance. 1 leaves it unchanged, above 1 promotes the domain, below 1 demotes it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub western: Option<f64>,
}
/// The single birth subject this forecast is built for. One object only, never an array.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FindSignificantDatesRequestBirthData {
    /// Birth date in YYYY-MM-DD format. Anchors the natal chart and the Vimshottari dasha sequence.
    pub date: String,
    /// Birth latitude in decimal degrees. Optional and does not affect the timeline. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Optional and does not affect the timeline. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Birth time in 24-hour HH:MM:SS format. Precision matters for the natal positions the transit aspects are measured against.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: FindSignificantDatesRequestBirthDataTimezone,
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum FindSignificantDatesRequestBirthDataTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
/// Path and query parameters of `findSignificantDates`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct FindSignificantDatesParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<FindSignificantDatesParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    FindSignificantDatesParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `findGrihaPraveshDates`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FindGrihaPraveshDatesResponse {
    /// The switches this search resolved, echoed so it can be reproduced later.
    pub conventions: FindGrihaPraveshDatesResponseConventions,
    /// The days in the window that clear every day-level rule, in date order. Only admitted days are listed; the rules that rejected the rest are tallied in rejectionsByRule.
    pub days: Vec<FindGrihaPraveshDatesResponseDaysItem>,
    /// The rules a date search cannot settle, published rather than dropped. They are judgements about a MOMENT and about the owner, not about a day, and a caller who believes an admitted day is finished without them would be wrong.
    #[serde(rename = "leftToTheAstrologer")]
    pub left_to_the_astrologer: Vec<String>,
    /// A tally of which rule rejected how many days, keyed on the rule id. This is what makes an empty result actionable: a window inside the southern course fails every day on one rule and you can see that at a glance.
    #[serde(rename = "rejectionsByRule")]
    pub rejections_by_rule: FindGrihaPraveshDatesResponseRejectionsByRule,
    /// Every rule applied, with what it requires, how well attested it is, and where it comes from.
    pub rules: Vec<FindGrihaPraveshDatesResponseRulesItem>,
    /// The primary citations behind the whole search, including the one house entry rule the Brihat Samhita itself states, which is in its muhurta chapter and not in the architecture chapter.
    pub sources: Vec<FindGrihaPraveshDatesResponseSourcesItem>,
    /// How many days were admitted.
    pub total: f64,
    /// What was searched, echoed so a stored result is self describing.
    pub window: FindGrihaPraveshDatesResponseWindow,
}
/// What was searched, echoed so a stored result is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FindGrihaPraveshDatesResponseWindow {
    /// How many days the window covered, inclusive of both ends.
    #[serde(rename = "daysEvaluated")]
    pub days_evaluated: f64,
    /// Last day searched, echoed.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// First day searched, echoed.
    #[serde(rename = "startDate")]
    pub start_date: String,
}
/// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FindGrihaPraveshDatesResponseSourcesItem {
    /// Why a convention rule says what it says. Present only when text is convention, and it names the tradition the rule comes from rather than a verse.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub basis: Option<String>,
    /// Chapter of the primary text. Absent on a convention, which has no chapter to cite.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chapter: Option<f64>,
    /// Whether the cited edition is in the public domain. True on the 1884 Brihat Samhita edition, whose verses are quoted. False on the 1933 Manasara edition behind the Ayadi formulas, from which only the multipliers, divisors and names are taken, never a sentence.
    #[serde(rename = "publicDomain", skip_serializing_if = "Option::is_none")]
    pub public_domain: Option<bool>,
    /// The primary text this verdict rests on, or the literal value convention where no verse states the rule. Always English, safe to compare against.
    pub text: String,
    /// Translator of the edition the verse was read in. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation: Option<String>,
    /// Verse or verse range inside the chapter. Absent on a convention. A range is written with a hyphen, as in 115-117.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub verse: Option<String>,
    /// Publication year of that edition. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<f64>,
}
/// One entry of `rules`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FindGrihaPraveshDatesResponseRulesItem {
    /// How well attested the rule is: high where two independent texts agree, medium where two dependent witnesses do or one text states it twice. Always English.
    pub confidence: String,
    /// Identifier of the rule, which is what the day rows reference.
    pub id: String,
    /// What the rule requires, as original prose. Translated in place when lang is set.
    pub requirement: String,
    /// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
    pub source: FindGrihaPraveshDatesResponseRulesItemSource,
}
/// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FindGrihaPraveshDatesResponseRulesItemSource {
    /// Why a convention rule says what it says. Present only when text is convention, and it names the tradition the rule comes from rather than a verse.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub basis: Option<String>,
    /// Chapter of the primary text. Absent on a convention, which has no chapter to cite.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chapter: Option<f64>,
    /// Whether the cited edition is in the public domain. True on the 1884 Brihat Samhita edition, whose verses are quoted. False on the 1933 Manasara edition behind the Ayadi formulas, from which only the multipliers, divisors and names are taken, never a sentence.
    #[serde(rename = "publicDomain", skip_serializing_if = "Option::is_none")]
    pub public_domain: Option<bool>,
    /// The primary text this verdict rests on, or the literal value convention where no verse states the rule. Always English, safe to compare against.
    pub text: String,
    /// Translator of the edition the verse was read in. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation: Option<String>,
    /// Verse or verse range inside the chapter. Absent on a convention. A range is written with a hyphen, as in 115-117.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub verse: Option<String>,
    /// Publication year of that edition. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<f64>,
}
/// A tally of which rule rejected how many days, keyed on the rule id. This is what makes an empty result actionable: a window inside the southern course fails every day on one rule and you can see that at a glance.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FindGrihaPraveshDatesResponseRejectionsByRule {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, f64>,
}
/// One entry of `days`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FindGrihaPraveshDatesResponseDaysItem {
    /// The rule ids this day satisfied, in the order they were tested. Look each one up in the rules field for what it requires and where it comes from.
    #[serde(rename = "admittedBy")]
    pub admitted_by: Vec<String>,
    /// Which half of the solar year: uttarayana is the northern course and is required, dakshinayana the southern. Always English, safe to compare against.
    pub ayana: String,
    /// The admitted day, in YYYY-MM-DD.
    pub date: String,
    /// The karana at sunrise. Vishti, also called Bhadra, is the one that bars a day. Always English transliteration.
    pub karana: String,
    /// The nakshatra the Moon stood in at sunrise, which is the strongest of the rules.
    pub nakshatra: FindGrihaPraveshDatesResponseDaysItemNakshatra,
    /// preferred where the tithi is one both texts single out and the weekday is not the neutral one, admissible otherwise. Always English, safe to compare against.
    pub quality: String,
    /// The day as a sentence, for a report or a chat answer. Translated in place when lang is set to a language other than English.
    pub reading: String,
    /// Sidereal longitude of the Sun at sunrise, in degrees. Published because two of the rules are solar and a caller can check them from it.
    #[serde(rename = "solarLongitude")]
    pub solar_longitude: f64,
    /// Sunrise at the coordinates you sent, as a UTC instant. This is the moment every limb below was read at. Absent inside a polar night, where the Sun does not rise and the day was read from local midnight instead.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sunrise: Option<String>,
    /// The tithi running at sunrise.
    pub tithi: FindGrihaPraveshDatesResponseDaysItemTithi,
    /// The weekday, which begins at sunrise in this reckoning.
    pub vara: FindGrihaPraveshDatesResponseDaysItemVara,
}
/// The weekday, which begins at sunrise in this reckoning.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FindGrihaPraveshDatesResponseDaysItemVara {
    /// Weekday name, counted from sunrise rather than from midnight.
    pub name: String,
    /// Weekday number, 0 for Sunday through 6 for Saturday.
    pub number: f64,
}
/// The tithi running at sunrise.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FindGrihaPraveshDatesResponseDaysItemTithi {
    /// Display name of the tithi, as the panchang endpoints spell it.
    pub name: String,
    /// Tithi number 1 to 30 across the lunar month, 1 to 15 bright then 16 to 30 dark.
    pub number: f64,
    /// Which half of the lunar month: Shukla for the bright half and Krishna for the dark. Always English, safe to compare against.
    pub paksha: String,
}
/// The nakshatra the Moon stood in at sunrise, which is the strongest of the rules.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FindGrihaPraveshDatesResponseDaysItemNakshatra {
    /// Identifier of the nakshatra, lower case with hyphens. Always English transliteration, safe to compare against and against the same value on the panchang endpoints.
    pub id: String,
    /// Display name of the nakshatra, as the panchang endpoints spell it.
    pub name: String,
    /// Nakshatra number 1 to 27, counting from Ashwini. Abhijit is not among them.
    pub number: f64,
}
/// The switches this search resolved, echoed so it can be reproduced later.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FindGrihaPraveshDatesResponseConventions {
    /// Which Muhurta text supplied the nakshatra list. Echoes the resolved value whether it was sent or defaulted.
    #[serde(rename = "muhurtaText")]
    pub muhurta_text: String,
    /// The UTC offset in hours the local day was resolved with, after any IANA name was resolved to a number.
    pub timezone: f64,
}
/// Request body of `findGrihaPraveshDates`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct FindGrihaPraveshDatesRequest {
    /// Last day of the search window, in YYYY-MM-DD, inclusive. The window is capped at 93 days, which is a full season and the same cap the Vedic auspicious day search carries.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Latitude of the house, in decimal degrees, positive north. Sunrise decides where one day ends and the next begins, so a nakshatra running out during the morning changes which day it counts for.
    pub latitude: f64,
    /// Longitude of the house, in decimal degrees, positive east.
    pub longitude: f64,
    /// Which Muhurta text supplies the admissible nakshatras for entering a new house. muhurta-chintamani admits eight and kalaprakasika admits twelve; seven overlap and are the high confidence core, one is unique to the first and five to the second. The two texts are independent witnesses, which is what makes the overlap strong and the difference worth exposing. Defaults to muhurta-chintamani.
    #[serde(rename = "muhurtaText", skip_serializing_if = "Option::is_none")]
    pub muhurta_text: Option<FindGrihaPraveshDatesRequestMuhurtaText>,
    /// First day of the search window, in YYYY-MM-DD. Every limb is read at sunrise of the local day, because the Hindu day begins at sunrise rather than at midnight.
    #[serde(rename = "startDate")]
    pub start_date: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: FindGrihaPraveshDatesRequestTimezone,
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum FindGrihaPraveshDatesRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Which Muhurta text supplies the admissible nakshatras for entering a new house. muhurta-chintamani admits eight and kalaprakasika admits twelve; seven overlap and are the high confidence core, one is unique to the first and five to the second. The two texts are independent witnesses, which is what makes the overlap strong and the difference worth exposing. Defaults to muhurta-chintamani.
    FindGrihaPraveshDatesRequestMuhurtaText {
        MuhurtaChintamani = "muhurta-chintamani",
        Kalaprakasika = "kalaprakasika",
    }
}
/// Path and query parameters of `findGrihaPraveshDates`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct FindGrihaPraveshDatesParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<FindGrihaPraveshDatesParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    FindGrihaPraveshDatesParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `drawCards`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DrawCardsResponse {
    /// Array of drawn tarot cards in draw order, each with orientation, keywords, and full meaning for divination.
    pub cards: Vec<DrawnCard>,
    /// Seed used for this reading, if one was provided. Same seed reproduces identical draw results for consistent tarot readings.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
}
/// Path and query parameters of `drawCards`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct DrawCardsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<DrawCardsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    DrawCardsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `generateDivisionalChart`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DivisionalChartResponse {
    /// Divisional chart showing planetary positions across 12 rashi houses plus a meta lookup. Same structure as birth chart and navamsa responses.
    pub chart: DivisionalChartResponseChart,
    /// Metadata about the selected divisional chart.
    pub division: DivisionalChartResponseDivision,
    /// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
    pub frame: DivisionalChartResponseFrame,
    /// Planets that are Vargottama (same sign in D1 and this divisional chart). Vargottama planets deliver strong, consistent results.
    pub vargottama: Vec<String>,
}
/// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DivisionalChartResponseFrame {
    /// Sidereal frame this chart was cast in, echoing the ayanamsa request field. "lahiri" when the field was omitted.
    pub ayanamsa: String,
    /// Degrees actually subtracted from every tropical longitude to produce this chart, read at the birth instant. Subtract it back to recover the tropical positions, or compare it against your reference software to confirm you are in the same frame before chasing a placement difference.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
}
/// Metadata about the selected divisional chart.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DivisionalChartResponseDivision {
    /// Size of each division segment within a 30-degree sign.
    #[serde(rename = "degreesPerDivision")]
    pub degrees_per_division: String,
    /// English name of the divisional chart.
    pub name: String,
    /// Division number (e.g. 10 for D10 Dasamsa).
    pub number: i64,
    /// Sanskrit name of the divisional chart.
    #[serde(rename = "sanskritName")]
    pub sanskrit_name: String,
    /// Life areas this divisional chart reveals.
    pub significance: String,
}
/// Divisional chart showing planetary positions across 12 rashi houses plus a meta lookup. Same structure as birth chart and navamsa responses.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DivisionalChartResponseChart {
    /// One of the 12 divisional rashi-house buckets (aries shown; taurus through pisces follow the identical shape). Each lists the planets placed in that sign.
    pub aries: DivisionalChartResponseChartAries,
    /// Planet positions in the divisional chart keyed by planet name. Contains all 9 Navagraha plus Lagna.
    pub meta: DivisionalChartResponseChartMeta,
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}
/// Planet positions in the divisional chart keyed by planet name. Contains all 9 Navagraha plus Lagna.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DivisionalChartResponseChartMeta {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<
        String,
        DivisionalChartResponseChartMetaAdditionalProperty,
    >,
}
/// One graha as the requested varga places it: the divisional rashi and house, with the D1 longitude and nakshatra carried over so a Vargottama check needs no second call.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DivisionalChartResponseChartMetaAdditionalProperty {
    /// Planet (graha) name. One of 9 Navagraha (Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn, Rahu, Ketu) or Lagna (Ascendant). Used to match transits and dasha lords to divisional chart placements.
    pub graha: String,
    /// Bhava (house) number 1-12 in this divisional chart, counted whole-sign from the divisional Lagna. Specific to this varga and differs from the D1 birth-chart house.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub house: Option<i64>,
    /// True if the planet is in retrograde motion (appears to move backward through the zodiac). Retrograde planets carry intensified or internalized significations in Vedic interpretation.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Original sidereal longitude in degrees (0-360) using Lahiri ayanamsa, same as D1 birth chart. Sign placement changes per division but longitude is preserved for cross-chart reference.
    pub longitude: f64,
    /// Nakshatra (lunar mansion) data for this planet. Nakshatras are the 27-fold division of the zodiac central to Vedic timing and compatibility systems.
    pub nakshatra: DivisionalChartResponseChartMetaAdditionalPropertyNakshatra,
    /// Zodiac sign (rashi) the planet occupies in this divisional chart. May differ from the D1 birth chart sign. Comparing D1 and divisional rashi reveals Vargottama status and domain-specific strengths.
    pub rashi: String,
}
/// Nakshatra (lunar mansion) data for this planet. Nakshatras are the 27-fold division of the zodiac central to Vedic timing and compatibility systems.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DivisionalChartResponseChartMetaAdditionalPropertyNakshatra {
    /// Nakshatra sequence number (1-27) in zodiac order starting from Ashwini. Used for Tara Bala compatibility and dasha calculations.
    pub key: f64,
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Carried over from the D1 nakshatra.
    pub lord: DivisionalChartResponseChartMetaAdditionalPropertyNakshatraLord,
    /// Nakshatra (lunar mansion) the planet occupies. One of 27 Vedic nakshatras spanning 13 degrees 20 minutes each. Determines dasha lord and behavioral qualities.
    pub name: String,
    /// Nakshatra pada (quarter, 1-4). Each nakshatra divides into 4 padas of 3 degrees 20 minutes. Pada determines Navamsa sign and refines personality traits.
    pub pada: f64,
}
string_enum! {
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Carried over from the D1 nakshatra.
    DivisionalChartResponseChartMetaAdditionalPropertyNakshatraLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// One of the 12 divisional rashi-house buckets (aries shown; taurus through pisces follow the identical shape). Each lists the planets placed in that sign.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DivisionalChartResponseChartAries {
    /// Zodiac sign name in lowercase. Always equals the key of the divisional rashi-house block it sits in.
    pub rashi: String,
    /// Planets placed in this divisional sign.
    pub signs: Vec<DivisionalChartResponseChartAriesSignsItem>,
}
/// One entry of `signs`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DivisionalChartResponseChartAriesSignsItem {
    /// Planet (graha) placed in this divisional sign.
    pub graha: String,
    /// Bhava (house) number 1-12 in this divisional chart, counted whole-sign from the divisional Lagna.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub house: Option<i64>,
    /// True if the planet is in retrograde motion.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Original sidereal longitude in degrees (0-360), same as the D1 birth chart. Preserved for cross-chart reference.
    pub longitude: f64,
    /// Nakshatra (lunar mansion) data for this planet, carried over from the D1 chart.
    pub nakshatra: DivisionalChartResponseChartAriesSignsItemNakshatra,
}
/// Nakshatra (lunar mansion) data for this planet, carried over from the D1 chart.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DivisionalChartResponseChartAriesSignsItemNakshatra {
    /// Nakshatra index (1-27) in the zodiac sequence starting from Ashwini.
    pub key: f64,
    /// Vimshottari ruling planet of this nakshatra.
    pub lord: DivisionalChartResponseChartAriesSignsItemNakshatraLord,
    /// Nakshatra (lunar mansion) the planet occupies.
    pub name: String,
    /// Nakshatra pada (quarter, 1-4).
    pub pada: f64,
}
string_enum! {
    /// Vimshottari ruling planet of this nakshatra.
    DivisionalChartResponseChartAriesSignsItemNakshatraLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Request body of `generateDivisionalChart`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DivisionalChartRequest {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<DivisionalChartRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Divisional chart number. Each division reveals a specific life area. Supported: 2 (Hora, wealth), 3 (Drekkana, siblings), 4 (Chaturthamsa, property), 7 (Saptamsa, children), 9 (Navamsa, marriage), 10 (Dasamsa, career), 12 (Dwadasamsa, parents), 16 (Shodasamsa, vehicles), 20 (Vimsamsa, spirituality), 24 (Chaturvimsamsa, education), 27 (Bhamsa, strength), 30 (Trimsamsa, misfortunes), 40 (Khavedamsa, merit), 45 (Akshavedamsa, character), 60 (Shashtiamsa, past life karma).
    pub division: i64,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<DivisionalChartRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum DivisionalChartRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    DivisionalChartRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Path and query parameters of `detectYogas`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct DetectYogasParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<DetectYogasParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    DetectYogasParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `detectAspectPatterns`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct DetectAspectPatternsParams {
    /// Comma-separated list of optional bodies to include beyond the classical 10 planets. Valid tokens (case-insensitive): chiron, northNode (also accepts north_node, north-node, northnode). Empty by default.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub include: Option<String>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<DetectAspectPatternsParamsLang>,
    /// Use tighter orbs, so only closely formed patterns are reported. Truthy values (true, 1, yes, on; case-insensitive) narrow trine to 5 degrees, square to 5, sextile to 4, quincunx to 2. Defaults to false, the standard pattern-detection orbs.
    #[serde(rename = "strictOrbs", skip_serializing_if = "Option::is_none")]
    pub strict_orbs: Option<String>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    DetectAspectPatternsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateDashakoot`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DashakootResponse {
    /// The ten poruthams in the order a Tamil panchangam prints them: Dina, Gana, Mahendra, Stree Deergha, Yoni, Rasi, Rasyadhipati, Vasya, Rajju, Vedha. Dina, Mahendra, Stree Deergha, Rasi and Vasya are directional and read from the bride toward the groom.
    pub breakdown: Vec<DashakootResponseBreakdownItem>,
    /// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
    pub frame: DashakootResponseFrame,
    /// Poruthams on the sheet, always 10. The South Indian system counts ten equal agreements where the Ashtakoot system weights eight kootas across 36 points.
    #[serde(rename = "maxTotal")]
    pub max_total: f64,
    /// Rajju veto. The 27 nakshatras divide into five limbs of a body, Paada the foot, Kati the waist, Udara the stomach, Kantha the neck and Siro the head, and a couple whose birth stars share a limb is refused. Published at the top level as well as on its breakdown row because it overrides the total, and a caller must not have to scan the sheet to find it.
    pub rajju: DashakootResponseRajju,
    /// One sentence stating the verdict and why, localized by the lang query parameter. Renders directly; the machine value to branch on is verdict.
    pub recommendation: String,
    /// Poruthams matched, 0 to 10. Each porutham is a pass or a fail in the South Indian system rather than a weighted score, so this is a plain count and never a fraction. A total says nothing on its own while a veto is active, which is why verdict exists.
    pub total: f64,
    /// Vedha veto. Thirteen nakshatra pairs are held to obstruct each other and a couple falling on one is refused. Chitra belongs to no pair and can never trigger this veto.
    pub vedha: DashakootResponseVedha,
    /// Overall reading. "rejected" means Rajju or Vedha fired, which the tradition treats as disqualifying however many poruthams matched, so it can appear on a high total. "recommended" means no veto and the total reached the working threshold. "marginal" means no veto and the total fell short of it. The threshold is a RoxyAPI convention because the tradition names a minimum SET of poruthams rather than a number, and that set varies by desk.
    pub verdict: DashakootResponseVerdict,
}
string_enum! {
    /// Overall reading. "rejected" means Rajju or Vedha fired, which the tradition treats as disqualifying however many poruthams matched, so it can appear on a high total. "recommended" means no veto and the total reached the working threshold. "marginal" means no veto and the total fell short of it. The threshold is a RoxyAPI convention because the tradition names a minimum SET of poruthams rather than a number, and that set varies by desk.
    DashakootResponseVerdict {
        Recommended = "recommended",
        Marginal = "marginal",
        Rejected = "rejected",
    }
}
/// Vedha veto. Thirteen nakshatra pairs are held to obstruct each other and a couple falling on one is refused. Chitra belongs to no pair and can never trigger this veto.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DashakootResponseVedha {
    /// True when the two Moon nakshatras are a mutually obstructing vedha pair, which is the second hard veto. A true here sets verdict to rejected regardless of total.
    pub active: bool,
    /// Why the veto is or is not active, localized by the lang query parameter. The same sentence appears on the Vedha row of breakdown.
    pub reason: String,
}
/// Rajju veto. The 27 nakshatras divide into five limbs of a body, Paada the foot, Kati the waist, Udara the stomach, Kantha the neck and Siro the head, and a couple whose birth stars share a limb is refused. Published at the top level as well as on its breakdown row because it overrides the total, and a caller must not have to scan the sheet to find it.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DashakootResponseRajju {
    /// True when both Moon nakshatras fall on the same Rajju limb, which is the first of the two hard vetoes. A true here sets verdict to rejected regardless of total.
    pub active: bool,
    /// Why the veto is or is not active, localized by the lang query parameter. The same sentence appears on the Rajju row of breakdown, which also carries the limb each person falls on.
    pub reason: String,
}
/// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DashakootResponseFrame {
    /// Sidereal frame this chart was cast in, echoing the ayanamsa request field. "lahiri" when the field was omitted.
    pub ayanamsa: String,
    /// Degrees actually subtracted from every tropical longitude to produce this chart, read at the birth instant. Subtract it back to recover the tropical positions, or compare it against your reference software to confirm you are in the same frame before chasing a placement difference.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
}
/// One entry of `breakdown`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DashakootResponseBreakdownItem {
    /// Always one, since each porutham is a single pass or fail.
    #[serde(rename = "maxPoints")]
    pub max_points: f64,
    /// Which of the ten poruthams this row decides. Canonical English, never translated, so it is safe to switch on. Rasyadhipati is the South Indian name for the agreement the North calls Graha Maitri.
    pub name: DashakootResponseBreakdownItemName,
    /// One sentence explaining what decided this porutham, localized by the lang query parameter. Only counts are written into it; every classification stays on person1 and person2 so a translated sentence never carries an English term.
    pub note: String,
    /// How the GROOM classifies for this porutham: a Rajju limb, a Gana class, a Yoni animal, a Moon rashi, a Moon rashi lord, or the Moon nakshatra where the rule counts stars. Canonical English, so the note never has to name it.
    pub person1: String,
    /// How the BRIDE classifies for this porutham, same vocabulary.
    pub person2: String,
    /// One when this porutham matched and zero when it did not. Every porutham carries equal weight in this system, unlike the Ashtakoot kootas.
    pub points: f64,
    /// The outcome as a word rather than a number, for a caller keying a badge or a filter off it. Canonical English, never translated.
    pub verdict: DashakootResponseBreakdownItemVerdict,
}
string_enum! {
    /// The outcome as a word rather than a number, for a caller keying a badge or a filter off it. Canonical English, never translated.
    DashakootResponseBreakdownItemVerdict {
        Matched = "matched",
        Unmatched = "unmatched",
    }
}
string_enum! {
    /// Which of the ten poruthams this row decides. Canonical English, never translated, so it is safe to switch on. Rasyadhipati is the South Indian name for the agreement the North calls Graha Maitri.
    DashakootResponseBreakdownItemName {
        Dina = "Dina",
        Gana = "Gana",
        Mahendra = "Mahendra",
        StreeDeergha = "Stree Deergha",
        Yoni = "Yoni",
        Rasi = "Rasi",
        Rasyadhipati = "Rasyadhipati",
        Vasya = "Vasya",
        Rajju = "Rajju",
        Vedha = "Vedha",
    }
}
/// Request body of `calculateDashakoot`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DashakootRequest {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<DashakootRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth data of the GROOM. Direction is load bearing in this system: Dina, Mahendra, Stree Deergha, Rasi and Vasya all count from the bride toward the groom, so sending the two people the wrong way round returns a different and wrong sheet without any error.
    pub person1: DashakootRequestPerson1,
    /// Birth data of the BRIDE. Five of the ten poruthams count FROM this birth star, so this field is not interchangeable with person1. Date, time and location determine the Moon nakshatra and Moon rashi every porutham reads.
    pub person2: DashakootRequestPerson2,
}
/// Birth data of the BRIDE. Five of the ten poruthams count FROM this birth star, so this field is not interchangeable with person1. Date, time and location determine the Moon nakshatra and Moon rashi every porutham reads.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DashakootRequestPerson2 {
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<DashakootRequestPerson2Timezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum DashakootRequestPerson2Timezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
/// Birth data of the GROOM. Direction is load bearing in this system: Dina, Mahendra, Stree Deergha, Rasi and Vasya all count from the bride toward the groom, so sending the two people the wrong way round returns a different and wrong sheet without any error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DashakootRequestPerson1 {
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<DashakootRequestPerson1Timezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum DashakootRequestPerson1Timezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    DashakootRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Response body of `convertLongCount`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ConvertLongCountResponse {
    /// The Tzolkin and Haab dates written together, which is how an inscription names a day. The pair repeats every 18,980 days, so it is ambiguous beyond about 52 years and the Long Count is what fixes it.
    #[serde(rename = "calendarRound")]
    pub calendar_round: String,
    /// The conventions this conversion was computed under, echoed so the result is self describing.
    pub conventions: ConvertLongCountResponseConventions,
    /// The proleptic Gregorian date, echoed when it was the input and computed when the Long Count was.
    pub date: String,
    /// The Long Count as one integer count of days from the epoch. Subtracting two of these is the correct way to measure an interval between two Maya dates.
    #[serde(rename = "daysSinceEpoch")]
    pub days_since_epoch: f64,
    /// Julian Day Number of the same day, which is the bridge to any other calendar. It is exactly daysSinceEpoch plus the correlation constant.
    #[serde(rename = "julianDayNumber")]
    pub julian_day_number: f64,
    /// The dotted Long Count, echoed when it was the input and computed when the date was.
    #[serde(rename = "longCount")]
    pub long_count: String,
    /// Which of the nine Lords of the Night governs the day, G1 to G9. The nine carry glyph labels rather than names because no source records what the Maya called them.
    #[serde(rename = "lordOfNight")]
    pub lord_of_night: String,
    /// Present ONLY for a date before the Gregorian reform, where the input convention is the usual reason two converters disagree. Absent otherwise, so its presence is itself the signal.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
}
/// The conventions this conversion was computed under, echoed so the result is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ConvertLongCountResponseConventions {
    /// The correlation constant actually applied, whether it was requested or defaulted. Store this beside any Maya date you persist: the same civil date resolves to a different Long Count under each constant, and a date with no correlation recorded cannot be reproduced.
    pub correlation: String,
}
/// What to convert, and under which correlation. Exactly one of date and longCount is present, which is why the whole body carries one example rather than leaving the per field ones to be read together.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ConvertLongCountRequest {
    /// Which correlation constant ties the day count to a civil date. This is the single choice that shifts every value in the response, so it is a parameter rather than a hidden default, and the resolved value comes back under conventions. "gmt-584283" is the commonly accepted constant and the default, and it is the one the major institutional converter runs on. "martinez-hernandez-584281" sits two days earlier, "astronomical-584285" two days later, and "martin-skidmore-584286" three days later, each shifting the Long Count by exactly its difference in days. Four of the eight published constants are offered: the other four sit tens of thousands of days away and are of historical interest only. The 584281 constant is the Martínez Hernández correlation, after Juan Martínez Hernández.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub correlation: Option<ConvertLongCountRequestCorrelation>,
    /// Proleptic Gregorian date to convert INTO a Long Count. Supply this or longCount, never both and never neither.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Dotted Long Count to convert INTO a date, written baktun.katun.tun.winal.kin. Each position is bounded by its own base, and the winal counts to 17 rather than to 19 because eighteen winal make a tun, so 9.12.11.18.0 is rejected as a date that does not exist. Supply this or date, never both and never neither.
    #[serde(rename = "longCount", skip_serializing_if = "Option::is_none")]
    pub long_count: Option<String>,
}
string_enum! {
    /// Which correlation constant ties the day count to a civil date. This is the single choice that shifts every value in the response, so it is a parameter rather than a hidden default, and the resolved value comes back under conventions. "gmt-584283" is the commonly accepted constant and the default, and it is the one the major institutional converter runs on. "martinez-hernandez-584281" sits two days earlier, "astronomical-584285" two days later, and "martin-skidmore-584286" three days later, each shifting the Long Count by exactly its difference in days. Four of the eight published constants are offered: the other four sit tens of thousands of days away and are of historical interest only. The 584281 constant is the Martínez Hernández correlation, after Juan Martínez Hernández.
    ConvertLongCountRequestCorrelation {
        Gmt584283 = "gmt-584283",
        MartinezHernandez584281 = "martinez-hernandez-584281",
        Astronomical584285 = "astronomical-584285",
        MartinSkidmore584286 = "martin-skidmore-584286",
    }
}
/// Path and query parameters of `convertLongCount`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ConvertLongCountParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<ConvertLongCountParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    ConvertLongCountParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateGunMilan`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CompatibilityResponse {
    /// Detailed breakdown of compatibility scores across all 8 Ashtakoot kootas. Each category evaluates a different aspect of marital compatibility: temperament, physical, mental, financial, and health.
    pub breakdown: Vec<CompatibilityResponseBreakdownItem>,
    /// Doshas detected but cancelled by classical exception rules. Nadi Dosha cancels when partners share the same Moon sign with different nakshatras, same nakshatra with different padas, or same nakshatra spanning different signs. Bhakoot Dosha cancels when Moon sign lords are the same planet or mutual natural friends. Koota score remains 0 but the dosha is not counted against the recommendation.
    #[serde(rename = "doshaCancellations")]
    pub dosha_cancellations: Vec<CompatibilityResponseDoshaCancellationsItem>,
    /// List of active (uncancelled) doshas in the matching. Doshas that meet classical cancellation conditions from Muhurta Martanda or BPHS are excluded from this array and appear in doshaCancellations instead. Common doshas: Nadi Dosha (same Nadi type, 0/8 points), Bhakoot Dosha (inauspicious Moon sign distance, 0/7 points). Empty array when no doshas are present or all detected doshas are cancelled.
    pub doshas: Vec<String>,
    /// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
    pub frame: CompatibilityResponseFrame,
    /// True when percentage &gt;= 50% (18/36 minimum). Based on the traditional Ashtakoot Gun Milan threshold used by Vedic astrologers for kundli matching.
    #[serde(rename = "isCompatible")]
    pub is_compatible: bool,
    /// Maximum possible Guna Milan score (always 36). The 36 points are distributed across 8 kootas (matching categories).
    #[serde(rename = "maxScore")]
    pub max_score: f64,
    /// Compatibility percentage derived from total/maxScore. Above 50% (18/36) is the traditional minimum threshold for marriage compatibility.
    pub percentage: f64,
    /// Human-readable marriage recommendation based on overall score and dosha analysis. Indicates whether the union is recommended, and if not, specifies the reason (e.g. Nadi Dosha, Bhakoot Dosha, low overall score).
    pub recommendation: String,
    /// Total Ashtakoot Gun Milan score out of 36. Scores above 18 are considered compatible for marriage. Higher scores indicate stronger marital harmony.
    pub total: f64,
}
/// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CompatibilityResponseFrame {
    /// Sidereal frame this chart was cast in, echoing the ayanamsa request field. "lahiri" when the field was omitted.
    pub ayanamsa: String,
    /// Degrees actually subtracted from every tropical longitude to produce this chart, read at the birth instant. Subtract it back to recover the tropical positions, or compare it against your reference software to confirm you are in the same frame before chasing a placement difference.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
}
/// One entry of `doshaCancellations`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CompatibilityResponseDoshaCancellationsItem {
    /// Name of the cancelled dosha (Nadi Dosha or Bhakoot Dosha).
    pub dosha: String,
    /// Classical cancellation condition that neutralizes this dosha. Based on Muhurta Martanda for Nadi Dosha and BPHS for Bhakoot Dosha.
    pub reason: String,
}
/// One entry of `breakdown`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CompatibilityResponseBreakdownItem {
    /// One of 8 Ashtakoot matching categories: Varna, Vashya, Tara, Yoni, Graha Maitri, Gana, Bhakoot, Nadi.
    pub category: String,
    /// Human-readable explanation of what this koota category evaluates.
    pub description: String,
    /// Maximum possible points for this koota category.
    #[serde(rename = "maxScore")]
    pub max_score: f64,
    /// Classification of person 1 for this koota (e.g. Vaishya for Varna, Chatushpada for Vashya, Sheep for Yoni).
    pub person1: String,
    /// Classification of person 2 for this koota.
    pub person2: String,
    /// Points scored in this category. Maximum varies: Varna (1), Vashya (2), Tara (3), Yoni (4), Graha Maitri (5), Gana (6), Bhakoot (7), Nadi (8).
    pub score: f64,
}
/// Request body of `calculateGunMilan`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CompatibilityRequest {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<CompatibilityRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth data of the first person (typically the boy/groom in traditional Ashtakoot matching). Date, time, and location determine Moon nakshatra for koota scoring.
    pub person1: CompatibilityRequestPerson1,
    /// Birth data of the second person (typically the girl/bride in traditional Ashtakoot matching). Moon nakshatra compared against person 1 across all 8 kootas.
    pub person2: CompatibilityRequestPerson2,
}
/// Birth data of the second person (typically the girl/bride in traditional Ashtakoot matching). Moon nakshatra compared against person 1 across all 8 kootas.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CompatibilityRequestPerson2 {
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<CompatibilityRequestPerson2Timezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CompatibilityRequestPerson2Timezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
/// Birth data of the first person (typically the boy/groom in traditional Ashtakoot matching). Date, time, and location determine Moon nakshatra for koota scoring.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CompatibilityRequestPerson1 {
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<CompatibilityRequestPerson1Timezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CompatibilityRequestPerson1Timezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    CompatibilityRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Path and query parameters of `checkSadhesati`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CheckSadhesatiParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CheckSadhesatiParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CheckSadhesatiParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `checkManglikDosha`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CheckManglikDoshaParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CheckManglikDoshaParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CheckManglikDoshaParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `checkKarmicDebt`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CheckKarmicDebtResponse {
    /// All karmic debt numbers found (13, 14, 16, 19), each listed once, in core-number order: Life Path, Expression, Soul Urge, Personality, Birth Day.
    #[serde(rename = "debtNumbers")]
    pub debt_numbers: Vec<f64>,
    /// Whether any karmic debt numbers were detected
    #[serde(rename = "hasKarmicDebt")]
    pub has_karmic_debt: bool,
    /// The `meanings` field.
    pub meanings: Vec<CheckKarmicDebtResponseMeaningsItem>,
    /// Human-readable summary. Explains what the karmic debt findings mean or provides a positive affirmation when no debt is found.
    pub message: String,
}
/// One entry of `meanings`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CheckKarmicDebtResponseMeaningsItem {
    /// Detailed explanation of past life issue and current challenges
    pub challenge: String,
    /// Debt title and nature
    pub description: String,
    /// Karmic debt number
    pub number: f64,
    /// Guidance for resolving karmic debt in this lifetime
    pub resolution: String,
}
/// Path and query parameters of `checkKarmicDebt`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CheckKarmicDebtParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CheckKarmicDebtParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CheckKarmicDebtParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `checkKalsarpaDosha`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CheckKalsarpaDoshaParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CheckKalsarpaDoshaParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CheckKalsarpaDoshaParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Chara Karakas for a birth chart: the movable significators of Jaimini astrology, ranked by how far each graha has advanced into its sign.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CharaKarakaResponse {
    /// Graha holding the Atmakaraka office, the most consequential single value in Jaimini analysis. Lifted to the top level so a client reading only the Atmakaraka does not have to search the array.
    pub atmakaraka: String,
    /// Graha holding the Darakaraka office, read for the spouse. The second most requested value, so it is also lifted to the top level.
    pub darakaraka: String,
    /// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
    pub frame: CharaKarakaResponseFrame,
    /// Karaka offices in descending rank, Atmakaraka first. Eight entries in the eight-karaka scheme, seven in the seven-karaka scheme.
    pub karakas: Vec<CharaKarakaResponseKarakasItem>,
    /// Scheme the ranking used, echoed back so a cached or logged response is self describing.
    pub scheme: CharaKarakaResponseScheme,
}
string_enum! {
    /// Scheme the ranking used, echoed back so a cached or logged response is self describing.
    CharaKarakaResponseScheme {
        Seven = "seven",
        Eight = "eight",
    }
}
/// One Chara Karaka: the office, the graha holding it, the degree that earned it, and what the office is read for.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CharaKarakaResponseKarakasItem {
    /// Practitioner shorthand: AK, AmK, BK, MK, PiK, PK, GK, DK, in descending rank order.
    pub abbreviation: String,
    /// Degree the graha has advanced into its sign, 0 to 30. This is the figure a chart displays.
    #[serde(rename = "degreeInRashi")]
    pub degree_in_rashi: f64,
    /// Graha holding this office in this chart.
    pub graha: String,
    /// Karaka office identifier: atmakaraka, amatyakaraka, bhratrikaraka, matrikaraka, pitrikaraka, putrakaraka, gnatikaraka, darakaraka. Returned in descending rank, so the first entry is always the Atmakaraka.
    pub id: String,
    /// True only for Rahu, flagging that its degree was measured from the end of the sign rather than the start.
    #[serde(rename = "isReversed")]
    pub is_reversed: bool,
    /// Short label for what this karaka is read for, sized for a table cell.
    pub meaning: String,
    /// Classical Sanskrit name of the karaka office.
    pub name: String,
    /// The degree actually ranked. Identical to degreeInRashi for every graha except Rahu, where it is 30 minus that value because Rahu advances backward through the sign. Returned so the ordering can be checked without knowing the rule.
    #[serde(rename = "rankingDegree")]
    pub ranking_degree: f64,
    /// Zodiac sign (rashi) the graha occupies.
    pub rashi: String,
    /// What this karaka office governs in a reading.
    pub significations: String,
}
/// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CharaKarakaResponseFrame {
    /// Sidereal frame this chart was cast in, echoing the ayanamsa request field. "lahiri" when the field was omitted.
    pub ayanamsa: String,
    /// Degrees actually subtracted from every tropical longitude to produce this chart, read at the birth instant. Subtract it back to recover the tropical positions, or compare it against your reference software to confirm you are in the same frame before chasing a placement difference.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
}
/// Request body of `calculateCharaKarakas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CharaKarakaRequest {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<CharaKarakaRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Which Chara Karaka scheme to rank. "eight" includes Rahu, counting its degree in reverse because it moves retrograde, and returns eight offices including Pitrikaraka. "seven" ranks only the seven classical grahas and drops Pitrikaraka. Ketu is excluded from both, since it always mirrors the Rahu degree exactly. The two schemes can produce a different Atmakaraka for the same chart, so select the one your reference software uses. Defaults to "eight".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub scheme: Option<CharaKarakaRequestScheme>,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<CharaKarakaRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CharaKarakaRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Which Chara Karaka scheme to rank. "eight" includes Rahu, counting its degree in reverse because it moves retrograde, and returns eight offices including Pitrikaraka. "seven" ranks only the seven classical grahas and drops Pitrikaraka. Ketu is excluded from both, since it always mirrors the Rahu degree exactly. The two schemes can produce a different Atmakaraka for the same chart, so select the one your reference software uses. Defaults to "eight".
    CharaKarakaRequestScheme {
        Seven = "seven",
        Eight = "eight",
    }
}
string_enum! {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    CharaKarakaRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Response body of `castYesNo`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CastYesNoResponse {
    /// Tarot-derived answer. Yes = upright card supports a positive outcome. No = reversed card suggests obstacles. Maybe = inherently ambiguous card drawn (The Hanged Man, Wheel of Fortune, Temperance, Two of Swords, Four of Swords) signaling pause, reflection, or shifting circumstances. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use answerLocalized for anything a reader sees.
    pub answer: CastYesNoResponseAnswer,
    /// Answer in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "answerLocalized", skip_serializing_if = "Option::is_none")]
    pub answer_localized: Option<String>,
    /// The `card` field.
    pub card: CastYesNoResponseCard,
    /// Contextual narrative explaining why this card answers the question with this result. Connects card meaning, orientation, and arcana strength into actionable guidance.
    pub interpretation: String,
    /// The querent question that was asked, if one was provided.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub question: Option<String>,
    /// The seed used for this draw, echoed back when one was supplied. Present only if the request carried a seed. Makes a cached or forwarded response self describing, so a reading can be reproduced or shared without the original request beside it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
    /// Confidence level of the answer. Strong = Major Arcana card drawn (powerful, definitive cosmic energy). Qualified = Minor Arcana card drawn (nuanced, situational guidance). Always English, whatever the lang parameter says. Use strengthLocalized for anything a reader sees.
    pub strength: CastYesNoResponseStrength,
    /// Answer strength in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "strengthLocalized", skip_serializing_if = "Option::is_none")]
    pub strength_localized: Option<String>,
}
string_enum! {
    /// Confidence level of the answer. Strong = Major Arcana card drawn (powerful, definitive cosmic energy). Qualified = Minor Arcana card drawn (nuanced, situational guidance). Always English, whatever the lang parameter says. Use strengthLocalized for anything a reader sees.
    CastYesNoResponseStrength {
        Strong = "Strong",
        Qualified = "Qualified",
    }
}
/// The `card` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CastYesNoResponseCard {
    /// Whether this card belongs to the Major Arcana (22 trump cards, major life themes) or Minor Arcana (56 suit cards, daily situations).
    pub arcana: CastYesNoResponseCardArcana,
    /// Unique card identifier in kebab-case (e.g. the-fool, ace-of-cups).
    pub id: String,
    /// URL to the tarot card artwork image.
    #[serde(rename = "imageUrl")]
    pub image_url: String,
    /// Key themes and concepts associated with this card in its current orientation (upright or reversed).
    pub keywords: Vec<String>,
    /// Display name of the tarot card.
    pub name: String,
    /// True if the card was drawn reversed (upside down). Reversed cards carry modified or blocked energy compared to upright position.
    pub reversed: bool,
}
string_enum! {
    /// Whether this card belongs to the Major Arcana (22 trump cards, major life themes) or Minor Arcana (56 suit cards, daily situations).
    CastYesNoResponseCardArcana {
        Major = "major",
        Minor = "minor",
    }
}
string_enum! {
    /// Tarot-derived answer. Yes = upright card supports a positive outcome. No = reversed card suggests obstacles. Maybe = inherently ambiguous card drawn (The Hanged Man, Wheel of Fortune, Temperance, Two of Swords, Four of Swords) signaling pause, reflection, or shifting circumstances. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use answerLocalized for anything a reader sees.
    CastYesNoResponseAnswer {
        Yes = "Yes",
        No = "No",
        Maybe = "Maybe",
    }
}
/// Path and query parameters of `castYesNo`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CastYesNoParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CastYesNoParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CastYesNoParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `castThreeCard`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CastThreeCardResponse {
    /// Array of spread positions, each containing a drawn card with position-specific tarot interpretation.
    pub positions: Vec<CastThreeCardResponsePositionsItem>,
    /// The querent question, if one was provided.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub question: Option<String>,
    /// Seed used for this reading, if one was provided. Same seed reproduces identical results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
    /// Name of the tarot spread used (e.g. Three-Card, Celtic Cross, Career, Love).
    pub spread: String,
    /// Narrative summary that connects the cards drawn across the spread positions into one cohesive reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub summary: Option<String>,
}
/// One entry of `positions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CastThreeCardResponsePositionsItem {
    /// The `card` field.
    pub card: DrawnCard,
    /// Position-specific interpretation of the drawn card, explaining how this card meaning applies to this particular spread position.
    pub interpretation: String,
    /// Position name describing what this card reveals (e.g. Past, Present, Future, Challenge).
    pub name: String,
    /// Position number in the spread layout (1-based).
    pub position: f64,
}
/// Path and query parameters of `castThreeCard`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CastThreeCardParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CastThreeCardParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CastThreeCardParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `castReading`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CastReadingResponse {
    /// Positions of changing lines (1-6, bottom to top)
    #[serde(rename = "changingLinePositions")]
    pub changing_line_positions: Vec<f64>,
    /// The `hexagram` field.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub hexagram: Option<Hexagram>,
    /// Line values (6-9) from bottom to top. 6=old yin (changing), 7=young yang, 8=young yin, 9=old yang (changing)
    pub lines: Vec<f64>,
    /// The `resultingHexagram` field.
    #[serde(rename = "resultingHexagram", skip_serializing_if = "Option::is_none")]
    pub resulting_hexagram: Option<Hexagram>,
    /// The seed used for this casting (if provided)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
}
/// Response body of `getHexagram`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct Hexagram {
    /// Binary line pattern (6 digits, bottom to top). 1 = yang (solid line), 0 = yin (broken line). Lines 1-3 form the lower trigram, lines 4-6 form the upper trigram.
    pub binary: String,
    /// Changing line interpretations for all 6 lines
    #[serde(rename = "changingLines")]
    pub changing_lines: Vec<ChangingLine>,
    /// Original Chinese character name of the hexagram in traditional script.
    pub chinese: String,
    /// English translation of the hexagram name, conveying the core concept and life situation it represents.
    pub english: String,
    /// The Image (Xiang) text, symbolic guidance derived from the trigram combination describing the ideal attitude and action.
    pub image: String,
    /// The `interpretation` field.
    pub interpretation: Interpretation,
    /// The Judgment (Tuan) text, the primary oracle statement of the hexagram offering core guidance and outcome.
    pub judgment: String,
    /// Lower trigram (lines 1-3). Combines with the upper trigram to form the hexagram and its meaning.
    #[serde(rename = "lowerTrigram")]
    pub lower_trigram: String,
    /// Hexagram number in the traditional King Wen sequence (1-64), the standard ordering used in I-Ching divination for over 3,000 years.
    pub number: f64,
    /// Pinyin romanization of the Chinese name with tone marks for correct pronunciation.
    pub pinyin: String,
    /// Unicode hexagram symbol (U+4DC0 block) representing all six lines. Use for visual display in I-Ching apps and divination interfaces.
    pub symbol: String,
    /// Upper trigram (lines 4-6). One of 8 trigrams: Heaven, Earth, Thunder, Wind, Water, Fire, Mountain, Lake.
    #[serde(rename = "upperTrigram")]
    pub upper_trigram: String,
}
/// The `interpretation` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct Interpretation {
    /// Practical wisdom and actionable advice from this hexagram for daily life application.
    pub advice: String,
    /// Career and professional life interpretation.
    pub career: String,
    /// Decision-making guidance for whether to act, wait, retreat, or advance based on this hexagram.
    pub decision: String,
    /// General life situation interpretation of this hexagram.
    pub general: String,
    /// Love and relationship guidance from this hexagram.
    pub love: String,
}
/// Path and query parameters of `castReading`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CastReadingParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CastReadingParamsLang>,
    /// Optional seed for reproducible castings. Same seed = same casting every time. Pass any unique identifier (userId, session token, question hash). Omit for random casting.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CastReadingParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `castLoveSpread`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CastLoveSpreadResponse {
    /// Array of 5 love spread positions exploring relationship dynamics, each with a drawn card and position-specific interpretation.
    pub positions: Vec<CastLoveSpreadResponsePositionsItem>,
    /// The querent question, if one was provided.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub question: Option<String>,
    /// Seed used for this reading, if one was provided. Same seed reproduces identical results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
    /// Name of the tarot spread used (e.g. Three-Card, Celtic Cross, Career, Love).
    pub spread: String,
    /// Narrative summary that connects the cards drawn across the spread positions into one cohesive reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub summary: Option<String>,
}
/// One entry of `positions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CastLoveSpreadResponsePositionsItem {
    /// The `card` field.
    pub card: DrawnCard,
    /// Position-specific interpretation of the drawn card, explaining how this card meaning applies to this particular spread position.
    pub interpretation: String,
    /// Position name describing what this card reveals (e.g. Past, Present, Future, Challenge).
    pub name: String,
    /// Position number in the spread layout (1-based).
    pub position: f64,
}
/// Path and query parameters of `castLoveSpread`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CastLoveSpreadParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CastLoveSpreadParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CastLoveSpreadParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `castKpHoraryChart`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CastKpHoraryChartParams {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<CastKpHoraryChartParamsFocus>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CastKpHoraryChartParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CastKpHoraryChartParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    CastKpHoraryChartParamsFocus {
        General = "general",
        Finance = "finance",
    }
}
/// Response body of `castDailyReading`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CastDailyReadingResponse {
    /// Positions of changing lines (1-6, bottom to top). These lines transform yin to yang or vice versa.
    #[serde(rename = "changingLinePositions")]
    pub changing_line_positions: Vec<f64>,
    /// The oracle statement and meaning of each line that came up CHANGING, and only those. The changing lines are what the cast is actually about, so this saves a second call to read them and stops a consuming agent from having to invent them.
    #[serde(rename = "changingLines", skip_serializing_if = "Option::is_none")]
    pub changing_lines: Option<Vec<ChangingLine>>,
    /// Date this daily casting is for (YYYY-MM-DD, UTC).
    pub date: String,
    /// The `hexagram` field.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub hexagram: Option<CastDailyReadingResponseHexagram>,
    /// Line values (6-9) from bottom to top. 6=old yin (changing), 7=young yang, 8=young yin, 9=old yang (changing).
    pub lines: Vec<f64>,
    /// Hexagram after transformation (if changing lines present)
    #[serde(rename = "resultingHexagram", skip_serializing_if = "Option::is_none")]
    pub resulting_hexagram: Option<CastDailyReadingResponseResultingHexagram>,
    /// Computed seed for reproducible castings.
    pub seed: String,
}
/// Hexagram after transformation (if changing lines present)
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CastDailyReadingResponseResultingHexagram {
    /// Original Chinese name.
    pub chinese: String,
    /// English translation of the hexagram name.
    pub english: String,
    /// The Image (Xiang) text, symbolic guidance derived from the trigram combination describing the ideal action.
    pub image: String,
    /// Modern interpretations across life areas based on ancient I-Ching wisdom.
    pub interpretation: CastDailyReadingResponseResultingHexagramInterpretation,
    /// The Judgment (Tuan) text, the primary oracle statement of the hexagram offering core guidance.
    pub judgment: String,
    /// Lower trigram (lines 1-3).
    #[serde(rename = "lowerTrigram")]
    pub lower_trigram: String,
    /// Hexagram number in King Wen sequence (1-64).
    pub number: f64,
    /// Pinyin romanization with tone marks.
    pub pinyin: String,
    /// Unicode hexagram symbol for display.
    pub symbol: String,
    /// Upper trigram (lines 4-6).
    #[serde(rename = "upperTrigram")]
    pub upper_trigram: String,
}
/// Modern interpretations across life areas based on ancient I-Ching wisdom.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CastDailyReadingResponseResultingHexagramInterpretation {
    /// Practical wisdom and actionable advice.
    pub advice: String,
    /// Career and professional interpretation.
    pub career: String,
    /// Decision-making guidance for whether to act, wait, or change course.
    pub decision: String,
    /// General life situation interpretation.
    pub general: String,
    /// Love and relationship guidance.
    pub love: String,
}
/// The `hexagram` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CastDailyReadingResponseHexagram {
    /// Binary line pattern (6 digits, bottom to top). 1 = yang (solid line), 0 = yin (broken line). Lines 1-3 form the lower trigram, lines 4-6 form the upper trigram.
    pub binary: String,
    /// The oracle statement and meaning of each line that came up CHANGING, and only those. The changing lines are what the cast is actually about, so this saves a second call to read them and stops a consuming agent from having to invent them.
    #[serde(rename = "changingLines", skip_serializing_if = "Option::is_none")]
    pub changing_lines: Option<Vec<ChangingLine>>,
    /// Original Chinese name.
    pub chinese: String,
    /// English translation of the hexagram name.
    pub english: String,
    /// The Image (Xiang) text, symbolic guidance derived from the trigram combination describing the ideal action.
    pub image: String,
    /// Modern interpretations across life areas based on ancient I-Ching wisdom.
    pub interpretation: CastDailyReadingResponseHexagramInterpretation,
    /// The Judgment (Tuan) text, the primary oracle statement of the hexagram offering core guidance.
    pub judgment: String,
    /// Lower trigram (lines 1-3).
    #[serde(rename = "lowerTrigram")]
    pub lower_trigram: String,
    /// Hexagram number in King Wen sequence (1-64).
    pub number: f64,
    /// Pinyin romanization with tone marks.
    pub pinyin: String,
    /// Unicode hexagram symbol for display.
    pub symbol: String,
    /// Upper trigram (lines 4-6).
    #[serde(rename = "upperTrigram")]
    pub upper_trigram: String,
}
/// Modern interpretations across life areas based on ancient I-Ching wisdom.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CastDailyReadingResponseHexagramInterpretation {
    /// Practical wisdom and actionable advice.
    pub advice: String,
    /// Career and professional interpretation.
    pub career: String,
    /// Decision-making guidance for whether to act, wait, or change course.
    pub decision: String,
    /// General life situation interpretation.
    pub general: String,
    /// Love and relationship guidance.
    pub love: String,
}
/// One entry of `changingLines`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ChangingLine {
    /// What the line statement asks of the querent, read from its position in the hexagram (1 is the hidden beginning, 3 is the exposed threshold, 5 is the ruling line, 6 is past the peak) and from whether the line is yin or yang. This is the meaning behind the image, so a consuming agent does not have to invent one.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub meaning: Option<String>,
    /// Line position (1-6, bottom to top). In I-Ching, each hexagram has six lines (yao) read from bottom upward.
    pub position: f64,
    /// The oracle statement for this line. It applies when this specific line comes up changing (old yin or old yang) in a casting, and it speaks in the concrete imagery of the tradition.
    pub text: String,
}
/// Path and query parameters of `castDailyReading`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CastDailyReadingParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CastDailyReadingParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CastDailyReadingParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `castCustomSpread`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CastCustomSpreadResponse {
    /// Array of custom spread positions matching your defined layout, each with a drawn card and position-specific interpretation.
    pub positions: Vec<CastCustomSpreadResponsePositionsItem>,
    /// The querent question, if one was provided.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub question: Option<String>,
    /// Seed used for this reading, if one was provided. Same seed reproduces identical results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
    /// Name of the tarot spread used (e.g. Three-Card, Celtic Cross, Career, Love).
    pub spread: String,
}
/// One entry of `positions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CastCustomSpreadResponsePositionsItem {
    /// The `card` field.
    pub card: DrawnCard,
    /// Position-specific interpretation of the drawn card, explaining how this card meaning applies to this particular spread position.
    pub interpretation: String,
    /// Position name describing what this card reveals (e.g. Past, Present, Future, Challenge).
    pub name: String,
    /// Position number in the spread layout (1-based).
    pub position: f64,
}
/// Request body of `castCustomSpread`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CastCustomSpreadRequest {
    /// Array of 1-10 custom position definitions for your tarot spread. Each position gets one drawn card with a position-specific interpretation.
    pub positions: Vec<CastCustomSpreadRequestPositionsItem>,
    /// Optional querent question to focus the custom tarot reading. Provides context for position-specific interpretations.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub question: Option<String>,
    /// Optional seed for reproducible results. Same seed with the same positions produces identical card draws for consistent divination.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
    /// Optional name for your custom tarot spread layout. Used as the spread identifier in the response.
    #[serde(rename = "spreadName", skip_serializing_if = "Option::is_none")]
    pub spread_name: Option<String>,
}
/// One entry of `positions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CastCustomSpreadRequestPositionsItem {
    /// Description of what this position reveals in the reading. Guides the tarot interpretation for the card drawn in this slot.
    pub interpretation: String,
    /// Name for this position in the spread (e.g. Core Issue, Hidden Factor, Best Action). Defines what aspect of the reading this card represents.
    pub name: String,
}
/// Path and query parameters of `castCustomSpread`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CastCustomSpreadParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CastCustomSpreadParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CastCustomSpreadParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `castCelticCross`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CastCelticCrossResponse {
    /// Array of 10 spread positions forming the complete Celtic Cross layout, each with a drawn card and position-specific interpretation.
    pub positions: Vec<CastCelticCrossResponsePositionsItem>,
    /// The querent question, if one was provided.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub question: Option<String>,
    /// Seed used for this reading, if one was provided. Same seed reproduces identical results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
    /// Name of the tarot spread used (e.g. Three-Card, Celtic Cross, Career, Love).
    pub spread: String,
    /// Narrative summary that connects the cards drawn across the spread positions into one cohesive reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub summary: Option<String>,
}
/// One entry of `positions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CastCelticCrossResponsePositionsItem {
    /// The `card` field.
    pub card: DrawnCard,
    /// Position-specific interpretation of the drawn card, explaining how this card meaning applies to this particular spread position.
    pub interpretation: String,
    /// Position name describing what this card reveals (e.g. Past, Present, Future, Challenge).
    pub name: String,
    /// Position number in the spread layout (1-based).
    pub position: f64,
}
/// Path and query parameters of `castCelticCross`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CastCelticCrossParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CastCelticCrossParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CastCelticCrossParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `castCareerSpread`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CastCareerSpreadResponse {
    /// Array of 7 career spread positions using SWOT framework, each with a drawn card and position-specific interpretation.
    pub positions: Vec<CastCareerSpreadResponsePositionsItem>,
    /// The querent question, if one was provided.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub question: Option<String>,
    /// Seed used for this reading, if one was provided. Same seed reproduces identical results.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
    /// Name of the tarot spread used (e.g. Three-Card, Celtic Cross, Career, Love).
    pub spread: String,
    /// Narrative summary that connects the cards drawn across the spread positions into one cohesive reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub summary: Option<String>,
}
/// One entry of `positions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CastCareerSpreadResponsePositionsItem {
    /// The `card` field.
    pub card: DrawnCard,
    /// Position-specific interpretation of the drawn card, explaining how this card meaning applies to this particular spread position.
    pub interpretation: String,
    /// Position name describing what this card reveals (e.g. Past, Present, Future, Challenge).
    pub name: String,
    /// Position number in the spread layout (1-based).
    pub position: f64,
}
/// The `card` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DrawnCard {
    /// Whether this card belongs to the Major Arcana (22 trump cards, major life themes) or Minor Arcana (56 suit cards, daily situations).
    pub arcana: DrawnCardArcana,
    /// Career and professional interpretation for the drawn orientation. Covers workplace dynamics, job transitions, ambition, and vocational purpose.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub career: Option<String>,
    /// Financial interpretation for the drawn orientation. Covers money management, investments, material prosperity, and abundance mindset.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub finances: Option<String>,
    /// Health and wellbeing interpretation for the drawn orientation. Covers physical vitality, mental health, energy levels, and self-care guidance.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub health: Option<String>,
    /// Unique card identifier in kebab-case (e.g. the-fool, ace-of-cups).
    pub id: String,
    /// URL to the tarot card artwork image.
    #[serde(rename = "imageUrl")]
    pub image_url: String,
    /// Key themes and concepts associated with this card in its current orientation (upright or reversed).
    pub keywords: Vec<String>,
    /// Love and relationship interpretation for the drawn orientation. Covers romantic partnerships, dating, emotional connections, and matters of the heart.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub love: Option<String>,
    /// Full interpretation of this card in its current orientation, providing detailed divination guidance.
    pub meaning: String,
    /// Display name of the tarot card.
    pub name: String,
    /// Card number within its arcana. Major Arcana: 0 (Fool) through 21 (World). Minor Arcana: 1 (Ace) through 14 (King). Null when not applicable.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub number: Option<f64>,
    /// Position index of this card in the draw sequence (1-based). Useful for mapping cards to spread positions.
    pub position: f64,
    /// True if the card was drawn reversed (upside down). Reversed cards carry modified or blocked energy compared to upright position.
    pub reversed: bool,
    /// Spiritual interpretation for the drawn orientation. Covers personal growth, inner wisdom, soul purpose, and metaphysical development.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub spirituality: Option<String>,
    /// Suit of the card (Minor Arcana only). Cups=emotions, Wands=creativity, Swords=intellect, Pentacles=material. Null for Major Arcana cards.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub suit: Option<DrawnCardSuit>,
}
string_enum! {
    /// Suit of the card (Minor Arcana only). Cups=emotions, Wands=creativity, Swords=intellect, Pentacles=material. Null for Major Arcana cards.
    DrawnCardSuit {
        Cups = "cups",
        Wands = "wands",
        Swords = "swords",
        Pentacles = "pentacles",
    }
}
string_enum! {
    /// Whether this card belongs to the Major Arcana (22 trump cards, major life themes) or Minor Arcana (56 suit cards, daily situations).
    DrawnCardArcana {
        Major = "major",
        Minor = "minor",
    }
}
/// Path and query parameters of `castCareerSpread`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CastCareerSpreadParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CastCareerSpreadParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CastCareerSpreadParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `getCard`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct Card {
    /// Whether this card belongs to the Major Arcana (22 trump cards representing major life themes) or Minor Arcana (56 suit cards for daily situations).
    pub arcana: CardArcana,
    /// Unique card identifier in kebab-case, with no leading article on Major Arcana (e.g. fool, star, ace-of-cups, queen-of-swords). This is the canonical form, whatever spelling was requested.
    pub id: String,
    /// URL to the tarot card artwork image in the Rider-Waite-Smith style.
    #[serde(rename = "imageUrl")]
    pub image_url: String,
    /// Keywords for both upright and reversed orientations of this tarot card, useful for quick divination reference.
    pub keywords: CardKeywords,
    /// Display name of the tarot card as it appears in the Rider-Waite-Smith tradition.
    pub name: String,
    /// Card number within its arcana. Major Arcana: 0 (Fool) through 21 (World). Minor Arcana: 1 (Ace) through 14 (King).
    pub number: f64,
    /// Complete reversed (inverted) interpretation including description, keywords, and guidance across love, career, finances, health, and spirituality domains. Reversed cards carry modified or blocked energy.
    pub reversed: CardReversed,
    /// Suit of the card (Minor Arcana only). Cups=emotions, Wands=creativity, Swords=intellect, Pentacles=material. Null for Major Arcana cards.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub suit: Option<CardSuit>,
    /// Complete upright interpretation including description, keywords, and guidance across love, career, finances, health, and spirituality domains.
    pub upright: CardUpright,
}
/// Complete upright interpretation including description, keywords, and guidance across love, career, finances, health, and spirituality domains.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CardUpright {
    /// Career and professional interpretation for this orientation. Covers workplace dynamics, job transitions, ambition, and vocational purpose.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub career: Option<String>,
    /// Full narrative interpretation of the card in this orientation. Covers symbolism, life lessons, and guidance for the querent.
    pub description: String,
    /// Financial interpretation for this orientation. Covers money management, investments, material prosperity, and abundance mindset.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub finances: Option<String>,
    /// Health and wellbeing interpretation for this orientation. Covers physical vitality, mental health, energy levels, and self-care guidance.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub health: Option<String>,
    /// Key themes and concepts for this card in the given orientation (upright or reversed). Used for quick tarot reference and divination summaries.
    pub keywords: Vec<String>,
    /// Love and relationship interpretation for this orientation. Covers romantic partnerships, dating, emotional connections, and matters of the heart.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub love: Option<String>,
    /// Spiritual interpretation for this orientation. Covers personal growth, inner wisdom, soul purpose, and metaphysical development.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub spirituality: Option<String>,
}
string_enum! {
    /// Suit of the card (Minor Arcana only). Cups=emotions, Wands=creativity, Swords=intellect, Pentacles=material. Null for Major Arcana cards.
    CardSuit {
        Cups = "cups",
        Wands = "wands",
        Swords = "swords",
        Pentacles = "pentacles",
    }
}
/// Complete reversed (inverted) interpretation including description, keywords, and guidance across love, career, finances, health, and spirituality domains. Reversed cards carry modified or blocked energy.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CardReversed {
    /// Career and professional interpretation for this orientation. Covers workplace dynamics, job transitions, ambition, and vocational purpose.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub career: Option<String>,
    /// Full narrative interpretation of the card in this orientation. Covers symbolism, life lessons, and guidance for the querent.
    pub description: String,
    /// Financial interpretation for this orientation. Covers money management, investments, material prosperity, and abundance mindset.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub finances: Option<String>,
    /// Health and wellbeing interpretation for this orientation. Covers physical vitality, mental health, energy levels, and self-care guidance.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub health: Option<String>,
    /// Key themes and concepts for this card in the given orientation (upright or reversed). Used for quick tarot reference and divination summaries.
    pub keywords: Vec<String>,
    /// Love and relationship interpretation for this orientation. Covers romantic partnerships, dating, emotional connections, and matters of the heart.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub love: Option<String>,
    /// Spiritual interpretation for this orientation. Covers personal growth, inner wisdom, soul purpose, and metaphysical development.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub spirituality: Option<String>,
}
/// Keywords for both upright and reversed orientations of this tarot card, useful for quick divination reference.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CardKeywords {
    /// Key themes when the card is drawn reversed (inverted). Reversed meanings often indicate blocked or internalized energy.
    pub reversed: Vec<String>,
    /// Key themes when the card is drawn upright. Used for quick tarot reference and reading summaries.
    pub upright: Vec<String>,
}
string_enum! {
    /// Whether this card belongs to the Major Arcana (22 trump cards representing major life themes) or Minor Arcana (56 suit cards for daily situations).
    CardArcana {
        Major = "major",
        Minor = "minor",
    }
}
/// Response body of `calculateZodiacAnimal`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateZodiacAnimalResponse {
    /// The zodiac animal for this date. The element on this block is the animal own fixed branch phase, which for a Horse is always Fire. The year phase is the sibling element field below.
    pub animal: CalculateZodiacAnimalResponseAnimal,
    /// The school parameters this answer was computed under, echoed so the result is self-describing.
    pub conventions: CalculateZodiacAnimalResponseConventions,
    /// Echo of the birth date the answer was resolved from.
    pub date: String,
    /// Five Element phase of the year Heavenly Stem. This is what distinguishes a Metal Horse from a Fire Horse and it changes every two years. It is NOT the animal own fixed phase, which sits on the animal block above. Always English so it stays safe to compare against.
    pub element: String,
    /// Five Element phase name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Composed reading of the sign under its year phase. The sign contributes the temperament and the phase contributes the register.
    pub interpretation: String,
    /// Yin or yang polarity of the branch. The twelve branches alternate, starting yang at zi, so the six odd-numbered animals are yang and the six even-numbered are yin.
    pub polarity: String,
    /// The sexagenary year the date falls in, under the resolved boundary. Stem and branch together repeat once every sixty years.
    #[serde(rename = "yearPillar")]
    pub year_pillar: CalculateZodiacAnimalResponseYearPillar,
}
/// The sexagenary year the date falls in, under the resolved boundary. Stem and branch together repeat once every sixty years.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateZodiacAnimalResponseYearPillar {
    /// Earthly Branch of the year, as its pinyin identifier. This is the branch the animal names.
    pub branch: String,
    /// Sexagenary year pillar id, Heavenly Stem then Earthly Branch. Always English pinyin.
    pub id: String,
    /// Position of this pillar in the sixty-year sexagenary cycle, 1 to 60, where jia-zi is 1.
    pub number: f64,
    /// Heavenly Stem of the year, as its pinyin identifier.
    pub stem: String,
}
/// The school parameters this answer was computed under, echoed so the result is self-describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateZodiacAnimalResponseConventions {
    /// The year boundary actually applied, whether it was requested or defaulted. Store this beside any sign you persist: the same date resolves to two different animals under the two schools, and a sign with no convention recorded cannot be reproduced.
    #[serde(rename = "yearBoundary")]
    pub year_boundary: String,
}
/// The zodiac animal for this date. The element on this block is the animal own fixed branch phase, which for a Horse is always Fire. The year phase is the sibling element field below.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateZodiacAnimalResponseAnimal {
    /// Earthly Branch this animal names, as its pinyin identifier. The twelve branches are zi, chou, yin, mao, chen, si, wu, wei, shen, you, xu, hai, and they run in the same order as the animals. Every animal element, polarity and double-hour is a property of this branch.
    pub branch: String,
    /// Traditional hanzi character for the animal itself, not for its Earthly Branch. Data rather than a translation, so it is identical under every lang.
    pub chinese: String,
    /// Fixed Five Element (Wu Xing) phase of the animal own branch: Wood, Fire, Earth, Metal or Water. This never changes for a sign. It is NOT the year phase that makes a Metal Rat differ from a Water Rat, which comes from the year Heavenly Stem. Always English so it stays safe to compare against and to key colours off.
    pub element: String,
    /// Five Element phase name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Stable machine identifier for the animal. Always English and lowercase, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees. The twelve ids are rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, pig.
    pub id: String,
    /// Display name of the animal in English. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Animal name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone-marked Hanyu Pinyin for the animal name. Data rather than a translation, so it is identical under every lang.
    pub pinyin: String,
    /// Yin or yang polarity of the branch. The twelve branches alternate, starting yang at zi, so the six odd-numbered animals are yang and the six even-numbered are yin.
    pub polarity: String,
}
/// Request body of `calculateZodiacAnimal`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateZodiacAnimalRequest {
    /// Birth date in YYYY-MM-DD format. Only the date is needed: the zodiac animal is a property of the year, so no time, timezone or place changes the answer.
    pub date: String,
    /// Which instant starts the zodiac year. lunar-new-year is the folk rule and the default on this route, because it is the rule people mean when they say what animal they are: the sign turns on Chinese New Year, between late January and late February. li-chun is the classical rule every Four Pillars text uses, turning the year at the solar term Beginning of Spring around 4 February. The two agree for roughly eleven months of every year and disagree for the weeks between them, so a 14 February 2026 birth is a Snake under lunar-new-year and a Horse under li-chun. The BaZi routes default to li-chun instead, because a chart and a folk sign are answering different questions.
    #[serde(rename = "yearBoundary", skip_serializing_if = "Option::is_none")]
    pub year_boundary: Option<CalculateZodiacAnimalRequestYearBoundary>,
}
string_enum! {
    /// Which instant starts the zodiac year. lunar-new-year is the folk rule and the default on this route, because it is the rule people mean when they say what animal they are: the sign turns on Chinese New Year, between late January and late February. li-chun is the classical rule every Four Pillars text uses, turning the year at the solar term Beginning of Spring around 4 February. The two agree for roughly eleven months of every year and disagree for the weeks between them, so a 14 February 2026 birth is a Snake under lunar-new-year and a Horse under li-chun. The BaZi routes default to li-chun instead, because a chart and a folk sign are answering different questions.
    CalculateZodiacAnimalRequestYearBoundary {
        LunarNewYear = "lunar-new-year",
        LiChun = "li-chun",
    }
}
/// Path and query parameters of `calculateZodiacAnimal`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateZodiacAnimalParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateZodiacAnimalParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateZodiacAnimalParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateVariables`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateVariablesResponse {
    /// The four Variable arrows: Determination and Environment from the design side, Perspective and Motivation from the personality side. Together they form the Rave Variables / Primary Health System layer that sits beneath Type, Strategy, Authority, and Profile.
    pub arrows: Vec<CalculateVariablesResponseArrowsItem>,
    /// What the Base layer is. Returned once at the top level rather than repeated on every arrow, since the Base layer is the same concept for all four. No per-Base meaning is returned: every one in circulation traces back to a single origin, so it fails the two-source bar this package holds.
    #[serde(rename = "baseDescription")]
    pub base_description: String,
    /// Boundary margin in degrees of ecliptic longitude used for the per-arrow confidence flag, the solar arc over a few minutes of clock time. An activation within this distance of a Color or Tone boundary is flagged low-confidence.
    #[serde(rename = "confidenceMarginDeg")]
    pub confidence_margin_deg: f64,
    /// True only when all four arrows are confident. A single knife-edge arrow makes the whole configuration uncertain.
    pub confident: bool,
}
/// One entry of `arrows`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateVariablesResponseArrowsItem {
    /// The single activation, body and chart side, that this arrow is derived from.
    pub activation: CalculateVariablesResponseArrowsItemActivation,
    /// Base number from 1 to 5, the finest published subdivision of the wheel. Returned for completeness but treated as informational, since it is finer than most birth times can resolve.
    pub base: f64,
    /// Name of the Base. Informational only: the Base is finer than any civil birth time can resolve. Always English, whatever the lang parameter says. Use baseNameLocalized for anything a reader sees.
    #[serde(rename = "baseName")]
    pub base_name: String,
    /// Base name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "baseNameLocalized", skip_serializing_if = "Option::is_none")]
    pub base_name_localized: Option<String>,
    /// Cognition, the strongest sense, read off the Determination Tone. Present on the determination arrow ONLY: no authority supports reading Cognition from the other three arrows, so it is omitted rather than invented.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cognition: Option<CalculateVariablesResponseArrowsItemCognition>,
    /// Color number from 1 to 6, the substructure level one octave finer than the line. Color selects the arrow theme, for example the determination family or the motivation.
    pub color: f64,
    /// Name of the Color theme for this arrow, for example a determination family such as Touch, an environment such as Mountains, a perspective such as Personal, or a motivation such as Hope. Always English, whatever the lang parameter says. Use colorLabelLocalized for anything a reader sees.
    #[serde(rename = "colorLabel")]
    pub color_label: String,
    /// Color theme name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "colorLabelLocalized", skip_serializing_if = "Option::is_none")]
    pub color_label_localized: Option<String>,
    /// Meaning of the Color for THIS arrow. The same Color number means something different under Determination than under Motivation, so this is the reading of colorLabel in context, not a generic gloss.
    #[serde(rename = "colorMeaning")]
    pub color_meaning: String,
    /// Whether this arrow is far enough from a Color or Tone boundary to be reliable. When false the activation sits on a knife edge where the Color label or the arrow direction could flip with a more precise birth time, and the arrow should not be presented as fact.
    pub confident: bool,
    /// What this arrow is and what it governs.
    pub description: String,
    /// Arrow direction derived from the Tone. left for tones 1 to 3, right for tones 4 to 6.
    pub direction: String,
    /// Keynote of the arrow direction for this arrow, for example Active or Passive for Determination, Focused or Peripheral for Perspective. Always English, whatever the lang parameter says. Use directionLabelLocalized for anything a reader sees.
    #[serde(rename = "directionLabel")]
    pub direction_label: String,
    /// Arrow direction keynote in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "directionLabelLocalized", skip_serializing_if = "Option::is_none")]
    pub direction_label_localized: Option<String>,
    /// Meaning of the left or right direction for THIS arrow, the reading of directionLabel.
    #[serde(rename = "directionMeaning")]
    pub direction_meaning: String,
    /// Stable arrow identifier. One of determination, environment, perspective, motivation.
    pub key: String,
    /// Which half of the advanced layer the arrow belongs to. Primary Health System covers the body-side Determination and Environment arrows, Rave Psychology covers the mind-side Perspective and Motivation arrows. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use layerLocalized for anything a reader sees.
    pub layer: String,
    /// What the layer this arrow belongs to governs, the body side or the mind side.
    #[serde(rename = "layerDescription")]
    pub layer_description: String,
    /// Layer name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "layerLocalized", skip_serializing_if = "Option::is_none")]
    pub layer_localized: Option<String>,
    /// Arrow name. Determination is the top-left arrow governing the Primary Health System and digestion, Environment the bottom-left arrow, Perspective the bottom-right arrow also called View, and Motivation the top-right arrow. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Arrow name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Position of the arrow at the head of the bodygraph. One of Top left, Bottom left, Top right, Bottom right. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use positionLocalized for anything a reader sees.
    pub position: String,
    /// Arrow position name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "positionLocalized", skip_serializing_if = "Option::is_none")]
    pub position_localized: Option<String>,
    /// Tone number from 1 to 6, the substructure level beneath Color. Tone sets the arrow direction: tones 1 to 3 face left, tones 4 to 6 face right.
    pub tone: f64,
    /// Meaning of the Tone. The six Tones are shared across all four arrows: the arrow does not change the Tone, it changes what the Tone qualifies.
    #[serde(rename = "toneMeaning")]
    pub tone_meaning: String,
}
/// Cognition, the strongest sense, read off the Determination Tone. Present on the determination arrow ONLY: no authority supports reading Cognition from the other three arrows, so it is omitted rather than invented.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateVariablesResponseArrowsItemCognition {
    /// How this Cognition discriminates what is correct for the body, and the conditions that sharpen it. Renderable as the Cognition paragraph of a Variables or Primary Health System report.
    pub description: String,
    /// Name of the Cognition, the strongest sense. One of six read off the Determination Tone: Smell, Taste, Outer Vision, Inner Vision, Feeling, Touch. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use labelLocalized for anything a reader sees.
    pub label: String,
    /// Cognition name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "labelLocalized", skip_serializing_if = "Option::is_none")]
    pub label_localized: Option<String>,
}
/// The single activation, body and chart side, that this arrow is derived from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateVariablesResponseArrowsItemActivation {
    /// Activating body whose substructure feeds this arrow. Determination and Motivation come from the Sun, Environment and Perspective from the North Node. Always English, whatever the lang parameter says, so it stays safe to compare against in code and to key a glyph table on. Use planetLocalized for anything a reader sees.
    pub planet: String,
    /// Activating body name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "planetLocalized", skip_serializing_if = "Option::is_none")]
    pub planet_localized: Option<String>,
    /// Chart side of the activation. Determination and Environment come from the design side, Perspective and Motivation from the personality side. Always English, whatever the lang parameter says, so it stays safe to compare against in code.
    pub side: String,
}
/// Request body of `calculateVariables`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateVariablesRequest {
    /// Birth date in YYYY-MM-DD format. The anchor for both the Personality activations at birth and the Design activations 88 degrees of solar arc earlier.
    pub date: String,
    /// Birth latitude in decimal degrees. Optional and does not affect the bodygraph, which depends only on ecliptic longitudes. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Optional and does not affect the bodygraph. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<CalculateVariablesRequestNodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Precision matters: the profile lines and gate boundaries shift with the exact minute of birth.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: CalculateVariablesRequestTimezone,
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateVariablesRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    CalculateVariablesRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Path and query parameters of `calculateVariables`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateVariablesParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateVariablesParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateVariablesParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateTzolkin`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTzolkinResponse {
    /// The conventions this answer was computed under, echoed so the result is self describing. Only the correlation is echoed here, because it is the only switch this route takes.
    pub conventions: CalculateTzolkinResponseConventions,
    /// Echo of the date the day was resolved from, in proleptic Gregorian.
    pub date: String,
    /// Machine identifier of the Tzolkin day sign, always lowercase ASCII Yucatec whatever the lang parameter says, so it stays safe to compare against in code. The twenty ids run imix, ik, akbal, kan, chikchan, kimi, manik, lamat, muluk, ok, chuwen, eb, ben, ix, men, kib, kaban, etznab, kawak, ajaw.
    #[serde(rename = "daySign")]
    pub day_sign: String,
    /// The sixteenth century Yucatec spelling of the same sign, which is the form most printed reference tables and older sources use. Useful for matching a name a reader copied out of a book.
    #[serde(rename = "daySignClassic")]
    pub day_sign_classic: String,
    /// The Kʼicheʼ name of the same day from the living highland daykeeping tradition, which is the vocabulary a nawal reading in Guatemala uses. A parallel naming tradition rather than a translation, so it is identical under every lang.
    #[serde(rename = "daySignKiche")]
    pub day_sign_kiche: String,
    /// Display name of the day sign in the standard Maya orthography, where the ejective is written with a modifier letter rather than a typewriter quote. A proper noun carried as data, so it is identical under every lang.
    #[serde(rename = "daySignName")]
    pub day_sign_name: String,
    /// The Tzolkin coefficient, 1 to 13. This is the classical day number that runs alongside the twenty signs; it is not a rank and a 13 is not better than a 1. Nine of the thirteen carry a recorded character, which is returned separately.
    pub number: f64,
    /// The composed nawal reading for this day: the sign, what the coefficient contributes, and what the sign does well and badly.
    pub reading: CalculateTzolkinResponseReading,
    /// The thirteen day period this day belongs to. The trecena is the unit a daykeeper reads a run of days in, and the sign it opens on is what gives the whole period its character.
    pub trecena: CalculateTzolkinResponseTrecena,
}
/// The thirteen day period this day belongs to. The trecena is the unit a daykeeper reads a run of days in, and the sign it opens on is what gives the whole period its character.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTzolkinResponseTrecena {
    /// Position of this day inside its trecena, 1 to 13. Always equal to the coefficient, because a trecena is exactly one run of the coefficient.
    #[serde(rename = "dayOfTrecena")]
    pub day_of_trecena: f64,
    /// Which of the twenty thirteen day periods this day falls in, 1 to 20. Trecena 1 opens on 1 Imix.
    pub number: f64,
    /// Machine identifier of the day sign the trecena opens on, which the tradition reads as colouring all thirteen of its days.
    #[serde(rename = "rulingSign")]
    pub ruling_sign: String,
    /// Display name of the sign the trecena opens on. A proper noun carried as data.
    #[serde(rename = "rulingSignName")]
    pub ruling_sign_name: String,
}
/// The composed nawal reading for this day: the sign, what the coefficient contributes, and what the sign does well and badly.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTzolkinResponseReading {
    /// Where the same temperament costs the sign something. Each one is the shadow of a strength above rather than an unrelated flaw.
    pub challenges: Vec<String>,
    /// The one thing worth doing differently under this sign.
    pub guidance: String,
    /// The sign in one composed sentence: its name in both naming traditions, what it is about, and the glyph reading behind it. Composed per request from the sign components rather than stored whole, which is why it stays consistent with every other reading in the response.
    pub keynote: String,
    /// Machine identifier of the recorded character of the coefficient: gentle, indifferent or violent. ABSENT for coefficients 4, 5, 6 and 10, which have no recorded character in any consulted source. Always English so it stays safe to switch on.
    #[serde(rename = "numberBand", skip_serializing_if = "Option::is_none")]
    pub number_band: Option<String>,
    /// What the coefficient contributes. Nine of the thirteen carry a recorded character, banded as gentle, indifferent or violent; the other four carry none and this field says so rather than inventing one. The band ids are the source vocabulary, so violent names the days reserved for strong ceremony and defence and is not a warning.
    #[serde(rename = "numberReading")]
    pub number_reading: String,
    /// What the sign does well, as full sentences rather than keywords.
    pub strengths: Vec<String>,
}
/// The conventions this answer was computed under, echoed so the result is self describing. Only the correlation is echoed here, because it is the only switch this route takes.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTzolkinResponseConventions {
    /// The correlation constant actually applied, whether it was requested or defaulted. Store this beside any Maya date you persist: the same civil date resolves to a different Long Count under each constant, and a date with no correlation recorded cannot be reproduced.
    pub correlation: String,
}
/// Request body of `calculateTzolkin`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTzolkinRequest {
    /// Which correlation constant ties the day count to a civil date. This is the single choice that shifts every value in the response, so it is a parameter rather than a hidden default, and the resolved value comes back under conventions. "gmt-584283" is the commonly accepted constant and the default, and it is the one the major institutional converter runs on. "martinez-hernandez-584281" sits two days earlier, "astronomical-584285" two days later, and "martin-skidmore-584286" three days later, each shifting the Long Count by exactly its difference in days. Four of the eight published constants are offered: the other four sit tens of thousands of days away and are of historical interest only. The 584281 constant is the Martínez Hernández correlation, after Juan Martínez Hernández.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub correlation: Option<CalculateTzolkinRequestCorrelation>,
    /// Date in YYYY-MM-DD format, in the PROLEPTIC GREGORIAN calendar, extended backwards unchanged through the 1582 reform. Years 1 to 4000 are accepted. A reference converter that switches to the Julian calendar below the reform will disagree with a date before 15 October 1582 by ten or eleven days; that is a difference of input convention rather than of arithmetic, and passing the Julian equivalent to such a tool reproduces these values exactly. A single-digit month or day is accepted and zero padded.
    pub date: String,
}
string_enum! {
    /// Which correlation constant ties the day count to a civil date. This is the single choice that shifts every value in the response, so it is a parameter rather than a hidden default, and the resolved value comes back under conventions. "gmt-584283" is the commonly accepted constant and the default, and it is the one the major institutional converter runs on. "martinez-hernandez-584281" sits two days earlier, "astronomical-584285" two days later, and "martin-skidmore-584286" three days later, each shifting the Long Count by exactly its difference in days. Four of the eight published constants are offered: the other four sit tens of thousands of days away and are of historical interest only. The 584281 constant is the Martínez Hernández correlation, after Juan Martínez Hernández.
    CalculateTzolkinRequestCorrelation {
        Gmt584283 = "gmt-584283",
        MartinezHernandez584281 = "martinez-hernandez-584281",
        Astronomical584285 = "astronomical-584285",
        MartinSkidmore584286 = "martin-skidmore-584286",
    }
}
/// Path and query parameters of `calculateTzolkin`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateTzolkinParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateTzolkinParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateTzolkinParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Request body of `calculateType`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTypeRequest {
    /// Birth date in YYYY-MM-DD format. The anchor for both the Personality activations at birth and the Design activations 88 degrees of solar arc earlier.
    pub date: String,
    /// Birth latitude in decimal degrees. Optional and does not affect the bodygraph, which depends only on ecliptic longitudes. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Optional and does not affect the bodygraph. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<CalculateTypeRequestNodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Precision matters: the profile lines and gate boundaries shift with the exact minute of birth.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: CalculateTypeRequestTimezone,
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateTypeRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    CalculateTypeRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Path and query parameters of `calculateType`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateTypeParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateTypeParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateTypeParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `calculateTransits`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateTransitsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateTransitsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateTransitsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateTransit`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitResponse {
    /// Birth datetime used for the natal chart, echoed as the local civil date and time supplied in the request (YYYY-MM-DDTHH:MM:SS). Combine it with the timezone field to recover the UTC instant.
    #[serde(rename = "birthDatetime")]
    pub birth_datetime: String,
    /// The zodiac frame every longitude in this response was computed in, so a cached or forwarded payload is self describing. Sidereal requests report the Lahiri ayanamsa, read at the birth instant; the transit positions use the same named frame resolved at their own instant, which moves by about 50 arcseconds a year. A tropical request reports "tropical" with 0 degrees subtracted, which is the one case a Vedic table can otherwise be rendered in the wrong zodiac with nothing on screen saying so.
    pub frame: CalculateTransitResponseFrame,
    /// Highlighted transits from slow-moving planets (Jupiter, Saturn, Rahu, Ketu), most impactful for Gochar analysis.
    #[serde(rename = "keyTransits")]
    pub key_transits: Vec<CalculateTransitResponseKeyTransitsItem>,
    /// All 9 planetary positions from the natal (birth) chart.
    #[serde(rename = "natalPlanets")]
    pub natal_planets: Vec<CalculateTransitResponseNatalPlanetsItem>,
    /// Transit datetime being analyzed, echoed as the local civil date and time supplied in the request (YYYY-MM-DDTHH:MM:SS). Gochar positions are computed for this moment and overlaid on the natal chart.
    #[serde(rename = "transitDatetime")]
    pub transit_datetime: String,
    /// Current planetary positions overlaid on the natal chart with house placements, aspects, and the Gochara Kaksha verdict for each graha.
    #[serde(rename = "transitingPlanets")]
    pub transiting_planets: Vec<CalculateTransitResponseTransitingPlanetsItem>,
}
/// One entry of `transitingPlanets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitResponseTransitingPlanetsItem {
    /// Degree-based angular aspects between this transiting graha and the natal grahas. Western vocabulary, kept for callers who read a chart that way; drishtiToNatal is the Vedic answer to the same question.
    #[serde(rename = "aspectsToNatal")]
    pub aspects_to_natal: Vec<
        CalculateTransitResponseTransitingPlanetsItemAspectsToNatalItem,
    >,
    /// Graha drishti cast by this transiting graha onto the natal grahas, the Vedic reading of transit-to-natal aspects. Rahu and Ketu cast none. Empty when this graha reaches no occupied natal sign.
    #[serde(rename = "drishtiToNatal")]
    pub drishti_to_natal: Vec<
        CalculateTransitResponseTransitingPlanetsItemDrishtiToNatalItem,
    >,
    /// Which house this graha is transiting counted from the natal Moon sign (Janma Rashi), 1-12 whole-sign and counted inclusively, so the Moon sign itself is 1. This is the number classical Gochara is reckoned in: Phaladeepika chapter 26 opens by saying that of all the Lagnas only the Moon Lagna matters for transit results, and the Vedha and Ashtakavarga transit rules are counted from the Moon throughout. The reference sign is the sign of the Moon entry in natalPlanets, so a client can label the column without a second request.
    #[serde(rename = "houseFromMoon")]
    pub house_from_moon: f64,
    /// Gochara Kaksha: the ashtakavarga-qualified reading of this transit. The sign says where a graha is, this says whether the exact stretch it currently occupies is one its own Bhinnashtakavarga supports, which is the classical way of refining a transit verdict from sign-level to under four degrees.
    pub kaksha: CalculateTransitResponseTransitingPlanetsItemKaksha,
    /// Current sidereal longitude of the transiting planet.
    pub longitude: f64,
    /// Transiting planet name.
    pub name: String,
    /// Which natal house (whole-sign bhava counted from the Lagna) this graha is currently transiting through. This is the Lagna reading of the transit, which is what a transit chart drawn over the birth chart shows. For the house classical Gochara is judged from, read houseFromMoon instead.
    #[serde(rename = "natalHouse")]
    pub natal_house: f64,
    /// Current zodiac sign of the transiting planet.
    pub sign: String,
}
/// Gochara Kaksha: the ashtakavarga-qualified reading of this transit. The sign says where a graha is, this says whether the exact stretch it currently occupies is one its own Bhinnashtakavarga supports, which is the classical way of refining a transit verdict from sign-level to under four degrees.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitResponseTransitingPlanetsItemKaksha {
    /// Whether this kaksha lord gave the transiting graha a bindu in the sign being transited, which is the Gochara Kaksha verdict: true reads as a favourable stretch of the transit, false as an unfavourable one. Null means the question does not apply rather than that the answer is no, because Rahu and Ketu have no Bhinnashtakavarga to read. Never render null as unfavourable.
    pub bindu: Option<bool>,
    /// Bindus the transiting graha holds in this whole sign, 0-8, or null for Rahu and Ketu. Context for the verdict, since the same kaksha reads differently in a sign worth 7 than in one worth 1.
    #[serde(rename = "binduCount")]
    pub bindu_count: Option<f64>,
    /// Degree within the sign where this kaksha ends.
    #[serde(rename = "endDegree")]
    pub end_degree: f64,
    /// Graha ruling this kaksha. The eight lords run Saturn, Jupiter, Mars, Sun, Venus, Mercury, Moon, Lagna from the start of every sign, ordered by how long each takes to cross a sign.
    pub lord: String,
    /// Kaksha number 1-8 within the current sign. Each sign divides into eight kakshas of 3 degrees 45 minutes, crossed in order, so this is how far through the sign the graha has travelled.
    pub number: f64,
    /// Degree within the sign where this kaksha begins (0, 3.75, 7.5 and so on).
    #[serde(rename = "startDegree")]
    pub start_degree: f64,
}
/// One entry of `drishtiToNatal`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitResponseTransitingPlanetsItemDrishtiToNatalItem {
    /// Which house the drishti falls on, counted whole-sign and inclusively from the transiting graha. Every graha aspects the 7th; Mars adds the 4th and 8th, Jupiter the 5th and 9th, Saturn the 3rd and 10th. Same vocabulary the /aspects endpoint returns, so the two can be compared directly.
    #[serde(rename = "aspectType")]
    pub aspect_type: CalculateTransitResponseTransitingPlanetsItemDrishtiToNatalItemAspectType,
    /// Natal graha receiving the drishti from this transiting graha.
    #[serde(rename = "natalPlanet")]
    pub natal_planet: String,
    /// Gap between the two degrees-in-sign, in degrees. Graha drishti is whole-sign and does not depend on this, so read it as how exact the sight is inside the pair of rashis rather than as a condition for the aspect.
    pub orb: f64,
    /// Drishti strength as a percentage. Full and special aspects are 100; the partial quarter, half and three-quarter sights are not reported.
    pub strength: f64,
}
string_enum! {
    /// Which house the drishti falls on, counted whole-sign and inclusively from the transiting graha. Every graha aspects the 7th; Mars adds the 4th and 8th, Jupiter the 5th and 9th, Saturn the 3rd and 10th. Same vocabulary the /aspects endpoint returns, so the two can be compared directly.
    CalculateTransitResponseTransitingPlanetsItemDrishtiToNatalItemAspectType {
        Conjunction = "conjunction",
        Variant7th = "7th",
        Variant4th = "4th",
        Variant8th = "8th",
        Variant5th = "5th",
        Variant9th = "9th",
        Variant3rd = "3rd",
        Variant10th = "10th",
    }
}
/// One entry of `aspectsToNatal`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitResponseTransitingPlanetsItemAspectsToNatalItem {
    /// Degree-based angular aspect between the two longitudes: conjunction, opposition, trine, square, or sextile. This is the Western aspect vocabulary and it is offered for charts read that way. Parashari jyotish has no sextile, square or trine, so for the Vedic reading use drishtiToNatal, which reports graha drishti by house count.
    #[serde(rename = "aspectType")]
    pub aspect_type: String,
    /// Natal planet being aspected by this transiting planet.
    #[serde(rename = "natalPlanet")]
    pub natal_planet: String,
    /// Angular distance from exact aspect in degrees. Smaller orb = stronger influence.
    pub orb: f64,
}
/// One entry of `natalPlanets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitResponseNatalPlanetsItem {
    /// Bhava (house) number 1-12, counted whole-sign from the Lagna (house 1 is the Lagna rashi).
    pub house: f64,
    /// Sidereal longitude in degrees (0-360) using Lahiri ayanamsa.
    pub longitude: f64,
    /// Graha name, Sun through Ketu. The Lagna is not one of these entries; it is a house frame rather than a body, and the natal house numbers on every entry are counted from it.
    pub name: String,
    /// Vedic zodiac sign (rashi) the planet occupies in the birth chart.
    pub sign: String,
}
/// One entry of `keyTransits`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitResponseKeyTransitsItem {
    /// Notable degree-based angular aspects to natal planets from this slow-moving transiting planet, in Western vocabulary.
    pub aspects: Vec<String>,
    /// Human-readable transit summary, naming the rashi being transited and both house readings: from the Lagna, then from the natal Moon.
    pub description: String,
    /// Graha drishti this slow-moving transiting graha casts on the natal grahas, the Vedic reading. Empty for Rahu and Ketu, which cast none.
    pub drishti: Vec<String>,
    /// House being transited by this slow graha counted from the natal Moon sign (Janma Rashi), the classical Gochara reference. Mirrors houseFromMoon on the matching transitingPlanets entry.
    #[serde(rename = "houseFromMoon")]
    pub house_from_moon: f64,
    /// Natal house being transited by this slow graha, counted whole-sign from the Lagna. Mirrors natalHouse on the matching transitingPlanets entry.
    #[serde(rename = "natalHouse")]
    pub natal_house: f64,
    /// Slow-moving planet (Jupiter, Saturn, Rahu, Ketu) forming a significant transit.
    pub planet: String,
}
/// The zodiac frame every longitude in this response was computed in, so a cached or forwarded payload is self describing. Sidereal requests report the Lahiri ayanamsa, read at the birth instant; the transit positions use the same named frame resolved at their own instant, which moves by about 50 arcseconds a year. A tropical request reports "tropical" with 0 degrees subtracted, which is the one case a Vedic table can otherwise be rendered in the wrong zodiac with nothing on screen saying so.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitResponseFrame {
    /// Sidereal frame this chart was cast in, echoing the ayanamsa request field. "lahiri" when the field was omitted.
    pub ayanamsa: String,
    /// Degrees actually subtracted from every tropical longitude to produce this chart, read at the birth instant. Subtract it back to recover the tropical positions, or compare it against your reference software to confirm you are in the same frame before chasing a placement difference.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
}
/// Request body of `calculateTransit`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitRequest {
    /// Birth date in YYYY-MM-DD format. Used to calculate the natal chart against which transits are analyzed.
    #[serde(rename = "birthDate")]
    pub birth_date: String,
    /// Birth time in HH:MM:SS format (24-hour). Critical for accurate natal Lagna and Placidus house cusps which determine transit house placements.
    #[serde(rename = "birthTime")]
    pub birth_time: String,
    /// Coordinate system for longitude output. "sidereal" (Nirayana) uses Lahiri ayanamsa, the standard for Vedic astrology. "tropical" (Sayana) uses raw ecliptic longitude matching Western astrology. Defaults to "sidereal".
    #[serde(rename = "coordinateSystem", skip_serializing_if = "Option::is_none")]
    pub coordinate_system: Option<CalculateTransitRequestCoordinateSystem>,
    /// Observer latitude in decimal degrees. Determines Placidus house cusps for natal chart house assignments.
    pub latitude: f64,
    /// Observer longitude in decimal degrees. Affects local sidereal time for Lagna and house calculations.
    pub longitude: f64,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5 (IST).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<CalculateTransitRequestTimezone>,
    /// Transit date to analyze in YYYY-MM-DD format. Planetary positions on this date are overlaid on the natal chart.
    #[serde(rename = "transitDate")]
    pub transit_date: String,
    /// Transit time in HH:MM:SS format (24-hour). Affects fast-moving planets like Moon. Defaults to noon.
    #[serde(rename = "transitTime", skip_serializing_if = "Option::is_none")]
    pub transit_time: Option<String>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5 (IST).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateTransitRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Coordinate system for longitude output. "sidereal" (Nirayana) uses Lahiri ayanamsa, the standard for Vedic astrology. "tropical" (Sayana) uses raw ecliptic longitude matching Western astrology. Defaults to "sidereal".
    CalculateTransitRequestCoordinateSystem {
        Sidereal = "sidereal",
        Tropical = "tropical",
    }
}
/// Response body of `calculateTransitAspects`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitAspectsResponse {
    /// The natal Ascendant (rising sign): the eastern horizon at birth, and the left-hand horizon a chart wheel is oriented to. Reported alongside the cusps because the two are not the same longitude in every house system: Whole Sign puts the first cusp at 0 degrees of the rising sign, which can sit most of a sign away from the Ascendant itself.
    pub ascendant: CalculateTransitAspectsResponseAscendant,
    /// Transit-to-natal aspects with interpretations, strength ratings, and guidance. Each aspect represents a transiting planet forming a geometric angle to a natal planet.
    pub aspects: Vec<CalculateTransitAspectsResponseAspectsItem>,
    /// House system actually used for the natal cusps behind every house number in this response. Differs from the requested system only above the polar circle, where quadrant systems fall back to Whole Sign.
    #[serde(rename = "houseSystem")]
    pub house_system: CalculateTransitAspectsResponseHouseSystem,
    /// The twelve NATAL house cusps that every house number in this response is read against, in the house system named by houseSystem. Same shape as the natal-chart houses array, so a bi-wheel can be drawn with real house sectors from this one response instead of pairing it with a second call.
    pub houses: Vec<CalculateTransitAspectsResponseHousesItem>,
    /// Natal (birth chart) planetary positions used as the baseline for transit aspect comparison, each placed in its natal house.
    #[serde(rename = "natalPlanets")]
    pub natal_planets: Vec<CalculateTransitAspectsResponseNatalPlanetsItem>,
    /// Statistical summary of all transit aspects. The harmonious-to-challenging ratio reveals the overall transit weather, meaning whether the current period favors ease or demands effort.
    pub summary: CalculateTransitAspectsResponseSummary,
    /// Date and time of the transit calculation.
    #[serde(rename = "transitDate")]
    pub transit_date: String,
    /// Current transiting positions in the tropical zodiac, each placed in the natal house it is passing through. All 14 celestial bodies: the 10 classical planets (Sun through Pluto), the lunar nodes, Chiron, and Black Moon Lilith.
    #[serde(rename = "transitPlanets")]
    pub transit_planets: Vec<CalculateTransitAspectsResponseTransitPlanetsItem>,
}
/// One entry of `transitPlanets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitAspectsResponseTransitPlanetsItem {
    /// Degree within the zodiac sign (0-29.999). Indicates how far the planet has progressed through the sign.
    pub degree: f64,
    /// Natal house (1-12) this transiting body is currently passing through, read against the natal house cusps. This is the life area the transit activates, so it is driven by the natal birth time and location rather than by the transit moment.
    pub house: i64,
    /// Whether the planet appears to move backward from Earth perspective. Retrograde periods signal review and introspection.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Apparent geocentric ecliptic latitude of date, in degrees. Near zero for most planets, varies for the Moon and Pluto, and reaches up to about 5 degrees for Black Moon Lilith (projected from the inclined mean lunar orbit).
    pub latitude: f64,
    /// Apparent geocentric tropical longitude on the true ecliptic of date, in degrees (0-360): light time and aberration applied, nutation included, the convention desktop chart software and the NASA JPL Horizons observer tables print, so it compares directly with either. Primary coordinate for zodiac sign and aspect calculations.
    pub longitude: f64,
    /// Body name. One of the 10 classical planets (Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto), the lunar nodes (North Node, South Node), Chiron, or Black Moon Lilith (the mean lunar apogee). The lunar nodes follow the request nodeType, which defaults to the true (osculating) node; pass "mean" for the smoothed node. The two differ by up to about 1.8 degrees and no other body is affected.
    pub name: CalculateTransitAspectsResponseTransitPlanetsItemName,
    /// Body name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tropical zodiac sign this planet occupies. Determined by 30-degree divisions of ecliptic longitude.
    pub sign: String,
    /// Zodiac sign name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
    /// Daily motion in degrees per day. Negative values indicate retrograde motion.
    pub speed: f64,
}
string_enum! {
    /// Body name. One of the 10 classical planets (Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto), the lunar nodes (North Node, South Node), Chiron, or Black Moon Lilith (the mean lunar apogee). The lunar nodes follow the request nodeType, which defaults to the true (osculating) node; pass "mean" for the smoothed node. The two differ by up to about 1.8 degrees and no other body is affected.
    CalculateTransitAspectsResponseTransitPlanetsItemName {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
/// Statistical summary of all transit aspects. The harmonious-to-challenging ratio reveals the overall transit weather, meaning whether the current period favors ease or demands effort.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitAspectsResponseSummary {
    /// Transit aspect counts grouped by aspect type (conjunction, trine, square, opposition, sextile, etc.). Useful for quickly assessing the transit weather.
    #[serde(rename = "byType")]
    pub by_type: CalculateTransitAspectsResponseSummaryByType,
    /// Count of challenging aspects (square, opposition, semi-square, sesquiquadrate). These transits bring tension, growth pressure, and action.
    pub challenging: f64,
    /// Count of harmonious aspects (trine, sextile). These transits bring ease, flow, and opportunity.
    pub harmonious: f64,
    /// Count of neutral aspects (conjunction, minor aspects). Conjunctions blend energies, so the outcome depends on the planets involved.
    pub neutral: f64,
    /// The tightest aspect by orb. This is the most potent transit currently active, and the one most likely to be felt.
    pub strongest: Option<CalculateTransitAspectsResponseSummaryStrongest>,
    /// Total number of transit-to-natal aspects found.
    pub total: f64,
}
/// The tightest aspect by orb. This is the most potent transit currently active, and the one most likely to be felt.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitAspectsResponseSummaryStrongest {
    /// Exact angular separation that defines this aspect type in degrees.
    pub angle: f64,
    /// Aspect nature. Harmonious (trine, sextile) flows easily. Challenging (square, opposition) creates tension and growth. Neutral (conjunction) blends energies. Always English, whatever the lang parameter says: it is an identifier consumers switch and style on. Use interpretationLocalized for anything a reader sees.
    pub interpretation: CalculateTransitAspectsResponseSummaryStrongestInterpretation,
    /// Whether the aspect is applying (planets moving toward exact) or separating (moving apart). Applying aspects grow stronger.
    #[serde(rename = "isApplying")]
    pub is_applying: bool,
    /// Deviation from exact aspect in degrees. Tighter orb means stronger influence.
    pub orb: f64,
    /// First planet in the aspect pair.
    pub planet1: CalculateTransitAspectsResponseSummaryStrongestPlanet1,
    /// First planet name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "planet1Localized", skip_serializing_if = "Option::is_none")]
    pub planet1_localized: Option<String>,
    /// Second planet in the aspect pair.
    pub planet2: CalculateTransitAspectsResponseSummaryStrongestPlanet2,
    /// Second planet name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "planet2Localized", skip_serializing_if = "Option::is_none")]
    pub planet2_localized: Option<String>,
    /// Aspect strength percentage (0-100). Based on orb tightness relative to the allowed maximum.
    pub strength: f64,
    /// Rich interpretation of the transit aspect: narrative summary, timing, impact assessment, practical guidance, and keywords.
    #[serde(rename = "transitInterpretation")]
    pub transit_interpretation: CalculateTransitAspectsResponseSummaryStrongestTransitInterpretation,
    /// Aspect type. Major: conjunction (0), opposition (180), trine (120), square (90), sextile (60). Minor: semi-sextile, quincunx, semi-square, sesquiquadrate.
    pub r#type: CalculateTransitAspectsResponseSummaryStrongestType,
    /// Aspect type name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "typeLocalized", skip_serializing_if = "Option::is_none")]
    pub type_localized: Option<String>,
}
string_enum! {
    /// Aspect type. Major: conjunction (0), opposition (180), trine (120), square (90), sextile (60). Minor: semi-sextile, quincunx, semi-square, sesquiquadrate.
    CalculateTransitAspectsResponseSummaryStrongestType {
        Conjunction = "CONJUNCTION",
        Opposition = "OPPOSITION",
        Trine = "TRINE",
        Square = "SQUARE",
        Sextile = "SEXTILE",
        SemiSextile = "SEMI_SEXTILE",
        Quincunx = "QUINCUNX",
        SemiSquare = "SEMI_SQUARE",
        Sesquiquadrate = "SESQUIQUADRATE",
    }
}
/// Rich interpretation of the transit aspect: narrative summary, timing, impact assessment, practical guidance, and keywords.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitAspectsResponseSummaryStrongestTransitInterpretation {
    /// Practical advice for working with this transit energy.
    pub guidance: String,
    /// Strength and nature of this transit effect: constructive, challenging, or neutral.
    pub impact: String,
    /// Key themes activated by this transit aspect.
    pub keywords: Vec<String>,
    /// Narrative interpretation of this transit aspect and its life impact.
    pub summary: String,
    /// When this transit is most active and how long its influence lasts, localized. The bucket follows the speed of the transiting body: a few hours for the Moon, a few days for the Sun, Mercury, Venus and Mars, one to two weeks for Jupiter, several weeks for Saturn, and an extended period for Uranus, Neptune and Pluto.
    pub timing: String,
}
string_enum! {
    /// Second planet in the aspect pair.
    CalculateTransitAspectsResponseSummaryStrongestPlanet2 {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
string_enum! {
    /// First planet in the aspect pair.
    CalculateTransitAspectsResponseSummaryStrongestPlanet1 {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
string_enum! {
    /// Aspect nature. Harmonious (trine, sextile) flows easily. Challenging (square, opposition) creates tension and growth. Neutral (conjunction) blends energies. Always English, whatever the lang parameter says: it is an identifier consumers switch and style on. Use interpretationLocalized for anything a reader sees.
    CalculateTransitAspectsResponseSummaryStrongestInterpretation {
        Harmonious = "harmonious",
        Challenging = "challenging",
        Neutral = "neutral",
    }
}
/// Transit aspect counts grouped by aspect type (conjunction, trine, square, opposition, sextile, etc.). Useful for quickly assessing the transit weather.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitAspectsResponseSummaryByType {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, f64>,
}
/// One entry of `natalPlanets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitAspectsResponseNatalPlanetsItem {
    /// Degree within the zodiac sign (0-29.999). Indicates how far the planet has progressed through the sign.
    pub degree: f64,
    /// House placement (1-12). Determined by the selected house system and birth location.
    pub house: i64,
    /// Whether the planet appears to move backward from Earth perspective. Retrograde periods signal review and introspection.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Apparent geocentric ecliptic latitude of date, in degrees. Near zero for most planets, varies for the Moon and Pluto, and reaches up to about 5 degrees for Black Moon Lilith (projected from the inclined mean lunar orbit).
    pub latitude: f64,
    /// Apparent geocentric tropical longitude on the true ecliptic of date, in degrees (0-360): light time and aberration applied, nutation included, the convention desktop chart software and the NASA JPL Horizons observer tables print, so it compares directly with either. Primary coordinate for zodiac sign and aspect calculations.
    pub longitude: f64,
    /// Body name. One of the 10 classical planets (Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto), the lunar nodes (North Node, South Node), Chiron, or Black Moon Lilith (the mean lunar apogee). The lunar nodes follow the request nodeType, which defaults to the true (osculating) node; pass "mean" for the smoothed node. The two differ by up to about 1.8 degrees and no other body is affected.
    pub name: CalculateTransitAspectsResponseNatalPlanetsItemName,
    /// Body name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tropical zodiac sign this planet occupies. Determined by 30-degree divisions of ecliptic longitude.
    pub sign: String,
    /// Zodiac sign name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
    /// Daily motion in degrees per day. Negative values indicate retrograde motion.
    pub speed: f64,
}
string_enum! {
    /// Body name. One of the 10 classical planets (Sun, Moon, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto), the lunar nodes (North Node, South Node), Chiron, or Black Moon Lilith (the mean lunar apogee). The lunar nodes follow the request nodeType, which defaults to the true (osculating) node; pass "mean" for the smoothed node. The two differ by up to about 1.8 degrees and no other body is affected.
    CalculateTransitAspectsResponseNatalPlanetsItemName {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
/// One entry of `houses`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitAspectsResponseHousesItem {
    /// Degree within the zodiac sign on this cusp (0-29.999).
    pub degree: f64,
    /// Ecliptic longitude of this house cusp in degrees (0-360).
    pub longitude: f64,
    /// House number (1-12). Each house governs specific life themes in Western astrology.
    pub number: i64,
    /// Zodiac sign on this house cusp. Colors the themes of this life area.
    pub sign: String,
    /// Zodiac sign name on this cusp in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
}
string_enum! {
    /// House system actually used for the natal cusps behind every house number in this response. Differs from the requested system only above the polar circle, where quadrant systems fall back to Whole Sign.
    CalculateTransitAspectsResponseHouseSystem {
        Placidus = "placidus",
        WholeSign = "whole-sign",
        Equal = "equal",
        Koch = "koch",
    }
}
/// One entry of `aspects`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitAspectsResponseAspectsItem {
    /// Exact angular separation that defines this aspect type in degrees.
    pub angle: f64,
    /// Aspect nature. Harmonious (trine, sextile) flows easily. Challenging (square, opposition) creates tension and growth. Neutral (conjunction) blends energies. Always English, whatever the lang parameter says: it is an identifier consumers switch and style on. Use interpretationLocalized for anything a reader sees.
    pub interpretation: CalculateTransitAspectsResponseAspectsItemInterpretation,
    /// Whether the aspect is applying (planets moving toward exact) or separating (moving apart). Applying aspects grow stronger.
    #[serde(rename = "isApplying")]
    pub is_applying: bool,
    /// Deviation from exact aspect in degrees. Tighter orb means stronger influence.
    pub orb: f64,
    /// First planet in the aspect pair.
    pub planet1: CalculateTransitAspectsResponseAspectsItemPlanet1,
    /// First planet name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "planet1Localized", skip_serializing_if = "Option::is_none")]
    pub planet1_localized: Option<String>,
    /// Second planet in the aspect pair.
    pub planet2: CalculateTransitAspectsResponseAspectsItemPlanet2,
    /// Second planet name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "planet2Localized", skip_serializing_if = "Option::is_none")]
    pub planet2_localized: Option<String>,
    /// Aspect strength percentage (0-100). Based on orb tightness relative to the allowed maximum.
    pub strength: f64,
    /// Rich interpretation of the transit aspect: narrative summary, timing, impact assessment, practical guidance, and keywords.
    #[serde(rename = "transitInterpretation")]
    pub transit_interpretation: CalculateTransitAspectsResponseAspectsItemTransitInterpretation,
    /// Aspect type. Major: conjunction (0), opposition (180), trine (120), square (90), sextile (60). Minor: semi-sextile, quincunx, semi-square, sesquiquadrate.
    pub r#type: CalculateTransitAspectsResponseAspectsItemType,
    /// Aspect type name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "typeLocalized", skip_serializing_if = "Option::is_none")]
    pub type_localized: Option<String>,
}
string_enum! {
    /// Aspect type. Major: conjunction (0), opposition (180), trine (120), square (90), sextile (60). Minor: semi-sextile, quincunx, semi-square, sesquiquadrate.
    CalculateTransitAspectsResponseAspectsItemType {
        Conjunction = "CONJUNCTION",
        Opposition = "OPPOSITION",
        Trine = "TRINE",
        Square = "SQUARE",
        Sextile = "SEXTILE",
        SemiSextile = "SEMI_SEXTILE",
        Quincunx = "QUINCUNX",
        SemiSquare = "SEMI_SQUARE",
        Sesquiquadrate = "SESQUIQUADRATE",
    }
}
/// Rich interpretation of the transit aspect: narrative summary, timing, impact assessment, practical guidance, and keywords.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitAspectsResponseAspectsItemTransitInterpretation {
    /// Practical advice for working with this transit energy.
    pub guidance: String,
    /// Strength and nature of this transit effect: constructive, challenging, or neutral.
    pub impact: String,
    /// Key themes activated by this transit aspect.
    pub keywords: Vec<String>,
    /// Narrative interpretation of this transit aspect and its life impact.
    pub summary: String,
    /// When this transit is most active and how long its influence lasts, localized. The bucket follows the speed of the transiting body: a few hours for the Moon, a few days for the Sun, Mercury, Venus and Mars, one to two weeks for Jupiter, several weeks for Saturn, and an extended period for Uranus, Neptune and Pluto.
    pub timing: String,
}
string_enum! {
    /// Second planet in the aspect pair.
    CalculateTransitAspectsResponseAspectsItemPlanet2 {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
string_enum! {
    /// First planet in the aspect pair.
    CalculateTransitAspectsResponseAspectsItemPlanet1 {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
string_enum! {
    /// Aspect nature. Harmonious (trine, sextile) flows easily. Challenging (square, opposition) creates tension and growth. Neutral (conjunction) blends energies. Always English, whatever the lang parameter says: it is an identifier consumers switch and style on. Use interpretationLocalized for anything a reader sees.
    CalculateTransitAspectsResponseAspectsItemInterpretation {
        Harmonious = "harmonious",
        Challenging = "challenging",
        Neutral = "neutral",
    }
}
/// The natal Ascendant (rising sign): the eastern horizon at birth, and the left-hand horizon a chart wheel is oriented to. Reported alongside the cusps because the two are not the same longitude in every house system: Whole Sign puts the first cusp at 0 degrees of the rising sign, which can sit most of a sign away from the Ascendant itself.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitAspectsResponseAscendant {
    /// Degree within the Ascendant sign (0-29.999).
    pub degree: f64,
    /// Absolute ecliptic longitude of the natal Ascendant in degrees (0-360).
    pub longitude: f64,
    /// Tropical zodiac sign on the natal Ascendant. Always English, whatever the lang parameter says. Use signLocalized for anything a reader sees.
    pub sign: String,
    /// Ascendant sign name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
}
/// Request body of `calculateTransitAspects`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitAspectsRequest {
    /// Filter to specific aspect types (conjunction, opposition, trine, square, sextile, etc.). Omit to include all aspect types.
    #[serde(rename = "aspectTypes", skip_serializing_if = "Option::is_none")]
    pub aspect_types: Option<Vec<CalculateTransitAspectsRequestAspectTypesItem>>,
    /// House system used to divide the natal chart into 12 houses. Every house number in the response is read against these natal cusps, for the natal bodies and the transiting bodies alike. Placidus (default) is time sensitive and the most widely used in Western astrology. Whole Sign assigns one sign per house. Equal divides into 30 degree segments from the Ascendant. Koch emphasizes higher latitudes. Quadrant systems fall back to Whole Sign above the polar circle.
    #[serde(rename = "houseSystem", skip_serializing_if = "Option::is_none")]
    pub house_system: Option<CalculateTransitAspectsRequestHouseSystem>,
    /// Minimum aspect strength threshold (0-100). Higher values return only tighter, more potent aspects. Useful for filtering out wide-orb aspects.
    #[serde(rename = "minStrength", skip_serializing_if = "Option::is_none")]
    pub min_strength: Option<f64>,
    /// Natal chart birth details (date, time, location, timezone). Used to calculate natal planetary positions that transits are compared against.
    #[serde(rename = "natalChart")]
    pub natal_chart: CalculateTransitAspectsRequestNatalChart,
    /// Filter to specific transiting planets. Omit to include all planets. Useful for focusing on slow-moving outer planet transits (Saturn, Jupiter, Pluto).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub planets: Option<Vec<CalculateTransitAspectsRequestPlanetsItem>>,
    /// Transit date in YYYY-MM-DD format. Defaults to current date if omitted. Use future dates for predictive transit analysis.
    #[serde(rename = "transitDate", skip_serializing_if = "Option::is_none")]
    pub transit_date: Option<String>,
    /// Transit time in HH:MM:SS format, read on the clock of the natal chart timezone at the transit date (an IANA zone takes the offset in force on that date, daylight saving included). Defaults to 12:00:00 (noon) if omitted.
    #[serde(rename = "transitTime", skip_serializing_if = "Option::is_none")]
    pub transit_time: Option<String>,
}
string_enum! {
    /// One entry of `planets`.
    CalculateTransitAspectsRequestPlanetsItem {
        Sun = "Sun",
        Moon = "Moon",
        Mercury = "Mercury",
        Venus = "Venus",
        Mars = "Mars",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
        NorthNode = "North Node",
        SouthNode = "South Node",
        Chiron = "Chiron",
        BlackMoonLilith = "Black Moon Lilith",
    }
}
/// Natal chart birth details (date, time, location, timezone). Used to calculate natal planetary positions that transits are compared against.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTransitAspectsRequestNatalChart {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<CalculateTransitAspectsRequestNatalChartNodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
    pub timezone: CalculateTransitAspectsRequestNatalChartTimezone,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateTransitAspectsRequestNatalChartTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    CalculateTransitAspectsRequestNatalChartNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// House system used to divide the natal chart into 12 houses. Every house number in the response is read against these natal cusps, for the natal bodies and the transiting bodies alike. Placidus (default) is time sensitive and the most widely used in Western astrology. Whole Sign assigns one sign per house. Equal divides into 30 degree segments from the Ascendant. Koch emphasizes higher latitudes. Quadrant systems fall back to Whole Sign above the polar circle.
    CalculateTransitAspectsRequestHouseSystem {
        Placidus = "placidus",
        WholeSign = "whole-sign",
        Equal = "equal",
        Koch = "koch",
    }
}
string_enum! {
    /// One entry of `aspectTypes`.
    CalculateTransitAspectsRequestAspectTypesItem {
        Conjunction = "CONJUNCTION",
        Opposition = "OPPOSITION",
        Trine = "TRINE",
        Square = "SQUARE",
        Sextile = "SEXTILE",
        SemiSextile = "SEMI_SEXTILE",
        Quincunx = "QUINCUNX",
        SemiSquare = "SEMI_SQUARE",
        Sesquiquadrate = "SESQUIQUADRATE",
    }
}
/// Path and query parameters of `calculateTransitAspects`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateTransitAspectsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateTransitAspectsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateTransitAspectsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateTonalpohualli`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTonalpohualliResponse {
    /// The conventions this answer was computed under, echoed so the result is self describing.
    pub conventions: CalculateTonalpohualliResponseConventions,
    /// Echo of the date the day was resolved from, in proleptic Gregorian.
    pub date: String,
    /// Machine identifier of the tonalpohualli day sign, always lowercase ASCII Nahuatl whatever the lang parameter says, so it stays safe to compare against in code. The twenty ids run cipactli, ehecatl, calli, cuetzpalin, coatl, miquiztli, mazatl, tochtli, atl, itzcuintli, ozomahtli, malinalli, acatl, ocelotl, cuauhtli, cozcacuauhtli, ollin, tecpatl, quiahuitl, xochitl.
    #[serde(rename = "daySign")]
    pub day_sign: String,
    /// Display name in Nahuatl with the vowel length marks the reference tables print. A proper noun carried as data, so it is identical under every lang.
    #[serde(rename = "daySignName")]
    pub day_sign_name: String,
    /// World direction the sign belongs to: east, north, west or south. The twenty run through the four quarters in order, so the direction is a property of the position as much as of the sign.
    pub direction: String,
    /// What the sign name means, translated in place because it is a common noun. Several English renderings are in circulation for some signs and all of them are given rather than one being picked.
    pub gloss: String,
    /// The one thing worth doing differently under this sign.
    pub guidance: String,
    /// The sign in one composed sentence. Composed per request from the sign components rather than stored whole.
    pub keynote: String,
    /// The tonalpohualli coefficient, 1 to 13. Structurally the same count as the Maya coefficient and read the same way: a rank it is not.
    pub number: f64,
    /// A plain statement of what this family covers and what it deliberately leaves out. Present on every response so nobody has to guess whether a missing field is an outage or a decision.
    pub scope: String,
    /// The thirteen day period this day belongs to, named by the sign it opens on. No patron deity is returned: the published patron column carries an unresolved disagreement on two of the twenty rows, and a column that is right for eighteen and guessed for two is worse than none.
    pub trecena: CalculateTonalpohualliResponseTrecena,
}
/// The thirteen day period this day belongs to, named by the sign it opens on. No patron deity is returned: the published patron column carries an unresolved disagreement on two of the twenty rows, and a column that is right for eighteen and guessed for two is worse than none.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTonalpohualliResponseTrecena {
    /// Position of this day inside its trecena, 1 to 13. Always equal to the coefficient.
    #[serde(rename = "dayOfTrecena")]
    pub day_of_trecena: f64,
    /// Which of the twenty thirteen day periods this day falls in, 1 to 20.
    pub number: f64,
    /// Machine identifier of the day sign the trecena opens on.
    #[serde(rename = "startSign")]
    pub start_sign: String,
    /// Display name of the sign the trecena opens on. A proper noun carried as data.
    #[serde(rename = "startSignName")]
    pub start_sign_name: String,
}
/// The conventions this answer was computed under, echoed so the result is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTonalpohualliResponseConventions {
    /// The correlation this count runs on, anchored on the recorded day 1 Coatl at the fall of Tenochtitlan, 13 August 1521 in the Julian calendar and 23 August 1521 in the proleptic Gregorian calendar this API takes. It is echoed rather than requested because it is not a switch: the anchor is a civil date, so no correlation constant enters the arithmetic, and the published alternatives for this calendar move the solar year alignment rather than the day count. The count was verified to run in step with the Maya count under the default constant, on the anchor and on two modern dates.
    pub correlation: String,
}
/// Path and query parameters of `calculateTonalpohualli`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateTonalpohualliParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateTonalpohualliParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateTonalpohualliParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateSynastry`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateSynastryResponse {
    /// Relationship analysis with strengths, challenges, and overall assessment.
    pub analysis: CalculateSynastryResponseAnalysis,
    /// Overall compatibility score (0-100). Calculated from the balance of harmonious vs challenging inter-chart aspects weighted by planet importance.
    #[serde(rename = "compatibilityScore")]
    pub compatibility_score: f64,
    /// All inter-chart (synastry) aspects between person 1 and person 2 planets. Each aspect reveals a specific dynamic in the relationship.
    #[serde(rename = "interAspects")]
    pub inter_aspects: Vec<CalculateSynastryResponseInterAspectsItem>,
    /// Person 1 chart highlights: Ascendant, Sun sign, Moon sign, and plotting positions.
    pub person1: CalculateSynastryResponsePerson1,
    /// Person 2 chart highlights: Ascendant, Sun sign, Moon sign, and plotting positions.
    pub person2: CalculateSynastryResponsePerson2,
    /// Synastry aspect summary showing the balance of harmonious vs challenging inter-chart connections.
    pub summary: CalculateSynastryResponseSummary,
}
/// Synastry aspect summary showing the balance of harmonious vs challenging inter-chart connections.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateSynastryResponseSummary {
    /// Aspect count grouped by type. Shows which aspect patterns dominate the relationship.
    #[serde(rename = "byType")]
    pub by_type: CalculateSynastryResponseSummaryByType,
    /// Count of challenging aspects (square, opposition). Dynamic tension and growth.
    pub challenging: f64,
    /// Count of harmonious aspects (trine, sextile). Natural ease and flow.
    pub harmonious: f64,
    /// Count of neutral aspects (conjunction). Outcome depends on planets involved.
    pub neutral: f64,
    /// Total number of inter-chart aspects found.
    pub total: f64,
}
/// Aspect count grouped by type. Shows which aspect patterns dominate the relationship.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateSynastryResponseSummaryByType {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, f64>,
}
/// Person 2 chart highlights: Ascendant, Sun sign, Moon sign, and plotting positions.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateSynastryResponsePerson2 {
    /// Ascendant position for person 2. Determines first house cusp and outward personality.
    pub ascendant: CalculateSynastryResponsePerson2Ascendant,
    /// Moon sign of this person. Emotional nature and inner needs. Always English, whatever the lang parameter says. Use moonSignLocalized for anything a reader sees.
    #[serde(rename = "moonSign")]
    pub moon_sign: String,
    /// Moon sign name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "moonSignLocalized", skip_serializing_if = "Option::is_none")]
    pub moon_sign_localized: Option<String>,
    /// Display name if provided in the request.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Planet positions for person 2, enough to render this side of a dual wheel without a second request. Per-planet interpretations are not repeated here; call the natal chart endpoint for an individual reading.
    pub planets: Vec<CalculateSynastryResponsePerson2PlanetsItem>,
    /// Sun sign (zodiac sign) of this person. Core identity and ego expression. Always English, whatever the lang parameter says. Use sunSignLocalized for anything a reader sees.
    #[serde(rename = "sunSign")]
    pub sun_sign: String,
    /// Sun sign name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "sunSignLocalized", skip_serializing_if = "Option::is_none")]
    pub sun_sign_localized: Option<String>,
}
/// One entry of `planets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateSynastryResponsePerson2PlanetsItem {
    /// Degree within the sign (0-29.999).
    pub degree: f64,
    /// House this planet occupies in the person 2 chart (1-12). This is the placement in this person OWN chart. For the house overlay a synastry reading is built on, read houseInOtherChart.
    pub house: f64,
    /// Which of person 1 houses this planet of person 2 falls into (1-12), counted on that person cusps in the same house system. This is the house OVERLAY, the half of synastry the inter-aspects do not cover: an aspect says two bodies are in relationship, an overlay says which area of the other person life this body lands in. Both people get their own overlay, so person 1 planets carry the reverse reading.
    #[serde(rename = "houseInOtherChart")]
    pub house_in_other_chart: f64,
    /// True when the planet is retrograde at this moment.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Ecliptic longitude in degrees (0-360) measured from 0 Aries. This is the value a wheel plots.
    pub longitude: f64,
    /// Planet or point name. Matches the names used in interAspects. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Planet or point name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Zodiac sign containing the planet. Always English, whatever the lang parameter says. Use signLocalized for anything a reader sees.
    pub sign: String,
    /// Zodiac sign name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
}
/// Ascendant position for person 2. Determines first house cusp and outward personality.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateSynastryResponsePerson2Ascendant {
    /// Degree within the Ascendant sign (0-29.999).
    pub degree: f64,
    /// Ascendant (rising sign) of this person. Always English, whatever the lang parameter says. Use signLocalized for anything a reader sees.
    pub sign: String,
    /// Ascendant sign name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
}
/// Person 1 chart highlights: Ascendant, Sun sign, Moon sign, and plotting positions.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateSynastryResponsePerson1 {
    /// Ascendant position for person 1. Determines first house cusp and outward personality.
    pub ascendant: CalculateSynastryResponsePerson1Ascendant,
    /// Moon sign of this person. Emotional nature and inner needs. Always English, whatever the lang parameter says. Use moonSignLocalized for anything a reader sees.
    #[serde(rename = "moonSign")]
    pub moon_sign: String,
    /// Moon sign name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "moonSignLocalized", skip_serializing_if = "Option::is_none")]
    pub moon_sign_localized: Option<String>,
    /// Display name if provided in the request.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Planet positions for person 1, enough to render this side of a dual wheel without a second request. Per-planet interpretations are not repeated here; call the natal chart endpoint for an individual reading.
    pub planets: Vec<CalculateSynastryResponsePerson1PlanetsItem>,
    /// Sun sign (zodiac sign) of this person. Core identity and ego expression. Always English, whatever the lang parameter says. Use sunSignLocalized for anything a reader sees.
    #[serde(rename = "sunSign")]
    pub sun_sign: String,
    /// Sun sign name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "sunSignLocalized", skip_serializing_if = "Option::is_none")]
    pub sun_sign_localized: Option<String>,
}
/// One entry of `planets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateSynastryResponsePerson1PlanetsItem {
    /// Degree within the sign (0-29.999).
    pub degree: f64,
    /// House this planet occupies in the person 1 chart (1-12). This is the placement in this person OWN chart. For the house overlay a synastry reading is built on, read houseInOtherChart.
    pub house: f64,
    /// Which of person 2 houses this planet of person 1 falls into (1-12), counted on that person cusps in the same house system. This is the house OVERLAY, the half of synastry the inter-aspects do not cover: an aspect says two bodies are in relationship, an overlay says which area of the other person life this body lands in. Both people get their own overlay, so person 2 planets carry the reverse reading.
    #[serde(rename = "houseInOtherChart")]
    pub house_in_other_chart: f64,
    /// True when the planet is retrograde at this moment.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Ecliptic longitude in degrees (0-360) measured from 0 Aries. This is the value a wheel plots.
    pub longitude: f64,
    /// Planet or point name. Matches the names used in interAspects. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Planet or point name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Zodiac sign containing the planet. Always English, whatever the lang parameter says. Use signLocalized for anything a reader sees.
    pub sign: String,
    /// Zodiac sign name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
}
/// Ascendant position for person 1. Determines first house cusp and outward personality.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateSynastryResponsePerson1Ascendant {
    /// Degree within the Ascendant sign (0-29.999).
    pub degree: f64,
    /// Ascendant (rising sign) of this person. Always English, whatever the lang parameter says. Use signLocalized for anything a reader sees.
    pub sign: String,
    /// Ascendant sign name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signLocalized", skip_serializing_if = "Option::is_none")]
    pub sign_localized: Option<String>,
}
/// One entry of `interAspects`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateSynastryResponseInterAspectsItem {
    /// Exact angle of this aspect type in degrees.
    pub angle: f64,
    /// Aspect nature: harmonious, challenging, or neutral.
    pub interpretation: String,
    /// Aspect meaning with relationship-specific context for this planet pair.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub meaning: Option<CalculateSynastryResponseInterAspectsItemMeaning>,
    /// Distance from exact aspect in degrees. Tighter orb means stronger influence.
    pub orb: f64,
    /// Planet from person 1 chart. Always English, whatever the lang parameter says. Use planet1Localized for anything a reader sees.
    pub planet1: String,
    /// Person 1 planet name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "planet1Localized", skip_serializing_if = "Option::is_none")]
    pub planet1_localized: Option<String>,
    /// Planet from person 2 chart. Always English, whatever the lang parameter says. Use planet2Localized for anything a reader sees.
    pub planet2: String,
    /// Person 2 planet name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "planet2Localized", skip_serializing_if = "Option::is_none")]
    pub planet2_localized: Option<String>,
    /// Aspect strength percentage (0-100) based on orb tightness.
    pub strength: f64,
    /// Aspect type (CONJUNCTION, OPPOSITION, TRINE, SQUARE, SEXTILE, etc.). Always English, whatever the lang parameter says. Use typeLocalized for anything a reader sees.
    pub r#type: String,
    /// Aspect type name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "typeLocalized", skip_serializing_if = "Option::is_none")]
    pub type_localized: Option<String>,
}
/// Aspect meaning with relationship-specific context for this planet pair.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateSynastryResponseInterAspectsItemMeaning {
    /// Aspect meaning in short and long form.
    pub description: CalculateSynastryResponseInterAspectsItemMeaningDescription,
    /// Keywords associated with this aspect type.
    pub keywords: Vec<String>,
    /// Aspect display name.
    pub name: String,
    /// How this aspect type is characterised in its reference card, in the requested language, exactly like the name, description and keywords beside it. Branch on the aspect-level interpretation field instead, which is always English.
    pub nature: String,
    /// How this specific planetary pair aspect manifests in relationships.
    #[serde(rename = "relationshipContext")]
    pub relationship_context: String,
}
/// Aspect meaning in short and long form.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateSynastryResponseInterAspectsItemMeaningDescription {
    /// Detailed aspect description.
    pub long: String,
    /// Brief aspect description.
    pub short: String,
}
/// Relationship analysis with strengths, challenges, and overall assessment.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateSynastryResponseAnalysis {
    /// Potential friction points and growth opportunities from challenging aspects.
    pub challenges: Vec<String>,
    /// Overall relationship analysis narrative based on aspect patterns.
    pub overall: String,
    /// Areas where the relationship naturally thrives based on harmonious aspects.
    pub strengths: Vec<String>,
}
/// Request body of `calculateSynastry`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateSynastryRequest {
    /// House system for both natal charts. Placidus (default), Whole Sign, Equal, or Koch.
    #[serde(rename = "houseSystem", skip_serializing_if = "Option::is_none")]
    pub house_system: Option<CalculateSynastryRequestHouseSystem>,
    /// The `person1` field.
    pub person1: CalculateSynastryRequestPerson1,
    /// The `person2` field.
    pub person2: CalculateSynastryRequestPerson2,
}
/// The `person2` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateSynastryRequestPerson2 {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Optional display name for this person. Included in the response for easy identification.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<CalculateSynastryRequestPerson2NodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
    pub timezone: CalculateSynastryRequestPerson2Timezone,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateSynastryRequestPerson2Timezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    CalculateSynastryRequestPerson2NodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// The `person1` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateSynastryRequestPerson1 {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Optional display name for this person. Included in the response for easy identification.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<CalculateSynastryRequestPerson1NodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
    pub timezone: CalculateSynastryRequestPerson1Timezone,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateSynastryRequestPerson1Timezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    CalculateSynastryRequestPerson1NodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// House system for both natal charts. Placidus (default), Whole Sign, Equal, or Koch.
    CalculateSynastryRequestHouseSystem {
        Placidus = "placidus",
        WholeSign = "whole-sign",
        Equal = "equal",
        Koch = "koch",
    }
}
/// Path and query parameters of `calculateSynastry`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateSynastryParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateSynastryParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateSynastryParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateSoulUrge`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateSoulUrgeResponse {
    /// Every vowel (A, E, I, O, U) of the birth name with its value, grouped by name: each name is summed and reduced, then the names are added and reduced to the final Soul Urge number.
    pub calculation: String,
    /// Indicates whether a Karmic Debt number (13, 14, 16, or 19) appeared during the vowel reduction chain. Karmic Debt in the Soul Urge reveals past-life emotional patterns and unresolved inner desires carried into this lifetime.
    #[serde(rename = "hasKarmicDebt")]
    pub has_karmic_debt: bool,
    /// Detailed interpretation of the Karmic Debt number when present. Only returned when hasKarmicDebt is true.
    #[serde(rename = "karmicDebtMeaning", skip_serializing_if = "Option::is_none")]
    pub karmic_debt_meaning: Option<CalculateSoulUrgeResponseKarmicDebtMeaning>,
    /// The specific Karmic Debt number detected during the vowel reduction, if any. Each debt number (13, 14, 16, 19) represents a distinct past-life emotional lesson that influences your deepest desires and motivations.
    #[serde(rename = "karmicDebtNumber", skip_serializing_if = "Option::is_none")]
    pub karmic_debt_number: Option<f64>,
    /// The `meaning` field.
    pub meaning: CalculateSoulUrgeResponseMeaning,
    /// Your Soul Urge number (also called Heart Desire number), revealing your innermost motivations and what your soul truly craves. Values range from 1 to 9 for single digits, or 11, 22, 33 for Master Numbers.
    pub number: f64,
    /// Whether this is a standard single-digit number (1 to 9) or a Master Number (11, 22, 33). Master Numbers in the Soul Urge position indicate a soul with amplified spiritual longing and heightened inner sensitivity.
    pub r#type: CalculateSoulUrgeResponseType,
}
string_enum! {
    /// Whether this is a standard single-digit number (1 to 9) or a Master Number (11, 22, 33). Master Numbers in the Soul Urge position indicate a soul with amplified spiritual longing and heightened inner sensitivity.
    CalculateSoulUrgeResponseType {
        Single = "single",
        Master = "master",
    }
}
/// The `meaning` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateSoulUrgeResponseMeaning {
    /// Career paths that satisfy your deepest emotional needs. Focuses on work that feeds the soul rather than just the resume, aligned with inner fulfillment.
    pub career: String,
    /// Inner shadows and emotional patterns to balance. Explains how each challenge manifests when the Soul Urge energy is overextended or repressed.
    pub challenges: Vec<String>,
    /// Core interpretation of the inner self, hidden desires and emotional landscape. Together with the strengths, challenges, career, relationships and spirituality fields it makes a full reading.
    pub description: String,
    /// Core emotional drives and inner motivations for this Soul Urge. Useful for understanding hidden desires, emotional needs, and what truly fulfills someone at the deepest level.
    pub keywords: Vec<String>,
    /// How your Soul Urge shapes what you need from love, friendship, and family. Covers emotional compatibility, attachment style, and the key to feeling truly seen.
    pub relationships: String,
    /// The spiritual hunger at your core. Explores what your soul is seeking in this lifetime and the practices that bring you closest to inner peace and alignment.
    pub spirituality: String,
    /// Emotional superpowers and inner gifts. Each strength describes how it shapes decision-making, relationships, and the pursuit of personal fulfillment.
    pub strengths: Vec<String>,
    /// Numerology archetype for this Soul Urge number. Reveals the deepest inner motivation, such as "The Seeker" for 7 or "The Master Teacher" for 33.
    pub title: String,
}
/// Detailed interpretation of the Karmic Debt number when present. Only returned when hasKarmicDebt is true.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateSoulUrgeResponseKarmicDebtMeaning {
    /// The specific challenge from past lives that must be confronted.
    pub challenge: String,
    /// Title describing the karmic debt theme and core past-life pattern.
    pub description: String,
    /// Practical guidance for resolving the karmic debt.
    pub resolution: String,
}
/// Path and query parameters of `calculateSoulUrge`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateSoulUrgeParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateSoulUrgeParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateSoulUrgeParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `calculateShadbala`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateShadbalaParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateShadbalaParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateShadbalaParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateRoomCompliance`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateRoomComplianceResponse {
    /// Which way the building faces, echoed. It does not move the zones: the mandala is aligned to the compass rather than to the building, so a room in the south-east is in the south-east whichever way the front door looks.
    pub facing: String,
    /// One reading per room sent, in the order you sent them.
    pub rooms: Vec<CalculateRoomComplianceResponseRoomsItem>,
    /// A RoxyAPI composite from 0 to 100 over the rooms you sent, not a classical quantity and not a number any verse gives. A rule carrying a verse weighs twice one carrying convention; an ideal placement scores full, an acceptable one half and a placement to avoid nothing. The weights are published in the scoring field so you can recompute it or ignore it.
    pub score: f64,
    /// The weights behind the composite, published rather than hidden so the number is auditable.
    pub scoring: CalculateRoomComplianceResponseScoring,
    /// Every rule this report rests on, so a printed report can carry the citation beside each room.
    pub sources: Vec<CalculateRoomComplianceResponseSourcesItem>,
}
/// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateRoomComplianceResponseSourcesItem {
    /// Why a convention rule says what it says. Present only when text is convention, and it names the tradition the rule comes from rather than a verse.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub basis: Option<String>,
    /// Chapter of the primary text. Absent on a convention, which has no chapter to cite.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chapter: Option<f64>,
    /// Whether the cited edition is in the public domain. True on the 1884 Brihat Samhita edition, whose verses are quoted. False on the 1933 Manasara edition behind the Ayadi formulas, from which only the multipliers, divisors and names are taken, never a sentence.
    #[serde(rename = "publicDomain", skip_serializing_if = "Option::is_none")]
    pub public_domain: Option<bool>,
    /// The primary text this verdict rests on, or the literal value convention where no verse states the rule. Always English, safe to compare against.
    pub text: String,
    /// Translator of the edition the verse was read in. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation: Option<String>,
    /// Verse or verse range inside the chapter. Absent on a convention. A range is written with a hyphen, as in 115-117.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub verse: Option<String>,
    /// Publication year of that edition. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<f64>,
}
/// The weights behind the composite, published rather than hidden so the number is auditable.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateRoomComplianceResponseScoring {
    /// The points a placement to avoid earns, out of one.
    #[serde(rename = "avoidPoints")]
    pub avoid_points: f64,
    /// The weight a rule carrying convention contributes.
    #[serde(rename = "conventionWeight")]
    pub convention_weight: f64,
    /// The points an ideal placement earns, out of one.
    #[serde(rename = "idealPoints")]
    pub ideal_points: f64,
    /// The points an acceptable placement earns, out of one.
    #[serde(rename = "neutralPoints")]
    pub neutral_points: f64,
    /// The weight a rule carrying a chapter and verse contributes.
    #[serde(rename = "sourcedWeight")]
    pub sourced_weight: f64,
}
/// One entry of `rooms`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateRoomComplianceResponseRoomsItem {
    /// The quarters this room type should be kept out of under its rule.
    #[serde(rename = "avoidDirections")]
    pub avoid_directions: Vec<String>,
    /// The quarters this room type belongs in under its rule.
    #[serde(rename = "idealDirections")]
    pub ideal_directions: Vec<String>,
    /// The placement as a sentence, for a report. Translated in place when lang is set to a language other than English.
    pub reading: String,
    /// What to do when the room is not where it belongs. Present when the verdict is acceptable or avoid, and absent on an ideal placement, which has nothing to fix. Original prose, translated in place when lang is set.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub remedy: Option<String>,
    /// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
    pub source: CalculateRoomComplianceResponseRoomsItemSource,
    /// The room type, echoed in its canonical spelling. Always English, safe to compare against.
    pub r#type: String,
    /// How the placement reads: ideal where the room sits where its rule puts it, avoid where it sits where the rule warns against, acceptable for everything between. Always English, safe to key styling on.
    pub verdict: String,
    /// Which of the nine zones the room occupies: one of the eight compass sectors, or Center for the middle ninth, which is the brahmasthan. Always English.
    pub zone: String,
}
/// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateRoomComplianceResponseRoomsItemSource {
    /// Why a convention rule says what it says. Present only when text is convention, and it names the tradition the rule comes from rather than a verse.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub basis: Option<String>,
    /// Chapter of the primary text. Absent on a convention, which has no chapter to cite.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chapter: Option<f64>,
    /// Whether the cited edition is in the public domain. True on the 1884 Brihat Samhita edition, whose verses are quoted. False on the 1933 Manasara edition behind the Ayadi formulas, from which only the multipliers, divisors and names are taken, never a sentence.
    #[serde(rename = "publicDomain", skip_serializing_if = "Option::is_none")]
    pub public_domain: Option<bool>,
    /// The primary text this verdict rests on, or the literal value convention where no verse states the rule. Always English, safe to compare against.
    pub text: String,
    /// Translator of the edition the verse was read in. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation: Option<String>,
    /// Verse or verse range inside the chapter. Absent on a convention. A range is written with a hyphen, as in 115-117.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub verse: Option<String>,
    /// Publication year of that edition. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<f64>,
}
/// The floor plan to check. Send facing or facingDegrees, never both, and give each room either its quarter or its outline, never both.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateRoomComplianceRequest {
    /// Direction the front of the house looks out toward, one of the eight compass sectors. Case and punctuation are folded, so north-east, northeast and NorthEast all resolve. Send this or facingDegrees, never both.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub facing: Option<CalculateRoomComplianceRequestFacing>,
    /// Direction the front of the house looks out toward, as a compass bearing in degrees clockwise from true north, measured looking OUT from the building. The same convention the feng shui facing endpoints use, so a bearing works unchanged across the two domains. Send this or facing, never both.
    #[serde(rename = "facingDegrees", skip_serializing_if = "Option::is_none")]
    pub facing_degrees: Option<f64>,
    /// The ground the mandala is projected over. Send width and depth for a compass-aligned rectangle, or polygon for anything else. The x axis runs east and the y axis north, and the mandala is aligned to the compass rather than to the building.
    pub plot: CalculateRoomComplianceRequestPlot,
    /// The rooms to check, 1 to 24 of them. Each carries a type and either the quarter it sits in or its outline.
    pub rooms: Vec<CalculateRoomComplianceRequestRoomsItem>,
}
/// One entry of `rooms`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateRoomComplianceRequestRoomsItem {
    /// Which quarter of the plot the room sits in, if you already know it. Send this or polygon, never both.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub direction: Option<CalculateRoomComplianceRequestRoomsItemDirection>,
    /// The room outline in plot coordinates, 3 to 16 vertices. The quarter is read from the area centroid against thirds of the plot, so an L-shaped room lands where its mass is rather than where its corners are. Send this or direction, never both.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub polygon: Option<Vec<CalculateRoomComplianceRequestRoomsItemPolygonItem>>,
    /// What the room is, one of puja, kitchen, master-bedroom, bedroom, living, dining, study, toilet, store, staircase, water-storage, entrance. Case and punctuation are folded, so Master Bedroom and master_bedroom both resolve. Four of the twelve carry a verse and the rest carry convention, and the response says which.
    pub r#type: CalculateRoomComplianceRequestRoomsItemType,
}
string_enum! {
    /// What the room is, one of puja, kitchen, master-bedroom, bedroom, living, dining, study, toilet, store, staircase, water-storage, entrance. Case and punctuation are folded, so Master Bedroom and master_bedroom both resolve. Four of the twelve carry a verse and the rest carry convention, and the response says which.
    CalculateRoomComplianceRequestRoomsItemType {
        Puja = "puja",
        Kitchen = "kitchen",
        MasterBedroom = "master-bedroom",
        Bedroom = "bedroom",
        Living = "living",
        Dining = "dining",
        Study = "study",
        Toilet = "toilet",
        Store = "store",
        Staircase = "staircase",
        WaterStorage = "water-storage",
        Entrance = "entrance",
    }
}
/// One entry of `polygon`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateRoomComplianceRequestRoomsItemPolygonItem {
    /// Distance east of the plot origin, in the same unit as the plot. The x axis runs east.
    pub x: f64,
    /// Distance north of the plot origin, in the same unit as the plot. The y axis runs north.
    pub y: f64,
}
string_enum! {
    /// Which quarter of the plot the room sits in, if you already know it. Send this or polygon, never both.
    CalculateRoomComplianceRequestRoomsItemDirection {
        North = "North",
        Northeast = "Northeast",
        East = "East",
        Southeast = "Southeast",
        South = "South",
        Southwest = "Southwest",
        West = "West",
        Northwest = "Northwest",
    }
}
/// The ground the mandala is projected over. Send width and depth for a compass-aligned rectangle, or polygon for anything else. The x axis runs east and the y axis north, and the mandala is aligned to the compass rather than to the building.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateRoomComplianceRequestPlot {
    /// North-south extent of a rectangular plot, in the unit given. Send this with width for a rectangle, or send polygon instead.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub depth: Option<f64>,
    /// The plot outline as 3 to 16 vertices in plot coordinates, x east and y north, in either winding order. Use this instead of width and depth for a plot with a cut corner, an extension or an irregular boundary.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub polygon: Option<Vec<CalculateRoomComplianceRequestPlotPolygonItem>>,
    /// Unit the plot dimensions are given in. Every distance the response returns is in this same unit. The mandala projection is scale free, so this affects the areas and the marma size and nothing else.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub unit: Option<CalculateRoomComplianceRequestPlotUnit>,
    /// East-west extent of a rectangular plot, in the unit given. Send this with depth for a rectangle, or send polygon instead.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub width: Option<f64>,
}
string_enum! {
    /// Unit the plot dimensions are given in. Every distance the response returns is in this same unit. The mandala projection is scale free, so this affects the areas and the marma size and nothing else.
    CalculateRoomComplianceRequestPlotUnit {
        Feet = "feet",
        Metres = "metres",
    }
}
/// One entry of `polygon`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateRoomComplianceRequestPlotPolygonItem {
    /// Distance east of the plot origin, in the same unit as the plot. The x axis runs east.
    pub x: f64,
    /// Distance north of the plot origin, in the same unit as the plot. The y axis runs north.
    pub y: f64,
}
string_enum! {
    /// Direction the front of the house looks out toward, one of the eight compass sectors. Case and punctuation are folded, so north-east, northeast and NorthEast all resolve. Send this or facingDegrees, never both.
    CalculateRoomComplianceRequestFacing {
        North = "North",
        Northeast = "Northeast",
        East = "East",
        Southeast = "Southeast",
        South = "South",
        Southwest = "Southwest",
        West = "West",
        Northwest = "Northwest",
    }
}
/// Path and query parameters of `calculateRoomCompliance`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateRoomComplianceParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateRoomComplianceParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateRoomComplianceParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Request body of `calculateProfile`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateProfileRequest {
    /// Birth date in YYYY-MM-DD format. The anchor for both the Personality activations at birth and the Design activations 88 degrees of solar arc earlier.
    pub date: String,
    /// Birth latitude in decimal degrees. Optional and does not affect the bodygraph, which depends only on ecliptic longitudes. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Optional and does not affect the bodygraph. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<CalculateProfileRequestNodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Precision matters: the profile lines and gate boundaries shift with the exact minute of birth.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: CalculateProfileRequestTimezone,
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateProfileRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    CalculateProfileRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Path and query parameters of `calculateProfile`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateProfileParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateProfileParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateProfileParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculatePlotAnalysis`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisResponse {
    /// The switches this analysis resolved, echoed so it can be reproduced later.
    pub conventions: CalculatePlotAnalysisResponseConventions,
    /// A verdict per cut quarter, every one of them convention.
    pub cuts: Vec<CalculatePlotAnalysisResponseCutsItem>,
    /// What the outline measures, in the unit you sent.
    pub dimensions: CalculatePlotAnalysisResponseDimensions,
    /// A verdict per extended quarter, every one of them convention. Empty when you named none.
    pub extensions: Vec<CalculatePlotAnalysisResponseExtensionsItem>,
    /// Which way the building looks and which way it sits. Resolved through the same 24 mountain table the feng shui facing endpoints use, so a bearing lands in the same sector on both domains.
    pub orientation: CalculatePlotAnalysisResponseOrientation,
    /// How the proportion reads. The one sourced verdict is the doubled length of 53.11; everything else is a modern band and is labelled convention, because no rank-independent ratio rule exists in the chapter at all.
    pub ratio: CalculatePlotAnalysisResponseRatio,
    /// The convention verdict on the side a road runs, with the sourced obstruction rule quoted in the sources list beside it. Absent when you named no road.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub road: Option<CalculatePlotAnalysisResponseRoad>,
    /// Whether the ground is a regular four sided figure, per 53.115, which gives the death of kinsmen for an irregular shape and barrenness for irregular sides.
    pub shape: CalculatePlotAnalysisResponseShape,
    /// The ground level under both schools. Absent when you sent no low direction, which is how you say the ground is level.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub slope: Option<CalculatePlotAnalysisResponseSlope>,
    /// Every verse and every convention this analysis rests on, so a report can print the citation beside each verdict.
    pub sources: Vec<CalculatePlotAnalysisResponseSourcesItem>,
    /// What the chapter says about standing water in the quarter you named. Only the north and the north-east are favourable, and each of the other six carries its own harm. Absent when you named no water.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub water: Option<CalculatePlotAnalysisResponseWater>,
}
/// What the chapter says about standing water in the quarter you named. Only the north and the north-east are favourable, and each of the other six carries its own harm. Absent when you named no water.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisResponseWater {
    /// How the stated effect reads: auspicious for a gain, inauspicious for a harm, mixed where the text names a gain and a loss together. A RoxyAPI classification of the verse effect rather than a word in the text, and always English so it is safe to key styling on.
    pub auspiciousness: String,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against and against the same value on the feng shui and I Ching endpoints.
    pub direction: String,
    /// What 53.119 gives for standing water in that quarter, as original prose. Translated in place when lang is set.
    pub effect: String,
    /// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
    pub source: CalculatePlotAnalysisResponseWaterSource,
}
/// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisResponseWaterSource {
    /// Why a convention rule says what it says. Present only when text is convention, and it names the tradition the rule comes from rather than a verse.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub basis: Option<String>,
    /// Chapter of the primary text. Absent on a convention, which has no chapter to cite.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chapter: Option<f64>,
    /// Whether the cited edition is in the public domain. True on the 1884 Brihat Samhita edition, whose verses are quoted. False on the 1933 Manasara edition behind the Ayadi formulas, from which only the multipliers, divisors and names are taken, never a sentence.
    #[serde(rename = "publicDomain", skip_serializing_if = "Option::is_none")]
    pub public_domain: Option<bool>,
    /// The primary text this verdict rests on, or the literal value convention where no verse states the rule. Always English, safe to compare against.
    pub text: String,
    /// Translator of the edition the verse was read in. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation: Option<String>,
    /// Verse or verse range inside the chapter. Absent on a convention. A range is written with a hyphen, as in 115-117.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub verse: Option<String>,
    /// Publication year of that edition. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<f64>,
}
/// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisResponseSourcesItem {
    /// Why a convention rule says what it says. Present only when text is convention, and it names the tradition the rule comes from rather than a verse.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub basis: Option<String>,
    /// Chapter of the primary text. Absent on a convention, which has no chapter to cite.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chapter: Option<f64>,
    /// Whether the cited edition is in the public domain. True on the 1884 Brihat Samhita edition, whose verses are quoted. False on the 1933 Manasara edition behind the Ayadi formulas, from which only the multipliers, divisors and names are taken, never a sentence.
    #[serde(rename = "publicDomain", skip_serializing_if = "Option::is_none")]
    pub public_domain: Option<bool>,
    /// The primary text this verdict rests on, or the literal value convention where no verse states the rule. Always English, safe to compare against.
    pub text: String,
    /// Translator of the edition the verse was read in. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation: Option<String>,
    /// Verse or verse range inside the chapter. Absent on a convention. A range is written with a hyphen, as in 115-117.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub verse: Option<String>,
    /// Publication year of that edition. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<f64>,
}
/// The ground level under both schools. Absent when you sent no low direction, which is how you say the ground is level.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisResponseSlope {
    /// Which of the two readings you asked to lead with, echoed.
    pub chosen: String,
    /// The quarter that therefore stands higher, which is what the verses are stated in terms of.
    #[serde(rename = "highDirection")]
    pub high_direction: String,
    /// The quarter you said the ground falls toward, echoed.
    #[serde(rename = "lowDirection")]
    pub low_direction: String,
    /// The ground level as a sentence, for a report. Translated in place when lang is set.
    pub reading: String,
    /// Both readings, always, whichever school you asked for. The two genuinely disagree where a slight rise on the east or the north is unavoidable: the chapter allows it and the modern rule does not, and publishing both is what lets a practitioner reconcile our verdict with their teacher.
    pub schools: Vec<CalculatePlotAnalysisResponseSlopeSchoolsItem>,
}
/// One entry of `schools`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisResponseSlopeSchoolsItem {
    /// What that reading says follows, as original prose. Translated in place when lang is set.
    pub effect: String,
    /// Which reading this verdict follows. Always English, safe to compare against.
    pub school: String,
    /// How that reading lands: auspicious, permitted where a slight rise is expressly allowed, inauspicious, or not-stated where the chapter gives no effect for a rise in that quarter. Always English.
    pub verdict: String,
    /// The verse the reading rests on. Empty on the modern school, which rests on teaching practice rather than on a verse.
    pub verse: String,
}
/// Whether the ground is a regular four sided figure, per 53.115, which gives the death of kinsmen for an irregular shape and barrenness for irregular sides.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisResponseShape {
    /// What the verdict means, as original prose. Translated in place when lang is set to a language other than English.
    pub effect: String,
    /// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
    pub source: CalculatePlotAnalysisResponseShapeSource,
    /// How the reading lands. Always English, safe to compare against and to key styling on.
    pub verdict: String,
}
/// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisResponseShapeSource {
    /// Why a convention rule says what it says. Present only when text is convention, and it names the tradition the rule comes from rather than a verse.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub basis: Option<String>,
    /// Chapter of the primary text. Absent on a convention, which has no chapter to cite.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chapter: Option<f64>,
    /// Whether the cited edition is in the public domain. True on the 1884 Brihat Samhita edition, whose verses are quoted. False on the 1933 Manasara edition behind the Ayadi formulas, from which only the multipliers, divisors and names are taken, never a sentence.
    #[serde(rename = "publicDomain", skip_serializing_if = "Option::is_none")]
    pub public_domain: Option<bool>,
    /// The primary text this verdict rests on, or the literal value convention where no verse states the rule. Always English, safe to compare against.
    pub text: String,
    /// Translator of the edition the verse was read in. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation: Option<String>,
    /// Verse or verse range inside the chapter. Absent on a convention. A range is written with a hyphen, as in 115-117.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub verse: Option<String>,
    /// Publication year of that edition. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<f64>,
}
/// The convention verdict on the side a road runs, with the sourced obstruction rule quoted in the sources list beside it. Absent when you named no road.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisResponseRoad {
    /// How the stated effect reads: auspicious for a gain, inauspicious for a harm, mixed where the text names a gain and a loss together. A RoxyAPI classification of the verse effect rather than a word in the text, and always English so it is safe to key styling on.
    pub auspiciousness: String,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against and against the same value on the feng shui and I Ching endpoints.
    pub direction: String,
    /// What the reading says, as original prose that names its own basis.
    pub effect: String,
    /// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
    pub source: CalculatePlotAnalysisResponseRoadSource,
}
/// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisResponseRoadSource {
    /// Why a convention rule says what it says. Present only when text is convention, and it names the tradition the rule comes from rather than a verse.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub basis: Option<String>,
    /// Chapter of the primary text. Absent on a convention, which has no chapter to cite.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chapter: Option<f64>,
    /// Whether the cited edition is in the public domain. True on the 1884 Brihat Samhita edition, whose verses are quoted. False on the 1933 Manasara edition behind the Ayadi formulas, from which only the multipliers, divisors and names are taken, never a sentence.
    #[serde(rename = "publicDomain", skip_serializing_if = "Option::is_none")]
    pub public_domain: Option<bool>,
    /// The primary text this verdict rests on, or the literal value convention where no verse states the rule. Always English, safe to compare against.
    pub text: String,
    /// Translator of the edition the verse was read in. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation: Option<String>,
    /// Verse or verse range inside the chapter. Absent on a convention. A range is written with a hyphen, as in 115-117.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub verse: Option<String>,
    /// Publication year of that edition. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<f64>,
}
/// How the proportion reads. The one sourced verdict is the doubled length of 53.11; everything else is a modern band and is labelled convention, because no rank-independent ratio rule exists in the chapter at all.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisResponseRatio {
    /// What the verdict means, as original prose. Translated in place when lang is set to a language other than English.
    pub effect: String,
    /// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
    pub source: CalculatePlotAnalysisResponseRatioSource,
    /// How the reading lands. Always English, safe to compare against and to key styling on.
    pub verdict: String,
}
/// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisResponseRatioSource {
    /// Why a convention rule says what it says. Present only when text is convention, and it names the tradition the rule comes from rather than a verse.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub basis: Option<String>,
    /// Chapter of the primary text. Absent on a convention, which has no chapter to cite.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chapter: Option<f64>,
    /// Whether the cited edition is in the public domain. True on the 1884 Brihat Samhita edition, whose verses are quoted. False on the 1933 Manasara edition behind the Ayadi formulas, from which only the multipliers, divisors and names are taken, never a sentence.
    #[serde(rename = "publicDomain", skip_serializing_if = "Option::is_none")]
    pub public_domain: Option<bool>,
    /// The primary text this verdict rests on, or the literal value convention where no verse states the rule. Always English, safe to compare against.
    pub text: String,
    /// Translator of the edition the verse was read in. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation: Option<String>,
    /// Verse or verse range inside the chapter. Absent on a convention. A range is written with a hyphen, as in 115-117.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub verse: Option<String>,
    /// Publication year of that edition. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<f64>,
}
/// Which way the building looks and which way it sits. Resolved through the same 24 mountain table the feng shui facing endpoints use, so a bearing lands in the same sector on both domains.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisResponseOrientation {
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against and against the same value on the feng shui and I Ching endpoints.
    pub facing: String,
    /// The bearing you sent, echoed. Absent when you named a sector instead of a bearing.
    #[serde(rename = "facingDegrees", skip_serializing_if = "Option::is_none")]
    pub facing_degrees: Option<f64>,
    /// The 15 degree mountain the bearing fell in, in the compass label form the feng shui endpoints use. Absent when you named a sector instead of a bearing, since a sector spans three mountains.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mountain: Option<String>,
    /// The sector directly opposite the facing, which is the back of the building. Always English.
    pub sitting: String,
}
/// One entry of `extensions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisResponseExtensionsItem {
    /// How the stated effect reads: auspicious for a gain, inauspicious for a harm, mixed where the text names a gain and a loss together. A RoxyAPI classification of the verse effect rather than a word in the text, and always English so it is safe to key styling on.
    pub auspiciousness: String,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against and against the same value on the feng shui and I Ching endpoints.
    pub direction: String,
    /// What the reading says, as original prose that names its own basis.
    pub effect: String,
    /// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
    pub source: CalculatePlotAnalysisResponseExtensionsItemSource,
}
/// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisResponseExtensionsItemSource {
    /// Why a convention rule says what it says. Present only when text is convention, and it names the tradition the rule comes from rather than a verse.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub basis: Option<String>,
    /// Chapter of the primary text. Absent on a convention, which has no chapter to cite.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chapter: Option<f64>,
    /// Whether the cited edition is in the public domain. True on the 1884 Brihat Samhita edition, whose verses are quoted. False on the 1933 Manasara edition behind the Ayadi formulas, from which only the multipliers, divisors and names are taken, never a sentence.
    #[serde(rename = "publicDomain", skip_serializing_if = "Option::is_none")]
    pub public_domain: Option<bool>,
    /// The primary text this verdict rests on, or the literal value convention where no verse states the rule. Always English, safe to compare against.
    pub text: String,
    /// Translator of the edition the verse was read in. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation: Option<String>,
    /// Verse or verse range inside the chapter. Absent on a convention. A range is written with a hyphen, as in 115-117.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub verse: Option<String>,
    /// Publication year of that edition. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<f64>,
}
/// What the outline measures, in the unit you sent.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisResponseDimensions {
    /// Area enclosed by the outline, in the square of your unit. Computed from the polygon, so a cut corner reduces it.
    pub area: f64,
    /// East-west extent of the plot, in the unit you sent.
    pub breadth: f64,
    /// North-south extent of the plot, in the unit you sent.
    pub length: f64,
    /// Length divided by breadth. The chapter has exactly one rank-independent ratio rule, twice the breadth for a house with an inner hall, and no band at all for anything else.
    pub ratio: f64,
}
/// One entry of `cuts`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisResponseCutsItem {
    /// How the stated effect reads: auspicious for a gain, inauspicious for a harm, mixed where the text names a gain and a loss together. A RoxyAPI classification of the verse effect rather than a word in the text, and always English so it is safe to key styling on.
    pub auspiciousness: String,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against and against the same value on the feng shui and I Ching endpoints.
    pub direction: String,
    /// What the reading says, as original prose that names its own basis.
    pub effect: String,
    /// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
    pub source: CalculatePlotAnalysisResponseCutsItemSource,
}
/// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisResponseCutsItemSource {
    /// Why a convention rule says what it says. Present only when text is convention, and it names the tradition the rule comes from rather than a verse.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub basis: Option<String>,
    /// Chapter of the primary text. Absent on a convention, which has no chapter to cite.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chapter: Option<f64>,
    /// Whether the cited edition is in the public domain. True on the 1884 Brihat Samhita edition, whose verses are quoted. False on the 1933 Manasara edition behind the Ayadi formulas, from which only the multipliers, divisors and names are taken, never a sentence.
    #[serde(rename = "publicDomain", skip_serializing_if = "Option::is_none")]
    pub public_domain: Option<bool>,
    /// The primary text this verdict rests on, or the literal value convention where no verse states the rule. Always English, safe to compare against.
    pub text: String,
    /// Translator of the edition the verse was read in. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation: Option<String>,
    /// Verse or verse range inside the chapter. Absent on a convention. A range is written with a hyphen, as in 115-117.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub verse: Option<String>,
    /// Publication year of that edition. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<f64>,
}
/// The switches this analysis resolved, echoed so it can be reproduced later.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisResponseConventions {
    /// Which ground level reading was asked to lead. Echoes the resolved value whether it was sent or defaulted.
    #[serde(rename = "slopeSchool")]
    pub slope_school: String,
}
/// The site to read: the ground, which way the front looks, and whichever of the slope, road, extensions, cuts and water you know. Send facing or facingDegrees, never both, and the same for the two plot forms.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisRequest {
    /// Quarters where a corner is missing from the rectangle. Every cut verdict is convention, for the same reason as the extensions.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cuts: Option<Vec<CalculatePlotAnalysisRequestCutsItem>>,
    /// Quarters where the plot bulges out beyond a rectangle. Every extension verdict is convention: the chapter states no rule for a named corner and the nearest verses speak of a figure with a limb wanting.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub extensions: Option<Vec<CalculatePlotAnalysisRequestExtensionsItem>>,
    /// Direction the front of the house looks out toward, one of the eight compass sectors. Case and punctuation are folded, so north-east, northeast and NorthEast all resolve. Send this or facingDegrees, never both.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub facing: Option<CalculatePlotAnalysisRequestFacing>,
    /// Direction the front of the house looks out toward, as a compass bearing in degrees clockwise from true north, measured looking OUT from the building. The same convention the feng shui facing endpoints use, so a bearing works unchanged across the two domains. Send this or facing, never both.
    #[serde(rename = "facingDegrees", skip_serializing_if = "Option::is_none")]
    pub facing_degrees: Option<f64>,
    /// The ground the mandala is projected over. Send width and depth for a compass-aligned rectangle, or polygon for anything else. The x axis runs east and the y axis north, and the mandala is aligned to the compass rather than to the building.
    pub plot: CalculatePlotAnalysisRequestPlot,
    /// Which side a road runs along. The verdict is convention: the chapter states no rule for the side a road is on, only that an obstruction facing the gate brings misery unless it lies beyond twice the height of the house.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub road: Option<CalculatePlotAnalysisRequestRoad>,
    /// Which quarter of the plot the ground falls toward, that is where the LOW point is. The chapter states its rules in terms of the side that stands HIGHER, so the opposite of this value is what the verses are read against, and both are returned. Omit it if the ground is level.
    #[serde(rename = "slopeLowDirection", skip_serializing_if = "Option::is_none")]
    pub slope_low_direction: Option<CalculatePlotAnalysisRequestSlopeLowDirection>,
    /// Which reading of the ground level to lead with. brihat-samhita applies verses 115 to 117 as written, where a higher north-east is a loss, a higher east or north is permitted when level ground is unavoidable and still carries its stated cost, and a higher south or west carries its cost with no allowance. modern applies the widely taught rule that the north-east must be the lowest point, which agrees with verse 115 and contradicts the verse 116 allowance. Both readings are returned whichever you choose, so the disagreement is visible rather than hidden. Defaults to brihat-samhita.
    #[serde(rename = "slopeSchool", skip_serializing_if = "Option::is_none")]
    pub slope_school: Option<CalculatePlotAnalysisRequestSlopeSchool>,
    /// Which quarter holds standing water, a well, a tank or a sump. This one IS sourced: 53.119 gives a distinct effect for each of the eight directions and calls only the north and the north-east favourable.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub water: Option<CalculatePlotAnalysisRequestWater>,
}
string_enum! {
    /// Which quarter holds standing water, a well, a tank or a sump. This one IS sourced: 53.119 gives a distinct effect for each of the eight directions and calls only the north and the north-east favourable.
    CalculatePlotAnalysisRequestWater {
        North = "North",
        Northeast = "Northeast",
        East = "East",
        Southeast = "Southeast",
        South = "South",
        Southwest = "Southwest",
        West = "West",
        Northwest = "Northwest",
    }
}
string_enum! {
    /// Which reading of the ground level to lead with. brihat-samhita applies verses 115 to 117 as written, where a higher north-east is a loss, a higher east or north is permitted when level ground is unavoidable and still carries its stated cost, and a higher south or west carries its cost with no allowance. modern applies the widely taught rule that the north-east must be the lowest point, which agrees with verse 115 and contradicts the verse 116 allowance. Both readings are returned whichever you choose, so the disagreement is visible rather than hidden. Defaults to brihat-samhita.
    CalculatePlotAnalysisRequestSlopeSchool {
        BrihatSamhita = "brihat-samhita",
        Modern = "modern",
    }
}
string_enum! {
    /// Which quarter of the plot the ground falls toward, that is where the LOW point is. The chapter states its rules in terms of the side that stands HIGHER, so the opposite of this value is what the verses are read against, and both are returned. Omit it if the ground is level.
    CalculatePlotAnalysisRequestSlopeLowDirection {
        North = "North",
        Northeast = "Northeast",
        East = "East",
        Southeast = "Southeast",
        South = "South",
        Southwest = "Southwest",
        West = "West",
        Northwest = "Northwest",
    }
}
string_enum! {
    /// Which side a road runs along. The verdict is convention: the chapter states no rule for the side a road is on, only that an obstruction facing the gate brings misery unless it lies beyond twice the height of the house.
    CalculatePlotAnalysisRequestRoad {
        North = "North",
        Northeast = "Northeast",
        East = "East",
        Southeast = "Southeast",
        South = "South",
        Southwest = "Southwest",
        West = "West",
        Northwest = "Northwest",
    }
}
/// The ground the mandala is projected over. Send width and depth for a compass-aligned rectangle, or polygon for anything else. The x axis runs east and the y axis north, and the mandala is aligned to the compass rather than to the building.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisRequestPlot {
    /// North-south extent of a rectangular plot, in the unit given. Send this with width for a rectangle, or send polygon instead.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub depth: Option<f64>,
    /// The plot outline as 3 to 16 vertices in plot coordinates, x east and y north, in either winding order. Use this instead of width and depth for a plot with a cut corner, an extension or an irregular boundary.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub polygon: Option<Vec<CalculatePlotAnalysisRequestPlotPolygonItem>>,
    /// Unit the plot dimensions are given in. Every distance the response returns is in this same unit. The mandala projection is scale free, so this affects the areas and the marma size and nothing else.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub unit: Option<CalculatePlotAnalysisRequestPlotUnit>,
    /// East-west extent of a rectangular plot, in the unit given. Send this with depth for a rectangle, or send polygon instead.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub width: Option<f64>,
}
string_enum! {
    /// Unit the plot dimensions are given in. Every distance the response returns is in this same unit. The mandala projection is scale free, so this affects the areas and the marma size and nothing else.
    CalculatePlotAnalysisRequestPlotUnit {
        Feet = "feet",
        Metres = "metres",
    }
}
/// One entry of `polygon`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisRequestPlotPolygonItem {
    /// Distance east of the plot origin, in the same unit as the plot. The x axis runs east.
    pub x: f64,
    /// Distance north of the plot origin, in the same unit as the plot. The y axis runs north.
    pub y: f64,
}
string_enum! {
    /// Direction the front of the house looks out toward, one of the eight compass sectors. Case and punctuation are folded, so north-east, northeast and NorthEast all resolve. Send this or facingDegrees, never both.
    CalculatePlotAnalysisRequestFacing {
        North = "North",
        Northeast = "Northeast",
        East = "East",
        Southeast = "Southeast",
        South = "South",
        Southwest = "Southwest",
        West = "West",
        Northwest = "Northwest",
    }
}
string_enum! {
    /// One entry of `extensions`.
    CalculatePlotAnalysisRequestExtensionsItem {
        North = "North",
        Northeast = "Northeast",
        East = "East",
        Southeast = "Southeast",
        South = "South",
        Southwest = "Southwest",
        West = "West",
        Northwest = "Northwest",
    }
}
string_enum! {
    /// One entry of `cuts`.
    CalculatePlotAnalysisRequestCutsItem {
        North = "North",
        Northeast = "Northeast",
        East = "East",
        Southeast = "Southeast",
        South = "South",
        Southwest = "Southwest",
        West = "West",
        Northwest = "Northwest",
    }
}
/// Path and query parameters of `calculatePlotAnalysis`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculatePlotAnalysisParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculatePlotAnalysisParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculatePlotAnalysisParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculatePersonality`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePersonalityResponse {
    /// Every consonant of the birth name with its value, grouped by name: each name is summed and reduced, then the names are added and reduced to the final Personality number.
    pub calculation: String,
    /// Indicates whether a Karmic Debt number (13, 14, 16, or 19) appeared during the consonant reduction chain. Karmic Debt in the Personality position reveals past-life patterns that influence how others perceive you and the social challenges you must overcome.
    #[serde(rename = "hasKarmicDebt")]
    pub has_karmic_debt: bool,
    /// Detailed interpretation of the Karmic Debt number when present. Only returned when hasKarmicDebt is true.
    #[serde(rename = "karmicDebtMeaning", skip_serializing_if = "Option::is_none")]
    pub karmic_debt_meaning: Option<CalculatePersonalityResponseKarmicDebtMeaning>,
    /// The specific Karmic Debt number detected during the consonant reduction, if any. Each debt number (13, 14, 16, 19) represents a distinct past-life lesson that shapes your public image and social interactions.
    #[serde(rename = "karmicDebtNumber", skip_serializing_if = "Option::is_none")]
    pub karmic_debt_number: Option<f64>,
    /// The `meaning` field.
    pub meaning: CalculatePersonalityResponseMeaning,
    /// Your Personality number, derived from the consonants in your birth name. Reveals how others perceive you, your outer persona, and the first impression you project. Values range from 1 to 9 for single digits, or 11, 22, 33 for Master Numbers.
    pub number: f64,
    /// Whether this is a standard single-digit number (1 to 9) or a Master Number (11, 22, 33). Master Numbers in the Personality position indicate a powerful outer presence that others immediately sense, carrying heightened charisma and public influence.
    pub r#type: CalculatePersonalityResponseType,
}
string_enum! {
    /// Whether this is a standard single-digit number (1 to 9) or a Master Number (11, 22, 33). Master Numbers in the Personality position indicate a powerful outer presence that others immediately sense, carrying heightened charisma and public influence.
    CalculatePersonalityResponseType {
        Single = "single",
        Master = "master",
    }
}
/// The `meaning` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePersonalityResponseMeaning {
    /// How your outward presence shapes professional opportunities. Covers the industries, roles, and environments where your public image creates the greatest advantage.
    pub career: String,
    /// Blind spots in your public persona. Patterns others notice that you may not, including defense mechanisms and image-management tendencies that can limit authentic connection.
    pub challenges: Vec<String>,
    /// Core interpretation of the outer personality, social presence and the image projected to the world. Together with the strengths, challenges, career, relationships and spirituality fields it makes a full reading.
    pub description: String,
    /// Traits that define your public persona and first impression. These are the qualities others perceive before they get to know the real you.
    pub keywords: Vec<String>,
    /// First impressions in love and social dynamics. Explores how your Personality number attracts certain partners, sets relationship expectations, and influences group dynamics.
    pub relationships: String,
    /// The spiritual energy you radiate to others. Explores how your outer presence serves as a channel for deeper purpose, and what your public path reveals about your soul mission.
    pub spirituality: String,
    /// Your strongest social assets and public-facing gifts. These qualities shape how you are received in professional settings, social gatherings, and first meetings.
    pub strengths: Vec<String>,
    /// Numerology archetype for this Personality number. Represents the outer mask you show the world, such as "The Builder" for 4 or "The Powerhouse" for 8.
    pub title: String,
}
/// Detailed interpretation of the Karmic Debt number when present. Only returned when hasKarmicDebt is true.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePersonalityResponseKarmicDebtMeaning {
    /// The specific challenge from past lives that must be confronted.
    pub challenge: String,
    /// Title describing the karmic debt theme and core past-life pattern.
    pub description: String,
    /// Practical guidance for resolving the karmic debt.
    pub resolution: String,
}
/// Path and query parameters of `calculatePersonality`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculatePersonalityParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculatePersonalityParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculatePersonalityParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `calculatePersonalYear`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculatePersonalYearParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculatePersonalYearParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculatePersonalYearParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `calculatePersonalMonth`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculatePersonalMonthParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculatePersonalMonthParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculatePersonalMonthParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `calculatePersonalDay`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculatePersonalDayParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculatePersonalDayParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculatePersonalDayParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculatePenta`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePentaResponse {
    /// The six channels of the Penta with their defined Strength state and which members supply each gate. Three upper channels run G to Throat (The Alpha, Inspiration, The Prodigal); three lower channels run G to Sacral (Rhythm, The Beat, Discovery).
    pub channels: Vec<CalculatePentaResponseChannelsItem>,
    /// The twelve Penta gates with their filled state and which members hold each.
    pub gates: Vec<CalculatePentaResponseGatesItem>,
    /// Number of people in the group, always between 3 and 5.
    #[serde(rename = "memberCount")]
    pub member_count: f64,
    /// Group-level rollup of the Penta channels and gates.
    pub summary: CalculatePentaResponseSummary,
}
/// Group-level rollup of the Penta channels and gates.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePentaResponseSummary {
    /// Whether the 2/14 Channel of the Beat, the material core of the Penta, is defined across the group.
    #[serde(rename = "coreDefined")]
    pub core_defined: bool,
    /// Count of the six Penta channels that are defined Strengths in the group.
    #[serde(rename = "definedChannels")]
    pub defined_channels: f64,
    /// Count of the twelve Penta gates filled by at least one member.
    #[serde(rename = "filledGates")]
    pub filled_gates: f64,
    /// Penta gates held by no member. A non-empty list flags the functional gaps in the group.
    #[serde(rename = "gapGates")]
    pub gap_gates: Vec<f64>,
}
/// One entry of `gates`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePentaResponseGatesItem {
    /// Whether at least one member holds this gate. A gate held by nobody is a gap that conditions the group to compensate for the missing role.
    pub filled: bool,
    /// Penta gate number. One of 1, 2, 5, 7, 8, 13, 14, 15, 29, 31, 33, 46.
    pub gate: f64,
    /// Human Design keynote name of the gate, describing the role it brings to the group. Always English, whatever the lang parameter says. Use gateNameLocalized for anything a reader sees.
    #[serde(rename = "gateName")]
    pub gate_name: String,
    /// Gate keynote name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "gateNameLocalized", skip_serializing_if = "Option::is_none")]
    pub gate_name_localized: Option<String>,
    /// Zero-based indices of the members whose chart holds this gate. Empty when the gate is a gap.
    #[serde(rename = "heldBy")]
    pub held_by: Vec<f64>,
}
/// One entry of `channels`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePentaResponseChannelsItem {
    /// Circuit family of the channel. One of Individual, Collective, Tribal. Always English, whatever the lang parameter says. Use circuitLocalized for anything a reader sees.
    pub circuit: String,
    /// Circuit family name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "circuitLocalized", skip_serializing_if = "Option::is_none")]
    pub circuit_localized: Option<String>,
    /// Whether the channel is a defined Strength: both of its gates are present somewhere in the group, so the function it governs has no gap.
    pub defined: bool,
    /// First gate of the Penta channel.
    #[serde(rename = "gateA")]
    pub gate_a: f64,
    /// Zero-based indices of the members whose chart holds gate A, in member order.
    #[serde(rename = "gateAHeldBy")]
    pub gate_aheld_by: Vec<f64>,
    /// Second gate of the Penta channel.
    #[serde(rename = "gateB")]
    pub gate_b: f64,
    /// Zero-based indices of the members whose chart holds gate B, in member order.
    #[serde(rename = "gateBHeldBy")]
    pub gate_bheld_by: Vec<f64>,
    /// Whether this is the 2/14 Channel of the Beat, the material core of the Penta vortex: gate 2 the direction for resources, gate 14 the resources themselves.
    #[serde(rename = "isCore")]
    pub is_core: bool,
    /// Name of the Penta channel. One of The Alpha, Inspiration, The Prodigal, Rhythm, The Beat, Discovery. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Penta channel name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Position of the channel in the Penta. upper channels run from the G Center to the Throat and carry the leadership and how-the-group-presents roles. lower channels run from the G Center to the Sacral and carry the managed, generative, resource roles.
    pub position: String,
}
/// Request body of `calculatePenta`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePentaRequest {
    /// Birth moments of the three to five people in the group. Below three no Penta forms; above five a second Penta emerges.
    pub members: Vec<CalculatePentaRequestMembersItem>,
}
/// One entry of `members`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePentaRequestMembersItem {
    /// Birth date in YYYY-MM-DD format. The anchor for both the Personality activations at birth and the Design activations 88 degrees of solar arc earlier.
    pub date: String,
    /// Birth latitude in decimal degrees. Optional and does not affect the bodygraph, which depends only on ecliptic longitudes. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Optional and does not affect the bodygraph. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<CalculatePentaRequestMembersItemNodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Precision matters: the profile lines and gate boundaries shift with the exact minute of birth.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: CalculatePentaRequestMembersItemTimezone,
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculatePentaRequestMembersItemTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    CalculatePentaRequestMembersItemNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Path and query parameters of `calculatePenta`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculatePentaParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculatePentaParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculatePentaParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateParallels`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateParallelsResponse {
    /// Datetime used for the declination calculation, echoed as the local civil date and time supplied in the request (YYYY-MM-DDTHH:MM:SS). The timezone field of the request is what converts it to the instant the declinations are computed for.
    pub datetime: String,
    /// All parallel and contraparallel aspects found within the specified orb. Parallels are powerful hidden aspects often overlooked in standard chart analysis.
    pub parallels: Vec<CalculateParallelsResponseParallelsItem>,
    /// Declination and right ascension for each planet at the given moment.
    pub planets: Vec<CalculateParallelsResponsePlanetsItem>,
}
/// One entry of `planets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateParallelsResponsePlanetsItem {
    /// Celestial declination in degrees. Positive = north of celestial equator, negative = south.
    pub declination: f64,
    /// Planet name (Sun through Saturn, the 7 visible planets).
    pub name: String,
    /// Right ascension in degrees (0-360) along the celestial equator.
    #[serde(rename = "rightAscension")]
    pub right_ascension: f64,
}
/// One entry of `parallels`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateParallelsResponseParallelsItem {
    /// Declination of the first planet in degrees.
    pub dec1: f64,
    /// Declination of the second planet in degrees.
    pub dec2: f64,
    /// Angular difference from exact parallel/contraparallel in degrees. Smaller = stronger.
    pub orb: f64,
    /// First planet in the parallel/contraparallel pair.
    pub planet1: String,
    /// Second planet in the pair.
    pub planet2: String,
    /// Parallel = same declination (acts like conjunction). Contraparallel = opposite declination (acts like opposition).
    pub r#type: CalculateParallelsResponseParallelsItemType,
}
string_enum! {
    /// Parallel = same declination (acts like conjunction). Contraparallel = opposite declination (acts like opposition).
    CalculateParallelsResponseParallelsItemType {
        Parallel = "parallel",
        Contraparallel = "contraparallel",
    }
}
/// Request body of `calculateParallels`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateParallelsRequest {
    /// Date in YYYY-MM-DD format. Planetary declinations are calculated for this date to find parallel and contraparallel aspects.
    pub date: String,
    /// Birth latitude in decimal degrees, part of the birth record. Declinations are geocentric, as every published ephemeris prints them, so it does not move them.
    pub latitude: f64,
    /// Birth longitude in decimal degrees, part of the birth record. Declinations are geocentric, so it does not move them; the instant comes from date, time and timezone.
    pub longitude: f64,
    /// Orb in degrees for parallel/contraparallel detection. Defaults to 1.5°.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub orb: Option<f64>,
    /// Time in HH:MM:SS format (24-hour). Exact time affects declination values, especially for the fast-moving Moon.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5 (IST).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<CalculateParallelsRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5 (IST).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateParallelsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
/// Path and query parameters of `calculatePapasamyam`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculatePapasamyamParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculatePapasamyamParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculatePapasamyamParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateNumCompatibility`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateNumCompatibilityResponse {
    /// Practical relationship advice
    pub advice: String,
    /// Potential relationship challenges
    pub challenges: Vec<String>,
    /// The `expression` field.
    pub expression: CalculateNumCompatibilityResponseExpression,
    /// The `lifePath` field.
    #[serde(rename = "lifePath")]
    pub life_path: CalculateNumCompatibilityResponseLifePath,
    /// Overall compatibility score: 50% Life Path, 30% Expression and 20% Soul Urge pair scores, rounded. Every pair score runs 50 to 100, so the overall score does too.
    #[serde(rename = "overallScore")]
    pub overall_score: f64,
    /// Compatibility rating from overallScore: Highly Compatible (90 and up), Very Compatible (75 to 89), Compatible (60 to 74) or Moderately Compatible (50 to 59). The scale also names Challenging below 45, which no pair of core numbers reaches.
    pub rating: String,
    /// The `soulUrge` field.
    #[serde(rename = "soulUrge")]
    pub soul_urge: CalculateNumCompatibilityResponseSoulUrge,
    /// Key relationship strengths
    pub strengths: Vec<String>,
}
/// The `soulUrge` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateNumCompatibilityResponseSoulUrge {
    /// Soul Urge compatibility score (50-100)
    pub compatibility: f64,
    /// Detailed Soul Urge compatibility analysis
    pub description: String,
    /// Person 1 Soul Urge number
    pub person1: f64,
    /// Person 2 Soul Urge number
    pub person2: f64,
}
/// The `lifePath` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateNumCompatibilityResponseLifePath {
    /// Life Path compatibility score (50-100)
    pub compatibility: f64,
    /// Detailed Life Path compatibility analysis
    pub description: String,
    /// Person 1 Life Path number
    pub person1: f64,
    /// Person 2 Life Path number
    pub person2: f64,
}
/// The `expression` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateNumCompatibilityResponseExpression {
    /// Expression compatibility score (50-100)
    pub compatibility: f64,
    /// Detailed Expression compatibility analysis
    pub description: String,
    /// Person 1 Expression number
    pub person1: f64,
    /// Person 2 Expression number
    pub person2: f64,
}
/// Request body of `calculateNumCompatibility`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateNumCompatibilityRequest {
    /// The `person1` field.
    pub person1: CalculateNumCompatibilityRequestPerson1,
    /// The `person2` field.
    pub person2: CalculateNumCompatibilityRequestPerson2,
}
/// The `person2` value.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateNumCompatibilityRequestPerson2 {
    /// Birth day (1-31). Required with year and month for automatic Life Path calculation.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub day: Option<i64>,
    /// Person 2 Expression number (1-9, 11, 22, 33). Optional if fullName is provided.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub expression: Option<i64>,
    /// Full birth name to calculate Expression and Soul Urge numbers automatically. Use instead of passing expression and soulUrge directly.
    #[serde(rename = "fullName", skip_serializing_if = "Option::is_none")]
    pub full_name: Option<String>,
    /// Person 2 Life Path number (1-9, 11, 22, 33). Optional if year, month, day are provided.
    #[serde(rename = "lifePath", skip_serializing_if = "Option::is_none")]
    pub life_path: Option<i64>,
    /// Birth month (1-12). Required with year and day for automatic Life Path calculation.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub month: Option<i64>,
    /// Person 2 Soul Urge number (1-9, 11, 22, 33). Optional if fullName is provided.
    #[serde(rename = "soulUrge", skip_serializing_if = "Option::is_none")]
    pub soul_urge: Option<i64>,
    /// Birth year to calculate Life Path automatically. Use with month and day instead of passing lifePath directly.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i64>,
}
/// The `person1` value.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateNumCompatibilityRequestPerson1 {
    /// Birth day (1-31). Required with year and month for automatic Life Path calculation.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub day: Option<i64>,
    /// Person 1 Expression number (1-9, 11, 22, 33). Optional if fullName is provided.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub expression: Option<i64>,
    /// Full birth name to calculate Expression and Soul Urge numbers automatically. Use instead of passing expression and soulUrge directly.
    #[serde(rename = "fullName", skip_serializing_if = "Option::is_none")]
    pub full_name: Option<String>,
    /// Person 1 Life Path number (1-9, 11, 22, 33). Optional if year, month, day are provided.
    #[serde(rename = "lifePath", skip_serializing_if = "Option::is_none")]
    pub life_path: Option<i64>,
    /// Birth month (1-12). Required with year and day for automatic Life Path calculation.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub month: Option<i64>,
    /// Person 1 Soul Urge number (1-9, 11, 22, 33). Optional if fullName is provided.
    #[serde(rename = "soulUrge", skip_serializing_if = "Option::is_none")]
    pub soul_urge: Option<i64>,
    /// Birth year to calculate Life Path automatically. Use with month and day instead of passing lifePath directly.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i64>,
}
/// Path and query parameters of `calculateNumCompatibility`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateNumCompatibilityParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateNumCompatibilityParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateNumCompatibilityParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateNameCompatibility`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateNameCompatibilityResponse {
    /// Which band the composite falls in: high, moderate or low. Derived from the score, always English.
    pub band: String,
    /// Every component of the composite with its own maximum, so a caller who disagrees with the weighting can recompute rather than argue.
    pub components: Vec<CalculateNameCompatibilityResponseComponentsItem>,
    /// The `conventions` field.
    pub conventions: CalculateNameCompatibilityResponseConventions,
    /// The `first` field.
    pub first: CalculateNameCompatibilityResponseFirst,
    /// The composed reading, in the requested language. It states that the score is ours.
    pub reading: String,
    /// The composite, 0 to 100. A RoxyAPI composite, not a classical measure: no source scores two names against each other, so the components below are published and the number is derivable from them.
    pub score: f64,
    /// The `second` field.
    pub second: CalculateNameCompatibilityResponseSecond,
    /// Every cipher on which the two names give the same number. Empty when they share none, which happens often and carries no traditional reading of its own.
    #[serde(rename = "sharedValues")]
    pub shared_values: Vec<CalculateNameCompatibilityResponseSharedValuesItem>,
}
/// One entry of `sharedValues`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateNameCompatibilityResponseSharedValuesItem {
    /// Machine identifier of the cipher the two names agree on.
    pub cipher: String,
    /// Display name of that cipher.
    pub name: String,
    /// The value both names give under it.
    pub value: f64,
}
/// The `second` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateNameCompatibilityResponseSecond {
    /// The Hebrew spelling this side was scored from.
    pub hebrew: String,
    /// The name as sent, in whichever script it was sent in.
    pub input: String,
    /// The standard value reduced by repeated digit sum, stopping at ten.
    pub reduced: f64,
    /// Latin transcription of that spelling, from the one mechanical letter map.
    pub romanization: String,
    /// Why this spelling was chosen over the other parses.
    pub rule: String,
    /// Machine identifier of the sephirah the reduced value points at.
    pub sephirah: String,
    /// The English gloss of that sephirah, in the requested language.
    #[serde(rename = "sephirahEnglish")]
    pub sephirah_english: String,
    /// Value under the standard reading, which is the relation the tradition works with.
    pub standard: f64,
}
/// The `first` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateNameCompatibilityResponseFirst {
    /// The Hebrew spelling this side was scored from.
    pub hebrew: String,
    /// The name as sent, in whichever script it was sent in.
    pub input: String,
    /// The standard value reduced by repeated digit sum, stopping at ten.
    pub reduced: f64,
    /// Latin transcription of that spelling, from the one mechanical letter map.
    pub romanization: String,
    /// Why this spelling was chosen over the other parses.
    pub rule: String,
    /// Machine identifier of the sephirah the reduced value points at.
    pub sephirah: String,
    /// The English gloss of that sephirah, in the requested language.
    #[serde(rename = "sephirahEnglish")]
    pub sephirah_english: String,
    /// Value under the standard reading, which is the relation the tradition works with.
    pub standard: f64,
}
/// The `conventions` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateNameCompatibilityResponseConventions {
    /// Which of the two published methods the name mispar gadol was read as.
    #[serde(rename = "misparGadol")]
    pub mispar_gadol: String,
    /// The Latin to Hebrew scheme applied. Absent when the caller sent Hebrew directly.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transliteration: Option<String>,
}
/// One entry of `components`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateNameCompatibilityResponseComponentsItem {
    /// Machine identifier of the component.
    pub id: String,
    /// Whether the component found anything at all.
    pub matched: bool,
    /// The most it can contribute. The four maxima sum to 100, so the weighting is visible rather than implied.
    pub maximum: f64,
    /// What this component contributed.
    pub points: f64,
}
/// The two names to compare. Each side takes the Latin field or the Hebrew one, never both: which one you send decides whether a transliteration step runs for that side.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateNameCompatibilityRequest {
    /// First name in Latin script. Send firstNameHebrew instead to control the spelling.
    #[serde(rename = "firstName", skip_serializing_if = "Option::is_none")]
    pub first_name: Option<String>,
    /// First name already in Hebrew, which skips the transliteration step.
    #[serde(rename = "firstNameHebrew", skip_serializing_if = "Option::is_none")]
    pub first_name_hebrew: Option<String>,
    /// Which method the name mispar gadol means, because the sources use it for two. Use finals-500-900 to score the five word final letters as 500 to 900, or milui to score each letter as the value of its own spelled out name.
    #[serde(rename = "misparGadol", skip_serializing_if = "Option::is_none")]
    pub mispar_gadol: Option<CalculateNameCompatibilityRequestMisparGadol>,
    /// Second name in Latin script. Send secondNameHebrew instead to control the spelling.
    #[serde(rename = "secondName", skip_serializing_if = "Option::is_none")]
    pub second_name: Option<String>,
    /// Second name already in Hebrew, which skips the transliteration step.
    #[serde(rename = "secondNameHebrew", skip_serializing_if = "Option::is_none")]
    pub second_name_hebrew: Option<String>,
    /// How a Latin name is written in Hebrew before it is scored. Two members. letter-map-mathers is the 1887 Hermetic letter map, with e read as its author practised it: a point inside a word and alef at the start of one. It writes no c, f, w or x, so a name carrying one of them outside a two letter group returns 400 naming the letter. letter-map-modern follows the modern Israeli transcription rules for the sound each Latin letter carries in English and French spelling, covers every Latin letter, drops the geresh and does not double vav or yod, so send textHebrew for the ktiv male form. Every form states the readings it used in rule. Phonetic Ashkenazi and Sephardi schemes are not offered because no two references agree on a rule for that direction.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transliteration: Option<CalculateNameCompatibilityRequestTransliteration>,
}
string_enum! {
    /// How a Latin name is written in Hebrew before it is scored. Two members. letter-map-mathers is the 1887 Hermetic letter map, with e read as its author practised it: a point inside a word and alef at the start of one. It writes no c, f, w or x, so a name carrying one of them outside a two letter group returns 400 naming the letter. letter-map-modern follows the modern Israeli transcription rules for the sound each Latin letter carries in English and French spelling, covers every Latin letter, drops the geresh and does not double vav or yod, so send textHebrew for the ktiv male form. Every form states the readings it used in rule. Phonetic Ashkenazi and Sephardi schemes are not offered because no two references agree on a rule for that direction.
    CalculateNameCompatibilityRequestTransliteration {
        LetterMapMathers = "letter-map-mathers",
        LetterMapModern = "letter-map-modern",
    }
}
string_enum! {
    /// Which method the name mispar gadol means, because the sources use it for two. Use finals-500-900 to score the five word final letters as 500 to 900, or milui to score each letter as the value of its own spelled out name.
    CalculateNameCompatibilityRequestMisparGadol {
        Finals500900 = "finals-500-900",
        Milui = "milui",
    }
}
/// Path and query parameters of `calculateNameCompatibility`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateNameCompatibilityParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateNameCompatibilityParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateNameCompatibilityParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateMayanCompatibility`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateMayanCompatibilityResponse {
    /// The five structural ties, in a fixed order, each either holding or not. Every one of them is a property of the count itself or of the measured daykeeper cross convention; what is ours is only the decision to weigh them together.
    pub components: Vec<CalculateMayanCompatibilityResponseComponentsItem>,
    /// The conventions this comparison was computed under. The direction scheme is echoed because one of the five ties is read off the world directions, which the two schemes assign differently.
    pub conventions: CalculateMayanCompatibilityResponseConventions,
    /// How far apart the two days sit in the 260 day round, taken the short way round, so the value never exceeds 130. Two people on the same nawal are 0 apart.
    #[serde(rename = "daysApart")]
    pub days_apart: f64,
    /// The Tzolkin day the first person was born on.
    #[serde(rename = "personA")]
    pub person_a: CalculateMayanCompatibilityResponsePersonA,
    /// The Tzolkin day the second person was born on.
    #[serde(rename = "personB")]
    pub person_b: CalculateMayanCompatibilityResponsePersonB,
    /// A RoxyAPI COMPOSITE, not a traditional rating. No classical source rates a pair of Tzolkin days, so this number is a floor of 45 plus the weight of every tie that holds, capped at 100. The components above are what is sourced; this is what we built out of them, and it is labelled so that nobody cites it as tradition.
    pub score: f64,
    /// One composed sentence naming both nawals and the distance between them, for a headline above the component list. When no tie holds at all it says so, because that is the common case and a blank component list is not self explanatory.
    pub summary: String,
    /// Coarse band the composite score falls in: excellent, strong, workable or reserved. Built for badges and filters that should not hard code a threshold against a number whose weighting may be tuned.
    pub verdict: String,
}
/// The Tzolkin day the second person was born on.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateMayanCompatibilityResponsePersonB {
    /// Echo of the second birth date.
    pub date: String,
    /// Machine identifier of the Tzolkin day sign, always lowercase ASCII Yucatec whatever the lang parameter says, so it stays safe to compare against in code. The twenty ids run imix, ik, akbal, kan, chikchan, kimi, manik, lamat, muluk, ok, chuwen, eb, ben, ix, men, kib, kaban, etznab, kawak, ajaw.
    #[serde(rename = "daySign")]
    pub day_sign: String,
    /// The sixteenth century Yucatec spelling of the same sign, which is the form most printed reference tables and older sources use. Useful for matching a name a reader copied out of a book.
    #[serde(rename = "daySignClassic")]
    pub day_sign_classic: String,
    /// The Kʼicheʼ name of the same day from the living highland daykeeping tradition, which is the vocabulary a nawal reading in Guatemala uses. A parallel naming tradition rather than a translation, so it is identical under every lang.
    #[serde(rename = "daySignKiche")]
    pub day_sign_kiche: String,
    /// Display name of the day sign in the standard Maya orthography, where the ejective is written with a modifier letter rather than a typewriter quote. A proper noun carried as data, so it is identical under every lang.
    #[serde(rename = "daySignName")]
    pub day_sign_name: String,
    /// The Tzolkin coefficient, 1 to 13. This is the classical day number that runs alongside the twenty signs; it is not a rank and a 13 is not better than a 1. Nine of the thirteen carry a recorded character, which is returned separately.
    pub number: f64,
    /// The thirteen day period this day belongs to. The trecena is the unit a daykeeper reads a run of days in, and the sign it opens on is what gives the whole period its character.
    pub trecena: CalculateMayanCompatibilityResponsePersonBTrecena,
}
/// The thirteen day period this day belongs to. The trecena is the unit a daykeeper reads a run of days in, and the sign it opens on is what gives the whole period its character.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateMayanCompatibilityResponsePersonBTrecena {
    /// Position of this day inside its trecena, 1 to 13. Always equal to the coefficient, because a trecena is exactly one run of the coefficient.
    #[serde(rename = "dayOfTrecena")]
    pub day_of_trecena: f64,
    /// Which of the twenty thirteen day periods this day falls in, 1 to 20. Trecena 1 opens on 1 Imix.
    pub number: f64,
    /// Machine identifier of the day sign the trecena opens on, which the tradition reads as colouring all thirteen of its days.
    #[serde(rename = "rulingSign")]
    pub ruling_sign: String,
    /// Display name of the sign the trecena opens on. A proper noun carried as data.
    #[serde(rename = "rulingSignName")]
    pub ruling_sign_name: String,
}
/// The Tzolkin day the first person was born on.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateMayanCompatibilityResponsePersonA {
    /// Echo of the first birth date.
    pub date: String,
    /// Machine identifier of the Tzolkin day sign, always lowercase ASCII Yucatec whatever the lang parameter says, so it stays safe to compare against in code. The twenty ids run imix, ik, akbal, kan, chikchan, kimi, manik, lamat, muluk, ok, chuwen, eb, ben, ix, men, kib, kaban, etznab, kawak, ajaw.
    #[serde(rename = "daySign")]
    pub day_sign: String,
    /// The sixteenth century Yucatec spelling of the same sign, which is the form most printed reference tables and older sources use. Useful for matching a name a reader copied out of a book.
    #[serde(rename = "daySignClassic")]
    pub day_sign_classic: String,
    /// The Kʼicheʼ name of the same day from the living highland daykeeping tradition, which is the vocabulary a nawal reading in Guatemala uses. A parallel naming tradition rather than a translation, so it is identical under every lang.
    #[serde(rename = "daySignKiche")]
    pub day_sign_kiche: String,
    /// Display name of the day sign in the standard Maya orthography, where the ejective is written with a modifier letter rather than a typewriter quote. A proper noun carried as data, so it is identical under every lang.
    #[serde(rename = "daySignName")]
    pub day_sign_name: String,
    /// The Tzolkin coefficient, 1 to 13. This is the classical day number that runs alongside the twenty signs; it is not a rank and a 13 is not better than a 1. Nine of the thirteen carry a recorded character, which is returned separately.
    pub number: f64,
    /// The thirteen day period this day belongs to. The trecena is the unit a daykeeper reads a run of days in, and the sign it opens on is what gives the whole period its character.
    pub trecena: CalculateMayanCompatibilityResponsePersonATrecena,
}
/// The thirteen day period this day belongs to. The trecena is the unit a daykeeper reads a run of days in, and the sign it opens on is what gives the whole period its character.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateMayanCompatibilityResponsePersonATrecena {
    /// Position of this day inside its trecena, 1 to 13. Always equal to the coefficient, because a trecena is exactly one run of the coefficient.
    #[serde(rename = "dayOfTrecena")]
    pub day_of_trecena: f64,
    /// Which of the twenty thirteen day periods this day falls in, 1 to 20. Trecena 1 opens on 1 Imix.
    pub number: f64,
    /// Machine identifier of the day sign the trecena opens on, which the tradition reads as colouring all thirteen of its days.
    #[serde(rename = "rulingSign")]
    pub ruling_sign: String,
    /// Display name of the sign the trecena opens on. A proper noun carried as data.
    #[serde(rename = "rulingSignName")]
    pub ruling_sign_name: String,
}
/// The conventions this comparison was computed under. The direction scheme is echoed because one of the five ties is read off the world directions, which the two schemes assign differently.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateMayanCompatibilityResponseConventions {
    /// The correlation constant actually applied, whether it was requested or defaulted. Store this beside any Maya date you persist: the same civil date resolves to a different Long Count under each constant, and a date with no correlation recorded cannot be reproduced.
    pub correlation: String,
    /// The direction reading actually applied. The two readings sit one quarter turn apart, so a direction stored without this value is ambiguous.
    #[serde(rename = "directionScheme")]
    pub direction_scheme: String,
}
/// One entry of `components`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateMayanCompatibilityResponseComponentsItem {
    /// Whether this tie holds for the pair. Every component is returned whether it holds or not, so a caller can render the misses as well as the hits.
    pub holds: bool,
    /// Which tie this row reports: same-sign, same-trecena, same-number, cross-partner or shared-direction. Always English so it stays safe to switch on.
    pub id: String,
    /// One line on what this tie means. Present ONLY when the tie holds, so a caller can render the hits without filtering and a miss carries no sentence to explain away.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reading: Option<String>,
    /// Points this tie contributes to the score when it holds, and nothing when it does not. The weights are published rather than hidden precisely because the weighting is ours rather than traditional.
    pub weight: f64,
}
/// Request body of `calculateMayanCompatibility`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateMayanCompatibilityRequest {
    /// Which correlation constant ties the day count to a civil date. This is the single choice that shifts every value in the response, so it is a parameter rather than a hidden default, and the resolved value comes back under conventions. "gmt-584283" is the commonly accepted constant and the default, and it is the one the major institutional converter runs on. "martinez-hernandez-584281" sits two days earlier, "astronomical-584285" two days later, and "martin-skidmore-584286" three days later, each shifting the Long Count by exactly its difference in days. Four of the eight published constants are offered: the other four sit tens of thousands of days away and are of historical interest only. The 584281 constant is the Martínez Hernández correlation, after Juan Martínez Hernández.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub correlation: Option<CalculateMayanCompatibilityRequestCorrelation>,
    /// Which reading of the world direction and colour to serve for a day sign. The two published assignments differ by exactly one quarter turn on all twenty signs, so neither is a rounding of the other and a silent pick would be a school choice. "madrid-codex" is the codex reading and the default; "landa" is the sixteenth century assignment recorded beside it.
    #[serde(rename = "directionScheme", skip_serializing_if = "Option::is_none")]
    pub direction_scheme: Option<CalculateMayanCompatibilityRequestDirectionScheme>,
    /// The first person, by birth date. Only a date is needed: the Tzolkin is a day count, so no time, timezone or place changes the answer.
    #[serde(rename = "personA")]
    pub person_a: CalculateMayanCompatibilityRequestPersonA,
    /// The second person, by birth date. The comparison is symmetric except for the cross tie, which is checked in both directions.
    #[serde(rename = "personB")]
    pub person_b: CalculateMayanCompatibilityRequestPersonB,
}
/// The second person, by birth date. The comparison is symmetric except for the cross tie, which is checked in both directions.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateMayanCompatibilityRequestPersonB {
    /// Date in YYYY-MM-DD format, in the PROLEPTIC GREGORIAN calendar, extended backwards unchanged through the 1582 reform. Years 1 to 4000 are accepted. A reference converter that switches to the Julian calendar below the reform will disagree with a date before 15 October 1582 by ten or eleven days; that is a difference of input convention rather than of arithmetic, and passing the Julian equivalent to such a tool reproduces these values exactly. A single-digit month or day is accepted and zero padded.
    pub date: String,
}
/// The first person, by birth date. Only a date is needed: the Tzolkin is a day count, so no time, timezone or place changes the answer.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateMayanCompatibilityRequestPersonA {
    /// Date in YYYY-MM-DD format, in the PROLEPTIC GREGORIAN calendar, extended backwards unchanged through the 1582 reform. Years 1 to 4000 are accepted. A reference converter that switches to the Julian calendar below the reform will disagree with a date before 15 October 1582 by ten or eleven days; that is a difference of input convention rather than of arithmetic, and passing the Julian equivalent to such a tool reproduces these values exactly. A single-digit month or day is accepted and zero padded.
    pub date: String,
}
string_enum! {
    /// Which reading of the world direction and colour to serve for a day sign. The two published assignments differ by exactly one quarter turn on all twenty signs, so neither is a rounding of the other and a silent pick would be a school choice. "madrid-codex" is the codex reading and the default; "landa" is the sixteenth century assignment recorded beside it.
    CalculateMayanCompatibilityRequestDirectionScheme {
        MadridCodex = "madrid-codex",
        Landa = "landa",
    }
}
string_enum! {
    /// Which correlation constant ties the day count to a civil date. This is the single choice that shifts every value in the response, so it is a parameter rather than a hidden default, and the resolved value comes back under conventions. "gmt-584283" is the commonly accepted constant and the default, and it is the one the major institutional converter runs on. "martinez-hernandez-584281" sits two days earlier, "astronomical-584285" two days later, and "martin-skidmore-584286" three days later, each shifting the Long Count by exactly its difference in days. Four of the eight published constants are offered: the other four sit tens of thousands of days away and are of historical interest only. The 584281 constant is the Martínez Hernández correlation, after Juan Martínez Hernández.
    CalculateMayanCompatibilityRequestCorrelation {
        Gmt584283 = "gmt-584283",
        MartinezHernandez584281 = "martinez-hernandez-584281",
        Astronomical584285 = "astronomical-584285",
        MartinSkidmore584286 = "martin-skidmore-584286",
    }
}
/// Path and query parameters of `calculateMayanCompatibility`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateMayanCompatibilityParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateMayanCompatibilityParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateMayanCompatibilityParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateMaturity`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateMaturityResponse {
    /// Full step-by-step reduction showing Life Path plus Expression combined and reduced to the final Maturity number. This synthesis represents the convergence of your life purpose and natural talents into mature wisdom.
    pub calculation: String,
    /// Indicates whether a Karmic Debt number (13, 14, 16, or 19) appeared during the Life Path plus Expression reduction. Karmic Debt in the Maturity position reveals past-life lessons that surface during midlife transformation, typically after age 35 to 40.
    #[serde(rename = "hasKarmicDebt")]
    pub has_karmic_debt: bool,
    /// Detailed interpretation of the Karmic Debt number when present. Only returned when hasKarmicDebt is true.
    #[serde(rename = "karmicDebtMeaning", skip_serializing_if = "Option::is_none")]
    pub karmic_debt_meaning: Option<CalculateMaturityResponseKarmicDebtMeaning>,
    /// The specific Karmic Debt number detected during the Maturity reduction, if any. Each debt number (13, 14, 16, 19) represents a distinct past-life challenge that becomes especially prominent as you enter the second half of life.
    #[serde(rename = "karmicDebtNumber", skip_serializing_if = "Option::is_none")]
    pub karmic_debt_number: Option<f64>,
    /// The `meaning` field.
    pub meaning: CalculateMaturityResponseMeaning,
    /// Your Maturity number (also called Realization number), revealing who you are becoming in the second half of life. Derived from the sum of your Life Path and Expression numbers. Values range from 1 to 9 for single digits, or 11, 22, 33 for Master Numbers.
    pub number: f64,
    /// Whether this is a standard single-digit number (1 to 9) or a Master Number (11, 22, 33). Master Numbers in the Maturity position indicate a powerful late-life awakening with extraordinary potential for spiritual leadership and legacy.
    pub r#type: CalculateMaturityResponseType,
}
string_enum! {
    /// Whether this is a standard single-digit number (1 to 9) or a Master Number (11, 22, 33). Master Numbers in the Maturity position indicate a powerful late-life awakening with extraordinary potential for spiritual leadership and legacy.
    CalculateMaturityResponseType {
        Single = "single",
        Master = "master",
    }
}
/// The `meaning` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateMaturityResponseMeaning {
    /// Career evolution and professional reinvention for the second act. Covers industries, roles, and pursuits that align with your mature energy and accumulated wisdom.
    pub career: String,
    /// Growth areas to watch as Maturity energy intensifies. Understanding these early helps you navigate the transition with awareness and grace.
    pub challenges: Vec<String>,
    /// Core interpretation of the person being grown into in the second half of life, the wisdom gained through lived experience. Together with the strengths, challenges, career, relationships and spirituality fields it makes a full reading.
    pub description: String,
    /// Emerging traits and qualities that strengthen after age 35 to 40. These energies gradually integrate into your personality as you mature.
    pub keywords: Vec<String>,
    /// How your relationships deepen and transform as Maturity energy takes hold. Covers evolving partnership needs, family dynamics, and the relationship wisdom that comes with age.
    pub relationships: String,
    /// Spiritual awakening in the mature years. Explores the deeper meaning that emerges when life experience meets the Maturity number, and practices for this transformative phase.
    pub spirituality: String,
    /// Late-blooming strengths that emerge with age and experience. These are the gifts that become your greatest assets in the second half of life.
    pub strengths: Vec<String>,
    /// Numerology archetype for the Maturity number. Reveals who you are becoming in the second half of life, such as "The Builder" for 4 or "The Humanitarian" for 9.
    pub title: String,
}
/// Detailed interpretation of the Karmic Debt number when present. Only returned when hasKarmicDebt is true.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateMaturityResponseKarmicDebtMeaning {
    /// The specific challenge from past lives that must be confronted.
    pub challenge: String,
    /// Title describing the karmic debt theme and core past-life pattern.
    pub description: String,
    /// Practical guidance for resolving the karmic debt.
    pub resolution: String,
}
/// Path and query parameters of `calculateMaturity`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateMaturityParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateMaturityParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateMaturityParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateLunarDate`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateLunarDateResponse {
    /// The Gregorian date, echoed when one was sent and computed when the lunar fields were. Echoes the request, or the current UTC date when neither side was supplied.
    #[serde(rename = "gregorianDate")]
    pub gregorian_date: String,
    /// The month this lunisolar year repeats, when it has thirteen months. Absent in a twelve month year, so a caller can branch on presence rather than on a sentinel.
    #[serde(rename = "leapMonthOfYear", skip_serializing_if = "Option::is_none")]
    pub leap_month_of_year: Option<f64>,
    /// The `lunar` field.
    pub lunar: CalculateLunarDateResponseLunar,
    /// Decimal UTC offset the calendar was evaluated at. Fixed at 8, which is what makes a Chinese lunar date a world constant.
    #[serde(rename = "referenceOffset")]
    pub reference_offset: f64,
}
/// The `lunar` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateLunarDateResponseLunar {
    /// The Gregorian date this lunar day covers, evaluated at the reference meridian.
    pub date: String,
    /// Day of the lunar month, 1 to 30. A lunar month never has 31 days.
    pub day: f64,
    /// True when this is the leap repetition of the month number rather than the first pass through it.
    #[serde(rename = "isLeapMonth")]
    pub is_leap_month: bool,
    /// Lunar month, 1 to 12. A leap month repeats the number of the month it follows.
    pub month: f64,
    /// Days in this lunar month, 29 for a short month or 30 for a long one. It is the interval between two new moons, so it varies month to month.
    #[serde(rename = "monthLength")]
    pub month_length: f64,
    /// Lunisolar year. It advances on the first day of month 1, not at Li Chun, so it can lag the Gregorian year by up to seven weeks.
    pub year: f64,
}
/// Path and query parameters of `calculateLunarDate`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateLunarDateParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateLunarDateParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateLunarDateParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateLuckPillars`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateLuckPillarsResponse {
    /// Year-by-year overlay, present only when annualFromYear was sent. Each year names the luck pillar it falls inside.
    #[serde(rename = "annualPillars", skip_serializing_if = "Option::is_none")]
    pub annual_pillars: Option<Vec<CalculateLuckPillarsResponseAnnualPillarsItem>>,
    /// Echo of the birth moment the chart was computed from.
    #[serde(rename = "birthData")]
    pub birth_data: CalculateLuckPillarsResponseBirthData,
    /// The minor solar term the count ran to. One of the twelve that also move the month pillar. Always the pinyin identifier, whatever the lang parameter says.
    #[serde(rename = "boundaryTerm")]
    pub boundary_term: String,
    /// Display name of that same term, in the requested language. Always present, and English when lang is en. Several English renderings of a term are in circulation, so treat this as the label and boundaryTerm as the value.
    #[serde(rename = "boundaryTermName")]
    pub boundary_term_name: String,
    /// The three school conventions this result was computed under. Returned on every BaZi response so a chart is self-describing: two calculators can produce different pillars for one birth and both be correct, and this object says which reading you are holding.
    pub conventions: CalculateLuckPillarsResponseConventions,
    /// Days from the birth instant to the minor solar term the count ran to, before conversion. Published so the start age can be checked rather than taken on trust.
    #[serde(rename = "daysToTerm")]
    pub days_to_term: f64,
    /// Which way the sequence walks the sexagenary cycle. A male born in a yang-stem year and a female born in a yin-stem year run forward, and the other two combinations run backward. Always English, whatever the lang parameter says.
    pub direction: String,
    /// Echo of the sex sent, which is what selected the direction below.
    pub gender: String,
    /// The ten-year periods in order, each with the relation its stem holds to the natal Day Master.
    #[serde(rename = "luckPillars")]
    pub luck_pillars: Vec<CalculateLuckPillarsResponseLuckPillarsItem>,
    /// Age in whole years at which the first luck pillar begins. Counted from the birth instant to the adjacent minor solar term at three days to the year, forward for a forward direction and backward for a reverse one.
    #[serde(rename = "startAge")]
    pub start_age: f64,
    /// Additional months past startAge, 0 to 11, from the remainder of the same count at one day to four months. Calculators that round the whole count to the nearest year will differ from this by up to six months.
    #[serde(rename = "startAgeMonths")]
    pub start_age_months: f64,
    /// One-paragraph reading of the sequence direction and its start.
    pub summary: String,
}
/// One entry of `luckPillars`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateLuckPillarsResponseLuckPillarsItem {
    /// The Earthly Branch of this luck pillar, with its animal, element and polarity.
    pub branch: CalculateLuckPillarsResponseLuckPillarsItemBranch,
    /// Age in whole years at which this period ends and the next one begins.
    #[serde(rename = "endAge")]
    pub end_age: f64,
    /// Gregorian year this period ends.
    #[serde(rename = "endYear")]
    pub end_year: f64,
    /// Pillar identifier, the stem id and the branch id joined by a hyphen.
    pub id: String,
    /// Position in the sequence, starting at 1 for the first ten-year period.
    pub index: f64,
    /// Position of this pillar in the sexagenary cycle, 1 to 60. Consecutive luck pillars always differ by exactly one step, forward or backward, because the sequence walks the cycle from the birth month pillar.
    pub number: f64,
    /// Age in whole years at which this ten-year period begins.
    #[serde(rename = "startAge")]
    pub start_age: f64,
    /// Gregorian year this period begins, the birth year plus startAge.
    #[serde(rename = "startYear")]
    pub start_year: f64,
    /// The Heavenly Stem of this luck pillar, with its element and polarity.
    pub stem: CalculateLuckPillarsResponseLuckPillarsItemStem,
    /// Relation the luck pillar STEM holds to the natal Day Master. This is what tells you whether a decade supports the chart or spends it.
    #[serde(rename = "tenGod")]
    pub ten_god: CalculateLuckPillarsResponseLuckPillarsItemTenGod,
}
/// Relation the luck pillar STEM holds to the natal Day Master. This is what tells you whether a decade supports the chart or spends it.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateLuckPillarsResponseLuckPillarsItemTenGod {
    /// Which of the five cycle relations this belongs to. peer is the same element as the Day Master, output is what the Day Master generates, wealth is what it controls, influence is what controls it, resource is what generates it, and self marks the Day Master itself. Always English, whatever the lang parameter says.
    pub category: String,
    /// The relation in traditional hanzi. Identical under every lang.
    pub chinese: String,
    /// Ten God identifier. One of friend, rob-wealth, eating-god, hurting-officer, indirect-wealth, direct-wealth, seven-killings, direct-officer, indirect-resource, direct-resource, plus day-master in the day-stem position. Always English, whatever the lang parameter says.
    pub id: String,
    /// One-line summary of what this relation contributes, for a compact rendering that has no room for the full meaning.
    pub keynote: String,
    /// Display name of the relation. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Ten God name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone-marked pinyin for the relation. Identical under every lang.
    pub pinyin: String,
}
/// The Heavenly Stem of this luck pillar, with its element and polarity.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateLuckPillarsResponseLuckPillarsItemStem {
    /// The stem in hanzi. Data rather than display copy, so it is identical under every lang.
    pub chinese: String,
    /// Five-phase element of the stem. One of Wood, Fire, Earth, Metal, Water. Always English, whatever the lang parameter says. Use elementLocalized for anything a reader sees.
    pub element: String,
    /// Element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Heavenly Stem identifier. One of jia, yi, bing, ding, wu, ji, geng, xin, ren, gui. Always English pinyin, whatever the lang parameter says, so it stays safe to compare against in code and to key a glyph table on.
    pub id: String,
    /// Tone-marked pinyin for the stem. Identical under every lang.
    pub pinyin: String,
    /// Polarity of the stem, yang or yin. The five odd stems are yang and the five even ones are yin, and this is half of what decides every Ten God relation in the chart.
    pub polarity: String,
}
/// The Earthly Branch of this luck pillar, with its animal, element and polarity.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateLuckPillarsResponseLuckPillarsItemBranch {
    /// Zodiac animal of the branch. One of rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, pig. Always English, whatever the lang parameter says. Use animalLocalized for anything a reader sees.
    pub animal: String,
    /// Zodiac animal name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "animalLocalized", skip_serializing_if = "Option::is_none")]
    pub animal_localized: Option<String>,
    /// The branch in hanzi. Identical under every lang.
    pub chinese: String,
    /// Five-phase element of the branch. Always English, whatever the lang parameter says. Use elementLocalized for anything a reader sees.
    pub element: String,
    /// Element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Earthly Branch identifier. One of zi, chou, yin, mao, chen, si, wu, wei, shen, you, xu, hai. Always English pinyin, whatever the lang parameter says. Note that "wu" is also a stem identifier: they never share a field, so a branch id is only ever read out of a branch position.
    pub id: String,
    /// Tone-marked pinyin for the branch. Identical under every lang.
    pub pinyin: String,
    /// Polarity of the branch, yang or yin.
    pub polarity: String,
}
/// The three school conventions this result was computed under. Returned on every BaZi response so a chart is self-describing: two calculators can produce different pillars for one birth and both be correct, and this object says which reading you are holding.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateLuckPillarsResponseConventions {
    /// Day-boundary school actually applied. Echoes the request, or the default when it was omitted. Always English, whatever the lang parameter says, so it stays safe to compare against in code.
    #[serde(rename = "dayBoundary")]
    pub day_boundary: CalculateLuckPillarsResponseConventionsDayBoundary,
    /// Hour clock actually applied. Echoes the request, or the default when omitted.
    #[serde(rename = "hourClock")]
    pub hour_clock: CalculateLuckPillarsResponseConventionsHourClock,
    /// Year-boundary school actually applied. Echoes the request, or the default when it was omitted.
    #[serde(rename = "yearBoundary")]
    pub year_boundary: CalculateLuckPillarsResponseConventionsYearBoundary,
}
string_enum! {
    /// Year-boundary school actually applied. Echoes the request, or the default when it was omitted.
    CalculateLuckPillarsResponseConventionsYearBoundary {
        LiChun = "li-chun",
        LunarNewYear = "lunar-new-year",
    }
}
string_enum! {
    /// Hour clock actually applied. Echoes the request, or the default when omitted.
    CalculateLuckPillarsResponseConventionsHourClock {
        Clock = "clock",
        LocalMean = "local-mean",
        Solar = "solar",
    }
}
string_enum! {
    /// Day-boundary school actually applied. Echoes the request, or the default when it was omitted. Always English, whatever the lang parameter says, so it stays safe to compare against in code.
    CalculateLuckPillarsResponseConventionsDayBoundary {
        SplitZi = "split-zi",
        Midnight = "midnight",
        EarlyZi = "early-zi",
    }
}
/// Echo of the birth moment the chart was computed from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateLuckPillarsResponseBirthData {
    /// Birth date in YYYY-MM-DD format. Sets the year, month and day pillars. The year pillar turns at Beginning of Spring rather than on 1 January, and the month pillar turns at each of the twelve minor solar terms rather than at a calendar month boundary.
    pub date: String,
    /// Birth latitude in decimal degrees. Accepted for consistency with the other birth-data endpoints and does not affect any part of a BaZi chart. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Positive is East, negative is West. Required when hourClock is "local-mean" or "solar", which shift the hour branch to the sun over the birth place; omitting it in either case returns 400. Ignored when hourClock is "clock".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Birth time in 24-hour HH:MM:SS format. Sets the hour pillar, which is one of the four and carries the whole picture of later life and offspring. Each Earthly Branch covers two hours, so a birth within a few minutes of an odd hour can land in either. All four pillars are read in the local clock of the birth, and the day boundary is applied in that same clock; only the lunisolar calendar date itself is a world constant, fixed at UTC plus 8 so one instant has one Chinese date everywhere.
    pub time: String,
    /// Decimal UTC offset the chart was computed with, resolved from whatever the request sent. An IANA name is resolved to the offset in force at the birth, so this is the literal number applied and never the name. A local time that never happened (the skipped hour of a daylight-saving change) is moved forward past the gap, and date, time and timezone then echo the clock that was running, which the day and hour pillars are read from.
    pub timezone: f64,
}
/// One entry of `annualPillars`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateLuckPillarsResponseAnnualPillarsItem {
    /// Annual pillar identifier for that year, under the year boundary applied.
    pub id: String,
    /// Which returned luck pillar this year falls inside, by its index. 0 means the year falls before the first luck pillar begins, in the stretch still governed by the natal chart alone.
    #[serde(rename = "luckPillarIndex")]
    pub luck_pillar_index: f64,
    /// Position of the annual pillar in the sexagenary cycle, 1 to 60.
    pub number: f64,
    /// Relation the annual pillar STEM holds to the natal Day Master.
    #[serde(rename = "tenGod")]
    pub ten_god: CalculateLuckPillarsResponseAnnualPillarsItemTenGod,
    /// Gregorian year.
    pub year: f64,
}
/// Relation the annual pillar STEM holds to the natal Day Master.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateLuckPillarsResponseAnnualPillarsItemTenGod {
    /// Which of the five cycle relations this belongs to. peer is the same element as the Day Master, output is what the Day Master generates, wealth is what it controls, influence is what controls it, resource is what generates it, and self marks the Day Master itself. Always English, whatever the lang parameter says.
    pub category: String,
    /// The relation in traditional hanzi. Identical under every lang.
    pub chinese: String,
    /// Ten God identifier. One of friend, rob-wealth, eating-god, hurting-officer, indirect-wealth, direct-wealth, seven-killings, direct-officer, indirect-resource, direct-resource, plus day-master in the day-stem position. Always English, whatever the lang parameter says.
    pub id: String,
    /// One-line summary of what this relation contributes, for a compact rendering that has no room for the full meaning.
    pub keynote: String,
    /// Display name of the relation. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Ten God name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone-marked pinyin for the relation. Identical under every lang.
    pub pinyin: String,
}
/// Request body of `calculateLuckPillars`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateLuckPillarsRequest {
    /// First Gregorian year of the annual pillar overlay. Omit it to leave annualPillars out of the response entirely. The annual pillar is the year the chart is currently walking through, read against the ten-year luck pillar underneath it.
    #[serde(rename = "annualFromYear", skip_serializing_if = "Option::is_none")]
    pub annual_from_year: Option<i64>,
    /// How many consecutive years the annual overlay covers, 1 to 20. Ignored unless annualFromYear is present.
    #[serde(rename = "annualYears", skip_serializing_if = "Option::is_none")]
    pub annual_years: Option<i64>,
    /// How many ten-year luck pillars to return, 1 to 12. Eight covers eighty years from the start age, which reaches past a normal lifetime for most start ages.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub count: Option<i64>,
    /// Birth date in YYYY-MM-DD format. Sets the year, month and day pillars. The year pillar turns at Beginning of Spring rather than on 1 January, and the month pillar turns at each of the twelve minor solar terms rather than at a calendar month boundary.
    pub date: String,
    /// Which instant starts the sexagenary DAY, which only matters for a birth between 23:00 and 23:59. "midnight" is the classical position of the Ming compendium San Ming Tong Hui: the day turns at 00:00 and 23:00 to 23:59 is the late zi hour of the day that is ending, so the hour stem is taken from that day. "early-zi" turns the whole day at 23:00, the practice in Hong Kong, Taiwan and much of South East Asia. "split-zi" is the compromise most software implements and the default here: the day still turns at 00:00, but the hour stem is taken from the next day. The three give three different answers for a late-evening birth and identical answers for every other birth.
    #[serde(rename = "dayBoundary", skip_serializing_if = "Option::is_none")]
    pub day_boundary: Option<CalculateLuckPillarsRequestDayBoundary>,
    /// Subject sex, used only to pick the luck-pillar direction: a male born in a yang-stem year and a female born in a yin-stem year run forward through the sexagenary cycle, and the other two combinations run backward. It affects nothing else in the response.
    pub gender: CalculateLuckPillarsRequestGender,
    /// Which clock the day boundary and the hour branch are read from, so a correction that carries a birth across midnight moves the day pillar with the hour. "clock" is civil time exactly as a birth certificate records it, which is what most calculators use and the default here. "local-mean" shifts to the mean sun over the birth longitude, a correction of up to 59 minutes at the edge of a wide time zone. "solar" adds the equation of time on top of that, up to a further 16 minutes. Both non-civil options need "longitude" in the request and return 400 without it.
    #[serde(rename = "hourClock", skip_serializing_if = "Option::is_none")]
    pub hour_clock: Option<CalculateLuckPillarsRequestHourClock>,
    /// Birth latitude in decimal degrees. Accepted for consistency with the other birth-data endpoints and does not affect any part of a BaZi chart. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Positive is East, negative is West. Required when hourClock is "local-mean" or "solar", which shift the hour branch to the sun over the birth place; omitting it in either case returns 400. Ignored when hourClock is "clock".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Birth time in 24-hour HH:MM:SS format. Sets the hour pillar, which is one of the four and carries the whole picture of later life and offspring. Each Earthly Branch covers two hours, so a birth within a few minutes of an odd hour can land in either. All four pillars are read in the local clock of the birth, and the day boundary is applied in that same clock; only the lunisolar calendar date itself is a world constant, fixed at UTC plus 8 so one instant has one Chinese date everywhere.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: CalculateLuckPillarsRequestTimezone,
    /// Which instant starts the sexagenary YEAR. "li-chun" is Beginning of Spring, around 4 February, and is the classical rule every BaZi text uses, so it is the default on this endpoint. "lunar-new-year" is the folk rule people mean when they say which animal they are, and it falls between late January and late February. The two disagree for any birth in the weeks between them: 14 February 2026 is a Wood Snake year under lunar-new-year and a Fire Horse year under li-chun.
    #[serde(rename = "yearBoundary", skip_serializing_if = "Option::is_none")]
    pub year_boundary: Option<CalculateLuckPillarsRequestYearBoundary>,
}
string_enum! {
    /// Which instant starts the sexagenary YEAR. "li-chun" is Beginning of Spring, around 4 February, and is the classical rule every BaZi text uses, so it is the default on this endpoint. "lunar-new-year" is the folk rule people mean when they say which animal they are, and it falls between late January and late February. The two disagree for any birth in the weeks between them: 14 February 2026 is a Wood Snake year under lunar-new-year and a Fire Horse year under li-chun.
    CalculateLuckPillarsRequestYearBoundary {
        LiChun = "li-chun",
        LunarNewYear = "lunar-new-year",
    }
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateLuckPillarsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Which clock the day boundary and the hour branch are read from, so a correction that carries a birth across midnight moves the day pillar with the hour. "clock" is civil time exactly as a birth certificate records it, which is what most calculators use and the default here. "local-mean" shifts to the mean sun over the birth longitude, a correction of up to 59 minutes at the edge of a wide time zone. "solar" adds the equation of time on top of that, up to a further 16 minutes. Both non-civil options need "longitude" in the request and return 400 without it.
    CalculateLuckPillarsRequestHourClock {
        Clock = "clock",
        LocalMean = "local-mean",
        Solar = "solar",
    }
}
string_enum! {
    /// Subject sex, used only to pick the luck-pillar direction: a male born in a yang-stem year and a female born in a yin-stem year run forward through the sexagenary cycle, and the other two combinations run backward. It affects nothing else in the response.
    CalculateLuckPillarsRequestGender {
        Male = "male",
        Female = "female",
    }
}
string_enum! {
    /// Which instant starts the sexagenary DAY, which only matters for a birth between 23:00 and 23:59. "midnight" is the classical position of the Ming compendium San Ming Tong Hui: the day turns at 00:00 and 23:00 to 23:59 is the late zi hour of the day that is ending, so the hour stem is taken from that day. "early-zi" turns the whole day at 23:00, the practice in Hong Kong, Taiwan and much of South East Asia. "split-zi" is the compromise most software implements and the default here: the day still turns at 00:00, but the hour stem is taken from the next day. The three give three different answers for a late-evening birth and identical answers for every other birth.
    CalculateLuckPillarsRequestDayBoundary {
        SplitZi = "split-zi",
        Midnight = "midnight",
        EarlyZi = "early-zi",
    }
}
/// Path and query parameters of `calculateLuckPillars`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateLuckPillarsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateLuckPillarsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateLuckPillarsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateLifePath`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateLifePathResponse {
    /// Every step of the calculation: the birth month, day and year each reduced, then combined into the final Life Path number.
    pub calculation: String,
    /// Indicates whether a Karmic Debt number (13, 14, 16, or 19) appeared during the reduction chain. Karmic Debt reveals past-life challenges carried into this lifetime.
    #[serde(rename = "hasKarmicDebt")]
    pub has_karmic_debt: bool,
    /// Detailed interpretation of the Karmic Debt number when present. Only returned when hasKarmicDebt is true.
    #[serde(rename = "karmicDebtMeaning", skip_serializing_if = "Option::is_none")]
    pub karmic_debt_meaning: Option<CalculateLifePathResponseKarmicDebtMeaning>,
    /// The specific Karmic Debt number detected during reduction, if any. Each debt number (13, 14, 16, 19) represents a distinct past-life lesson requiring resolution.
    #[serde(rename = "karmicDebtNumber", skip_serializing_if = "Option::is_none")]
    pub karmic_debt_number: Option<f64>,
    /// The `meaning` field.
    pub meaning: CalculateLifePathResponseMeaning,
    /// Your Life Path number, the single most important number in Pythagorean numerology. Values range from 1 to 9 for single digits, or 11, 22, 33 for Master Numbers.
    pub number: f64,
    /// Whether this is a standard single-digit number (1 to 9) or a Master Number (11, 22, 33). Master Numbers carry amplified spiritual significance and are never reduced further.
    pub r#type: CalculateLifePathResponseType,
}
string_enum! {
    /// Whether this is a standard single-digit number (1 to 9) or a Master Number (11, 22, 33). Master Numbers carry amplified spiritual significance and are never reduced further.
    CalculateLifePathResponseType {
        Single = "single",
        Master = "master",
    }
}
/// The `meaning` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateLifePathResponseMeaning {
    /// Tailored career guidance covering ideal industries, roles, and work environments. Includes specific job titles and explains why certain professional paths align with this number.
    pub career: String,
    /// Growth areas and shadow qualities to be aware of. Each entry names the challenge and explains its root cause and how to work through it constructively.
    pub challenges: Vec<String>,
    /// Core interpretation of the number covering personality, purpose and life themes. Together with the strengths, challenges, career, relationships and spirituality fields it makes a full-page reading.
    pub description: String,
    /// Defining personality traits and energetic themes of this number. Useful for quick personality snapshots, tag clouds and compatibility matching.
    pub keywords: Vec<String>,
    /// Love, friendship, and family dynamics. Covers romantic compatibility with other Life Path numbers, communication style, and the key relationship lessons for this number.
    pub relationships: String,
    /// Spiritual path, soul lessons, and recommended practices. Explores the deeper purpose behind this number and offers guidance for personal growth and inner alignment.
    pub spirituality: String,
    /// Core strengths and positive qualities. Each entry includes a trait name followed by a detailed explanation of how it manifests in daily life.
    pub strengths: Vec<String>,
    /// Numerology archetype name for this Life Path number. Encapsulates the core identity and energy in a single phrase, such as "The Leader" for 1 or "The Master Builder" for 22.
    pub title: String,
}
/// Detailed interpretation of the Karmic Debt number when present. Only returned when hasKarmicDebt is true.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateLifePathResponseKarmicDebtMeaning {
    /// The specific challenge or pattern from past lives that must be confronted.
    pub challenge: String,
    /// Title describing the karmic debt theme and core past-life pattern.
    pub description: String,
    /// Practical guidance for resolving the karmic debt and transforming the challenge into growth.
    pub resolution: String,
}
/// Path and query parameters of `calculateLifePath`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateLifePathParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateLifePathParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateLifePathParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateKuaNumber`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateKuaNumberResponse {
    /// Calendar date of the boundary that decided the year, computed astronomically rather than assumed. Li Chun is commonly quoted as 4 February and lands on the 3rd or the 5th in roughly one year in four.
    #[serde(rename = "boundaryDate")]
    pub boundary_date: String,
    /// The `conventions` field.
    pub conventions: CalculateKuaNumberResponseConventions,
    /// Echo of the sex sent, which selected the formula variant.
    pub gender: String,
    /// Life group, east or west. East group Kuas are 1, 3, 4 and 9 and share North, East, Southeast and South as their favourable sectors; west group Kuas are 2, 6, 7 and 8 and share Northeast, Southwest, West and Northwest. Always English, safe to compare against.
    pub group: String,
    /// Kua number, 1 to 9 excluding 5. This is the value every other feng shui calculation about a person keys on.
    pub kua: f64,
    /// The formula output before any reassignment. Equal to kua except when the formula produced 5, which has no trigram and no direction and must be moved.
    #[serde(rename = "rawKua")]
    pub raw_kua: f64,
    /// Whether the raw result was 5 and had to be moved onto a trigram, to 2 for a man and to 8 for a woman.
    pub reassigned: bool,
    /// All eight sectors classified for this Kua, in compass order from North. Exactly four are auspicious and four are inauspicious, and the two sets partition the compass. Call the eight mansions endpoint for the same map with full readings and ranked placement guidance.
    pub sectors: Vec<CalculateKuaNumberResponseSectorsItem>,
    /// The Chinese year the birth date fell in under the boundary applied. This is the year the formula actually used, which is the previous calendar year for an early-in-the-year birthday.
    #[serde(rename = "solarYear")]
    pub solar_year: f64,
    /// The `trigram` field.
    pub trigram: CalculateKuaNumberResponseTrigram,
}
/// The `trigram` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateKuaNumberResponseTrigram {
    /// Three lines bottom to top, 1 for yang and 0 for yin. The Eight Mansions classification of any sector is decided by which of these three lines differ from your own trigram.
    pub binary: String,
    /// Chinese character for the trigram. Data, identical in every language.
    pub chinese: String,
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against in code and against the same value on the I-Ching trigram endpoints.
    pub direction: String,
    /// Compass sector in the requested language, for display only, the same word the composed readings use. Present only when lang is set to a language other than English. Never compare against this value.
    #[serde(rename = "directionLocalized", skip_serializing_if = "Option::is_none")]
    pub direction_localized: Option<String>,
    /// Five phase of this entry: Wood, Fire, Earth, Metal or Water. Always English so it stays safe to compare against and to key styling on. The full cycles live on the Chinese astrology elements endpoint.
    pub element: String,
    /// Five phase name in the requested language, for display only. Present only when lang is set to a language other than English. Never compare against this value.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// English name of the trigram, byte identical to the English value the I-Ching trigram endpoints publish for this number. Always English here, whatever the lang parameter says, so it stays safe to compare against. Use nameLocalized for anything a reader sees.
    pub english: String,
    /// Family role of the trigram. Read alongside an affliction to know which member of the household a sector points at. Always English, and it carries no localized sibling: no vocabulary this package ships names the eight family roles.
    #[serde(rename = "familyMember")]
    pub family_member: String,
    /// Trigram name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat english exactly. Never compare against this value.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Trigram number, 1 to 8, the same identifier the I-Ching trigram endpoints use. It is a lookup key, not a ranking.
    pub number: f64,
    /// Tone-marked pinyin for the trigram. Data, identical in every language.
    pub pinyin: String,
    /// Unicode trigram symbol, for rendering a Bagua diagram without an icon set.
    pub symbol: String,
}
/// One entry of `sectors`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateKuaNumberResponseSectorsItem {
    /// Compass sector, one of North, Northeast, East, Southeast, South, Southwest, West, Northwest. Always English, whatever the lang parameter says, so it stays safe to compare against in code and against the same value on the I-Ching trigram endpoints.
    pub direction: String,
    /// The life domain this sector governs, in a few words, written in the requested language.
    pub domain: String,
    /// Whether the sector helps or harms: auspicious or inauspicious.
    pub nature: String,
    /// Order within its nature, 1 to 4. Among auspicious sectors 1 is the strongest; among inauspicious sectors 1 is the mildest and 4 the most serious, which is what tells you which affliction to accept when no favourable sector is reachable.
    pub rank: f64,
    /// Eight Mansions star for this sector, one of sheng-chi, tian-yi, yan-nian, fu-wei, huo-hai, wu-gui, liu-sha, jue-ming. Always English, safe to compare against and to key styling on.
    pub star: String,
    /// Display name of the star. Always English, whatever the lang parameter says. Use starNameLocalized for anything a reader sees.
    #[serde(rename = "starName")]
    pub star_name: String,
    /// Star name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat starName exactly. Never compare against this value.
    #[serde(rename = "starNameLocalized", skip_serializing_if = "Option::is_none")]
    pub star_name_localized: Option<String>,
}
/// The `conventions` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateKuaNumberResponseConventions {
    /// Which boundary decided the Chinese year for this calculation. li-chun starts the year at the astronomical start of spring, in early February, and is the classical position that feng shui uses throughout. lunar-new-year starts it at the first day of the lunar year, which is usually two to four weeks later and is what most popular zodiac tables use. Echoes the resolved value, whether it was sent or defaulted.
    #[serde(rename = "yearBoundary")]
    pub year_boundary: String,
}
/// Request body of `calculateKuaNumber`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateKuaNumberRequest {
    /// Birth date in YYYY-MM-DD format. Only the Chinese YEAR this date falls in enters the formula, so no birth time, latitude or longitude is needed. A January or early February birthday is the case that matters: it usually belongs to the PREVIOUS Chinese year and produces a different Kua. A date is read at the start of its day, and the boundary falls part-way through its own day, so a birth date landing exactly on the boundary day is placed in the outgoing year.
    pub date: String,
    /// Selects the Kua formula variant. The two formulas are different arithmetic on the same year, and they also differ in where a raw result of 5 is reassigned.
    pub gender: CalculateKuaNumberRequestGender,
    /// Which boundary starts the Chinese year. Defaults to li-chun, the astronomical start of spring in early February, which is the classical position and the one feng shui uses for periods, annual stars and afflictions alike. Send lunar-new-year to match popular zodiac tables, which start the year two to four weeks later. The two disagree for anyone born between the two dates.
    #[serde(rename = "yearBoundary", skip_serializing_if = "Option::is_none")]
    pub year_boundary: Option<CalculateKuaNumberRequestYearBoundary>,
}
string_enum! {
    /// Which boundary starts the Chinese year. Defaults to li-chun, the astronomical start of spring in early February, which is the classical position and the one feng shui uses for periods, annual stars and afflictions alike. Send lunar-new-year to match popular zodiac tables, which start the year two to four weeks later. The two disagree for anyone born between the two dates.
    CalculateKuaNumberRequestYearBoundary {
        LiChun = "li-chun",
        LunarNewYear = "lunar-new-year",
    }
}
string_enum! {
    /// Selects the Kua formula variant. The two formulas are different arithmetic on the same year, and they also differ in where a raw result of 5 is reassigned.
    CalculateKuaNumberRequestGender {
        Male = "male",
        Female = "female",
    }
}
/// Path and query parameters of `calculateKuaNumber`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateKuaNumberParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateKuaNumberParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateKuaNumberParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Request body of `calculateHouses`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateHousesRequest {
    /// Birth date in YYYY-MM-DD format. Date is critical for house cusp calculations as it determines planetary positions used in some house systems.
    pub date: String,
    /// House system for dividing ecliptic into 12 houses. Placidus (most popular) uses time, Whole Sign (ancient) uses signs, Equal divides from Ascendant. Use "all" to compare all 4 systems side-by-side for educational purposes.
    #[serde(rename = "houseSystem", skip_serializing_if = "Option::is_none")]
    pub house_system: Option<CalculateHousesRequestHouseSystem>,
    /// Birth location latitude in decimal degrees (-90 to 90). Location determines the local horizon and meridian, which are fundamental to house division. Higher latitudes cause more distortion in time-based systems like Placidus.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Affects local time and horizon calculations for house cusps.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Time is ESSENTIAL for accurate house cusps, and even minutes matter. The Ascendant (1st house cusp) changes roughly every 4 minutes. Without accurate time, house placements will be incorrect.
    pub time: String,
    /// Decimal hours from UTC (e.g. -5 for EST, 5.5 for IST, 9 for JST) OR IANA name (e.g. "America/New_York"). IANA resolved to the DST-correct offset for the chart date.
    pub timezone: CalculateHousesRequestTimezone,
}
/// Decimal hours from UTC (e.g. -5 for EST, 5.5 for IST, 9 for JST) OR IANA name (e.g. "America/New_York"). IANA resolved to the DST-correct offset for the chart date.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateHousesRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// House system for dividing ecliptic into 12 houses. Placidus (most popular) uses time, Whole Sign (ancient) uses signs, Equal divides from Ascendant. Use "all" to compare all 4 systems side-by-side for educational purposes.
    CalculateHousesRequestHouseSystem {
        Placidus = "placidus",
        WholeSign = "whole-sign",
        Equal = "equal",
        Koch = "koch",
        All = "all",
    }
}
/// Path and query parameters of `calculateHouses`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateHousesParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateHousesParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateHousesParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `calculateGunMilan`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateGunMilanParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateGunMilanParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateGunMilanParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateGematria`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateGematriaResponse {
    /// The `chosen` field.
    pub chosen: CalculateGematriaResponseChosen,
    /// The `conventions` field.
    pub conventions: CalculateGematriaResponseConventions,
    /// Every Hebrew spelling the input can be written as, greedy parse first. One entry when Hebrew was sent, since there is nothing to choose.
    #[serde(rename = "hebrewForms")]
    pub hebrew_forms: Vec<CalculateGematriaResponseHebrewFormsItem>,
    /// The `input` field.
    pub input: CalculateGematriaResponseInput,
    /// The Latin alphabet ciphers applied to the Latin text. Present only when latinCiphers was set and a Latin text was sent.
    #[serde(rename = "latinValues", skip_serializing_if = "Option::is_none")]
    pub latin_values: Option<Vec<CalculateGematriaResponseLatinValuesItem>>,
    /// Curated words whose standard value equals the chosen spelling. Matching is on the standard reading only, because that is the relation the classical method works with. Empty when nothing matches, which is the ordinary case.
    pub matches: Vec<CalculateGematriaResponseMatchesItem>,
    /// The two substitution transformations applied to the chosen spelling. Each exchanges letters and returns a new word, so the interesting output is often the string rather than the number.
    pub transformations: Vec<CalculateGematriaResponseTransformationsItem>,
    /// Every requested cipher applied to the chosen spelling, in catalogue order, each named as the catalogue names it. Only computed ciphers appear, so every row carries a number.
    pub values: Vec<CalculateGematriaResponseValuesItem>,
}
/// One entry of `values`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateGematriaResponseValuesItem {
    /// Other published totals for the same string, ascending. Present only where the cipher is not single valued: letter names have several accepted spellings, so several totals are equally published. Absent otherwise, so a caller can branch on presence.
    #[serde(rename = "alternateValues", skip_serializing_if = "Option::is_none")]
    pub alternate_values: Option<Vec<f64>>,
    /// Machine identifier of the cipher. Call the ciphers endpoint for the definition, the tradition and the sources behind each one.
    pub id: String,
    /// Display name of the cipher in the requested language, the same string the ciphers catalogue serves for this id. Present so a caller holding one response can label a row without humanizing the identifier or fetching the catalogue. Switch on id, never on this.
    pub name: String,
    /// The first published source this cipher was taken from.
    pub source: String,
    /// Provenance class of the cipher, one of rabbinic, renaissance-latin, golden-dawn-transliterated or modern. Always English, so it stays safe to compare against in code.
    pub tradition: String,
    /// The number this cipher gives for the string. Always a number: the one catalogued cipher this API does not compute is absent from this array rather than present without a value, so no row here has to be guarded. Its catalogue entry carries computed false and says why.
    pub value: f64,
}
/// One entry of `transformations`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateGematriaResponseTransformationsItem {
    /// Machine identifier of the transformation.
    pub id: String,
    /// Display name of the transformation as the catalogue names it, in the requested language.
    pub name: String,
    /// The substituted Hebrew string. Absent when atbashOutput asked for the value alone.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output: Option<String>,
    /// Latin transcription of the substituted string, from the same mechanical letter map.
    #[serde(rename = "outputRomanization", skip_serializing_if = "Option::is_none")]
    pub output_romanization: Option<String>,
    /// The first published source the substitution table was taken from.
    pub source: String,
    /// Provenance class of the transformation.
    pub tradition: String,
    /// Standard value of the substituted string. Absent when atbashOutput asked for the string alone.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub value: Option<f64>,
}
/// One entry of `matches`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateGematriaResponseMatchesItem {
    /// The word in Hebrew. Data, identical in every language.
    pub hebrew: String,
    /// Machine identifier of the entry, an ASCII romanization.
    pub id: String,
    /// What the word means, in the requested language.
    pub meaning: String,
    /// What the tradition says about the equality, in the requested language.
    pub note: String,
    /// Latin transcription of the Hebrew beside it, from the same mechanical letter map.
    pub romanization: String,
    /// Where the value is attested. Every entry in the lexicon carries at least two independent sources, which is why the list is short rather than long.
    pub sources: Vec<String>,
    /// Its value under the standard reading, which is why it matched.
    pub value: f64,
}
/// One entry of `latinValues`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateGematriaResponseLatinValuesItem {
    /// Machine identifier of the Latin cipher.
    pub id: String,
    /// Where the cipher comes from, stated so it cannot be misattributed.
    pub lineage: String,
    /// Provenance class. None of these is rabbinic, whatever a consumer calculator calls them.
    pub tradition: String,
    /// The number this cipher gives for the Latin text as sent.
    pub value: f64,
}
/// The `input` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateGematriaResponseInput {
    /// Echo of the Latin text sent. Absent when Hebrew was sent instead.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub text: Option<String>,
    /// Echo of the Hebrew text sent. Absent when Latin was sent instead.
    #[serde(rename = "textHebrew", skip_serializing_if = "Option::is_none")]
    pub text_hebrew: Option<String>,
}
/// One entry of `hebrewForms`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateGematriaResponseHebrewFormsItem {
    /// One Hebrew spelling the Latin input can be written as. Data, identical in every language.
    pub hebrew: String,
    /// The per letter breakdown of this spelling under the standard reading.
    pub letters: Vec<CalculateGematriaResponseHebrewFormsItemLettersItem>,
    /// Latin transcription of the Hebrew beside it, produced by one mechanical letter map. It is a label for reading the string back, never a pronunciation claim.
    pub romanization: String,
    /// Why this spelling came out of the map: the parse rule first, then one sentence for every reading the scheme applied that the letters alone would not show, so a caller can tell the parses apart.
    pub rule: String,
    /// Every computed cipher applied to this spelling, in catalogue order. The rows carry no display name, because they are the same ciphers in the same order for every spelling: read the names off the top level values array once.
    pub values: Vec<CalculateGematriaResponseHebrewFormsItemValuesItem>,
}
/// One entry of `values`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateGematriaResponseHebrewFormsItemValuesItem {
    /// Other published totals for the same string, ascending. Present only where the cipher is not single valued: letter names have several accepted spellings, so several totals are equally published. Absent otherwise, so a caller can branch on presence.
    #[serde(rename = "alternateValues", skip_serializing_if = "Option::is_none")]
    pub alternate_values: Option<Vec<f64>>,
    /// Machine identifier of the cipher. Call the ciphers endpoint for the definition, the tradition and the sources behind each one.
    pub id: String,
    /// The first published source this cipher was taken from.
    pub source: String,
    /// Provenance class of the cipher, one of rabbinic, renaissance-latin, golden-dawn-transliterated or modern. Always English, so it stays safe to compare against in code.
    pub tradition: String,
    /// The number this cipher gives for the string. Always a number: the one catalogued cipher this API does not compute is absent from this array rather than present without a value, so no row here has to be guarded. Its catalogue entry carries computed false and says why.
    pub value: f64,
}
/// One entry of `letters`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateGematriaResponseHebrewFormsItemLettersItem {
    /// The Hebrew letter as it stands in the string. Data, identical in every language.
    pub glyph: String,
    /// True when the glyph is the word final form. Under the finals-500-900 reading the same letter scores differently in final position, which is why this is on the row.
    #[serde(rename = "isFinal")]
    pub is_final: bool,
    /// Machine identifier of the letter, always English romanization so it stays safe to compare against in code.
    #[serde(rename = "letterId")]
    pub letter_id: String,
    /// Display name of the letter, in the requested language. Branch on letterId, never on this.
    pub name: String,
    /// What this letter contributed under the standard reading, or under the finals reading when one applies.
    pub value: f64,
}
/// The `conventions` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateGematriaResponseConventions {
    /// What the substitution transformations returned.
    #[serde(rename = "atbashOutput")]
    pub atbash_output: String,
    /// Which of the two published methods the name mispar gadol was read as.
    #[serde(rename = "misparGadol")]
    pub mispar_gadol: String,
    /// The Latin to Hebrew scheme applied. Absent when the caller sent Hebrew directly.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transliteration: Option<String>,
}
/// The `chosen` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateGematriaResponseChosen {
    /// The spelling the values and matches on this response were taken from.
    pub hebrew: String,
    /// Why this spelling was chosen over the others.
    pub rule: String,
}
/// What to score and how. Send text for a Latin input or textHebrew for a Hebrew one, never both: which one you send decides whether a transliteration step runs at all. Every other field has a default.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateGematriaRequest {
    /// What AtBash and Albam return: the substituted Hebrew string, its standard value, or both. The biblical witness for AtBash is a substituted WORD rather than a number, which is why the string is available on its own.
    #[serde(rename = "atbashOutput", skip_serializing_if = "Option::is_none")]
    pub atbash_output: Option<CalculateGematriaRequestAtbashOutput>,
    /// Which ciphers to return, by identifier. Omit for every computed cipher. Valid values are mispar-hechrachi, mispar-gadol, otiyot-be-milui, mispar-katan, mispar-kidmi, mispar-prati, mispar-ha-merubah-ha-klali, mispar-meshulash, mispar-musafi, kolel.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ciphers: Option<Vec<CalculateGematriaRequestCiphersItem>>,
    /// Whether to return the curated equal value entries for the chosen spelling. Set false to skip the lookup when only the numbers are wanted.
    #[serde(rename = "includeMatches", skip_serializing_if = "Option::is_none")]
    pub include_matches: Option<bool>,
    /// Whether to also score the Latin text with the three Latin alphabet ciphers. They are Renaissance Christian and modern in lineage rather than rabbinic, and the response labels each one. Ignored when textHebrew was sent.
    #[serde(rename = "latinCiphers", skip_serializing_if = "Option::is_none")]
    pub latin_ciphers: Option<bool>,
    /// Which method the name mispar gadol means, because the sources use it for two. Use finals-500-900 to score the five word final letters as 500 to 900, or milui to score each letter as the value of its own spelled out name.
    #[serde(rename = "misparGadol", skip_serializing_if = "Option::is_none")]
    pub mispar_gadol: Option<CalculateGematriaRequestMisparGadol>,
    /// Latin text to write in Hebrew and then score, up to 200 characters. Non Latin scripts are folded to Latin first, so a Cyrillic or Devanagari name works. Send textHebrew instead to control the Hebrew spelling yourself.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub text: Option<String>,
    /// Hebrew text to score, up to 200 characters. Anything outside the Hebrew script is rejected. Vowel points, cantillation marks, maqaf and paseq are removed before scoring, so a pointed and an unpointed spelling of one word give the same number.
    #[serde(rename = "textHebrew", skip_serializing_if = "Option::is_none")]
    pub text_hebrew: Option<String>,
    /// How a Latin name is written in Hebrew before it is scored. Two members. letter-map-mathers is the 1887 Hermetic letter map, with e read as its author practised it: a point inside a word and alef at the start of one. It writes no c, f, w or x, so a name carrying one of them outside a two letter group returns 400 naming the letter. letter-map-modern follows the modern Israeli transcription rules for the sound each Latin letter carries in English and French spelling, covers every Latin letter, drops the geresh and does not double vav or yod, so send textHebrew for the ktiv male form. Every form states the readings it used in rule. Phonetic Ashkenazi and Sephardi schemes are not offered because no two references agree on a rule for that direction.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transliteration: Option<CalculateGematriaRequestTransliteration>,
}
string_enum! {
    /// How a Latin name is written in Hebrew before it is scored. Two members. letter-map-mathers is the 1887 Hermetic letter map, with e read as its author practised it: a point inside a word and alef at the start of one. It writes no c, f, w or x, so a name carrying one of them outside a two letter group returns 400 naming the letter. letter-map-modern follows the modern Israeli transcription rules for the sound each Latin letter carries in English and French spelling, covers every Latin letter, drops the geresh and does not double vav or yod, so send textHebrew for the ktiv male form. Every form states the readings it used in rule. Phonetic Ashkenazi and Sephardi schemes are not offered because no two references agree on a rule for that direction.
    CalculateGematriaRequestTransliteration {
        LetterMapMathers = "letter-map-mathers",
        LetterMapModern = "letter-map-modern",
    }
}
string_enum! {
    /// Which method the name mispar gadol means, because the sources use it for two. Use finals-500-900 to score the five word final letters as 500 to 900, or milui to score each letter as the value of its own spelled out name.
    CalculateGematriaRequestMisparGadol {
        Finals500900 = "finals-500-900",
        Milui = "milui",
    }
}
string_enum! {
    /// One entry of `ciphers`.
    CalculateGematriaRequestCiphersItem {
        MisparHechrachi = "mispar-hechrachi",
        MisparGadol = "mispar-gadol",
        OtiyotBeMilui = "otiyot-be-milui",
        MisparKatan = "mispar-katan",
        MisparKidmi = "mispar-kidmi",
        MisparPrati = "mispar-prati",
        MisparHaMerubahHaKlali = "mispar-ha-merubah-ha-klali",
        MisparMeshulash = "mispar-meshulash",
        MisparMusafi = "mispar-musafi",
        Kolel = "kolel",
    }
}
string_enum! {
    /// What AtBash and Albam return: the substituted Hebrew string, its standard value, or both. The biblical witness for AtBash is a substituted WORD rather than a number, which is why the string is available on its own.
    CalculateGematriaRequestAtbashOutput {
        Both = "both",
        String = "string",
        Value = "value",
    }
}
/// Path and query parameters of `calculateGematria`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateGematriaParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateGematriaParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateGematriaParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateGates`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateGatesResponse {
    /// The 13 unconscious Design activations computed 88 degrees of solar arc before birth, in red on a standard chart.
    pub design: Vec<CalculateGatesResponseDesignItem>,
    /// The 13 conscious Personality activations computed at the exact birth moment, in black on a standard chart.
    pub personality: Vec<CalculateGatesResponsePersonalityItem>,
}
/// One entry of `personality`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateGatesResponsePersonalityItem {
    /// Human Design gate number from 1 to 64 that this activation falls in.
    pub gate: f64,
    /// Bodygraph function of the gate: what it does in the center it sits in and the channel it forms. This is NOT the meaning of the I-Ching hexagram that shares its number. They share a number, not a definition.
    #[serde(rename = "gateDescription")]
    pub gate_description: String,
    /// Human Design keynote name of the gate, describing its bodygraph function. Always English, whatever the lang parameter says. Use gateNameLocalized for anything a reader sees.
    #[serde(rename = "gateName")]
    pub gate_name: String,
    /// Gate keynote name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "gateNameLocalized", skip_serializing_if = "Option::is_none")]
    pub gate_name_localized: Option<String>,
    /// Cross-reference to the I-Ching hexagram that shares this gate number.
    #[serde(rename = "ichingHexagram")]
    pub iching_hexagram: CalculateGatesResponsePersonalityItemIchingHexagram,
    /// Line number from 1 to 6 within the gate, setting the line keynote and the profile.
    pub line: f64,
    /// Meaning of this gate at this specific line, one of 384. The finest interpretive layer in the chart and the one that makes a reading specific rather than generic. This is not the six abstract line archetypes: gate 41 line 3 carries its own meaning that neither the gate keynote nor the line-3 archetype holds alone.
    #[serde(rename = "lineMeaning")]
    pub line_meaning: String,
    /// Activating body. One of Sun, Earth, Moon, North Node, South Node, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto. Always English, whatever the lang parameter says, so it stays safe to compare against in code and to key a glyph table on. Use planetLocalized for anything a reader sees.
    pub planet: String,
    /// What this planetary activation contributes in Human Design specifically, which is not its meaning in western astrology.
    #[serde(rename = "planetDescription")]
    pub planet_description: String,
    /// Activating body name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "planetLocalized", skip_serializing_if = "Option::is_none")]
    pub planet_localized: Option<String>,
    /// Chart side. personality is the conscious birth-moment activation, design is the unconscious activation 88 degrees of solar arc before birth.
    pub side: String,
}
/// Cross-reference to the I-Ching hexagram that shares this gate number.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateGatesResponsePersonalityItemIchingHexagram {
    /// English name of the corresponding I-Ching hexagram.
    pub english: String,
    /// I-Ching hexagram number, identical to the gate number it corresponds to.
    pub number: f64,
}
/// One entry of `design`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateGatesResponseDesignItem {
    /// Human Design gate number from 1 to 64 that this activation falls in.
    pub gate: f64,
    /// Bodygraph function of the gate: what it does in the center it sits in and the channel it forms. This is NOT the meaning of the I-Ching hexagram that shares its number. They share a number, not a definition.
    #[serde(rename = "gateDescription")]
    pub gate_description: String,
    /// Human Design keynote name of the gate, describing its bodygraph function. Always English, whatever the lang parameter says. Use gateNameLocalized for anything a reader sees.
    #[serde(rename = "gateName")]
    pub gate_name: String,
    /// Gate keynote name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "gateNameLocalized", skip_serializing_if = "Option::is_none")]
    pub gate_name_localized: Option<String>,
    /// Cross-reference to the I-Ching hexagram that shares this gate number.
    #[serde(rename = "ichingHexagram")]
    pub iching_hexagram: CalculateGatesResponseDesignItemIchingHexagram,
    /// Line number from 1 to 6 within the gate, setting the line keynote and the profile.
    pub line: f64,
    /// Meaning of this gate at this specific line, one of 384. The finest interpretive layer in the chart and the one that makes a reading specific rather than generic. This is not the six abstract line archetypes: gate 41 line 3 carries its own meaning that neither the gate keynote nor the line-3 archetype holds alone.
    #[serde(rename = "lineMeaning")]
    pub line_meaning: String,
    /// Activating body. One of Sun, Earth, Moon, North Node, South Node, Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, Pluto. Always English, whatever the lang parameter says, so it stays safe to compare against in code and to key a glyph table on. Use planetLocalized for anything a reader sees.
    pub planet: String,
    /// What this planetary activation contributes in Human Design specifically, which is not its meaning in western astrology.
    #[serde(rename = "planetDescription")]
    pub planet_description: String,
    /// Activating body name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "planetLocalized", skip_serializing_if = "Option::is_none")]
    pub planet_localized: Option<String>,
    /// Chart side. personality is the conscious birth-moment activation, design is the unconscious activation 88 degrees of solar arc before birth.
    pub side: String,
}
/// Cross-reference to the I-Ching hexagram that shares this gate number.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateGatesResponseDesignItemIchingHexagram {
    /// English name of the corresponding I-Ching hexagram.
    pub english: String,
    /// I-Ching hexagram number, identical to the gate number it corresponds to.
    pub number: f64,
}
/// Request body of `calculateGates`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateGatesRequest {
    /// Birth date in YYYY-MM-DD format. The anchor for both the Personality activations at birth and the Design activations 88 degrees of solar arc earlier.
    pub date: String,
    /// Birth latitude in decimal degrees. Optional and does not affect the bodygraph, which depends only on ecliptic longitudes. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Optional and does not affect the bodygraph. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<CalculateGatesRequestNodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Precision matters: the profile lines and gate boundaries shift with the exact minute of birth.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: CalculateGatesRequestTimezone,
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateGatesRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    CalculateGatesRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Path and query parameters of `calculateGates`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateGatesParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateGatesParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateGatesParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateExpression`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateExpressionResponse {
    /// Every letter value of the birth name, grouped by name: each name is summed and reduced, then the names are added and reduced to the final Expression number.
    pub calculation: String,
    /// Whether a Karmic Debt number (13, 14, 16, 19) appeared in the final reduction, the sum of the reduced names. Indicates inherited challenges embedded in your given name.
    #[serde(rename = "hasKarmicDebt")]
    pub has_karmic_debt: bool,
    /// Detailed interpretation of the Karmic Debt number when present. Includes the debt theme, the inherited challenge, and guidance for resolution. Only returned when hasKarmicDebt is true.
    #[serde(rename = "karmicDebtMeaning", skip_serializing_if = "Option::is_none")]
    pub karmic_debt_meaning: Option<CalculateExpressionResponseKarmicDebtMeaning>,
    /// Specific Karmic Debt number found during reduction. Each debt (13, 14, 16, 19) points to a distinct lesson woven into the talents your name bestows.
    #[serde(rename = "karmicDebtNumber", skip_serializing_if = "Option::is_none")]
    pub karmic_debt_number: Option<f64>,
    /// The `meaning` field.
    pub meaning: CalculateExpressionResponseMeaning,
    /// Expression number (also called Destiny number) from every letter of the full birth name. Reveals natural talents, abilities, and the goals you are meant to achieve. Values: 1 to 9, 11, 22, or 33.
    pub number: f64,
    /// Single-digit (1 to 9) or Master Number (11, 22, 33). Master Numbers in the Expression position indicate extraordinary innate talent that demands conscious development.
    pub r#type: CalculateExpressionResponseType,
}
string_enum! {
    /// Single-digit (1 to 9) or Master Number (11, 22, 33). Master Numbers in the Expression position indicate extraordinary innate talent that demands conscious development.
    CalculateExpressionResponseType {
        Single = "single",
        Master = "master",
    }
}
/// The `meaning` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateExpressionResponseMeaning {
    /// Professional guidance aligned with your natural Expression talents. Covers ideal industries, specific roles, and the work environments where you will thrive.
    pub career: String,
    /// Shadow side of your talents and areas requiring conscious effort. Each challenge explains its root cause and practical strategies for transformation.
    pub challenges: Vec<String>,
    /// Core interpretation of the natural abilities, life mission and destiny the birth name describes. Together with the strengths, challenges, career, relationships and spirituality fields it makes a full reading.
    pub description: String,
    /// Defining traits and talent themes for this Expression number. Ideal for personality profiles, compatibility engines, and talent-matching features.
    pub keywords: Vec<String>,
    /// How your Expression number shapes love, friendship, and family bonds. Includes compatibility insights with other numbers and communication patterns.
    pub relationships: String,
    /// The spiritual dimension of your Expression energy. Explores soul lessons, recommended practices, and the deeper purpose your talents are meant to serve.
    pub spirituality: String,
    /// Natural talents and innate gifts. Each strength includes a detailed explanation of how it shows up in work, relationships, and personal growth.
    pub strengths: Vec<String>,
    /// Numerology archetype for this Expression number. Captures the essence of your natural abilities, such as "The Communicator" for 3 or "The Master Intuitive" for 11.
    pub title: String,
}
/// Detailed interpretation of the Karmic Debt number when present. Includes the debt theme, the inherited challenge, and guidance for resolution. Only returned when hasKarmicDebt is true.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateExpressionResponseKarmicDebtMeaning {
    /// The specific challenge or pattern from past lives that must be confronted. Explains the root cause of recurring obstacles.
    pub challenge: String,
    /// Title describing the karmic debt theme. Identifies the core past-life pattern that this debt number carries forward.
    pub description: String,
    /// Practical guidance for resolving the karmic debt. Actionable steps for transforming the inherited challenge into growth.
    pub resolution: String,
}
/// Path and query parameters of `calculateExpression`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateExpressionParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateExpressionParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateExpressionParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateEntrancePada`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateEntrancePadaResponse {
    /// How the stated effect reads: auspicious for a gain, inauspicious for a harm, mixed where the text names a gain and a loss together. A RoxyAPI classification of the verse effect rather than a word in the text, and always English so it is safe to key styling on.
    pub auspiciousness: String,
    /// The square as a row and column, which is what you draw with. Row 1 is the northern edge and column 1 the western one.
    pub cell: CalculateEntrancePadaResponseCell,
    /// The switches this reading resolved, echoed so a stored response can be reproduced years later without knowing what the defaults were on the day it was made.
    pub conventions: CalculateEntrancePadaResponseConventions,
    /// The devata holding the entrance square. Present only on the 81 pada grid, because 53.55 to 56 gives the 64 pada division its structure and names no devata on it. The effects themselves apply to either division, which is why the pada and the effect are returned in both cases.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub devata: Option<CalculateEntrancePadaResponseDevata>,
    /// What the chapter says follows from a main entrance on this pada. Original prose composed from the verse, translated in place when lang is set.
    pub effect: String,
    /// Position of the pada along its own side, 1 to 8, counting from the start corner. Useful for drawing a door strip without recomputing the global index.
    #[serde(rename = "ordinalOnSide")]
    pub ordinal_on_side: f64,
    /// Which of the 32 perimeter padas the main door falls on, numbered 1 to 32. Padas 1 to 8 run down the east side from the north-east corner, 9 to 16 along the south from the south-east, 17 to 24 up the west from the south-west and 25 to 32 along the north from the north-west. This index is the identifier every entrance verdict keys on.
    pub pada: f64,
    /// The verdict as a sentence, for a report or a chat answer. Composed from the pada, its side and its effect, and translated in place when lang is set.
    pub reading: String,
    /// The padas on this same side whose stated effect is a gain, so a door can be moved to the nearest favourable position without re-reading the whole table. Empty on a side where the chapter names no gain at all, which is true of the south.
    #[serde(rename = "recommendedPadas")]
    pub recommended_padas: Vec<f64>,
    /// Which of the four sides the pada belongs to. A corner square belongs to exactly one side, decided by the verses rather than by geometry, so the south-east corner reads South even though it sits at the end of the east edge.
    pub side: String,
    /// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
    pub source: CalculateEntrancePadaResponseSource,
    /// The square of the 81 pada grid the door falls in, 1 to 81. It is always the 81 pada square, whichever grid you ask for, because that is the division the chapter numbers and the one the 32 padas are enumerated on. Squares run row-major over the printed plate, so the corners are 1 north-east, 9 south-east, 73 north-west and 81 south-west.
    pub square: f64,
    /// The corner the chapter counts this side from. The four start corners are stated in the verses themselves, which is what makes the effect to pada alignment a reading rather than an inference.
    #[serde(rename = "startCorner")]
    pub start_corner: String,
}
/// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateEntrancePadaResponseSource {
    /// Why a convention rule says what it says. Present only when text is convention, and it names the tradition the rule comes from rather than a verse.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub basis: Option<String>,
    /// Chapter of the primary text. Absent on a convention, which has no chapter to cite.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chapter: Option<f64>,
    /// Whether the cited edition is in the public domain. True on the 1884 Brihat Samhita edition, whose verses are quoted. False on the 1933 Manasara edition behind the Ayadi formulas, from which only the multipliers, divisors and names are taken, never a sentence.
    #[serde(rename = "publicDomain", skip_serializing_if = "Option::is_none")]
    pub public_domain: Option<bool>,
    /// The primary text this verdict rests on, or the literal value convention where no verse states the rule. Always English, safe to compare against.
    pub text: String,
    /// Translator of the edition the verse was read in. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation: Option<String>,
    /// Verse or verse range inside the chapter. Absent on a convention. A range is written with a hyphen, as in 115-117.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub verse: Option<String>,
    /// Publication year of that edition. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<f64>,
}
/// The devata holding the entrance square. Present only on the 81 pada grid, because 53.55 to 56 gives the 64 pada division its structure and names no devata on it. The effects themselves apply to either division, which is why the pada and the effect are returned in both cases.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateEntrancePadaResponseDevata {
    /// Identifier of the devata holding that square. Always English transliteration, safe to compare against and to look up on the devatas endpoint.
    pub id: String,
    /// Display name of the devata. A Sanskrit proper noun: romanised with the diacritics the transliteration carries in every language, and written in Devanagari as the Sanskrit text prints it when lang is hi. Compare on id, never on this.
    pub name: String,
    /// How many of the 81 squares this devata holds: one for a padika, two for a dvipada, three for a tripada and nine for Brahma.
    #[serde(rename = "padaCount")]
    pub pada_count: f64,
}
/// The switches this reading resolved, echoed so a stored response can be reproduced years later without knowing what the defaults were on the day it was made.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateEntrancePadaResponseConventions {
    /// Which division of the ground was read. Echoes the resolved value whether it was sent or defaulted.
    pub grid: String,
    /// Unit every distance and area in the response is measured in, areas in its square. Echoes the resolved value whether it was sent or defaulted.
    pub unit: CalculateEntrancePadaResponseConventionsUnit,
}
string_enum! {
    /// Unit every distance and area in the response is measured in, areas in its square. Echoes the resolved value whether it was sent or defaulted.
    CalculateEntrancePadaResponseConventionsUnit {
        Feet = "feet",
        Metres = "metres",
    }
}
/// The square as a row and column, which is what you draw with. Row 1 is the northern edge and column 1 the western one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateEntrancePadaResponseCell {
    /// Column of the grid the square sits in, 1 at the western edge.
    #[serde(rename = "columnFromWest")]
    pub column_from_west: f64,
    /// Row of the grid the square sits in, 1 at the northern edge.
    #[serde(rename = "rowFromNorth")]
    pub row_from_north: f64,
}
/// Where the main door sits on the plot. Send facing or facingDegrees, never both, and locate the door with either door coordinates or doorPosition, never both.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateEntrancePadaRequest {
    /// Where the main door sits, in plot coordinates. The point is snapped to the nearest boundary of the plot, so a coordinate read off a drawing that lands slightly inside or outside still resolves. Send this or doorPosition, never both.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub door: Option<CalculateEntrancePadaRequestDoor>,
    /// Where the main door sits along the facing side, as a fraction from 0 to 1 measured from the corner the chapter starts that side at: the north-east for an east facing, the south-east for a south facing, the south-west for a west facing and the north-west for a north facing. The side carries 8 padas, so to aim at pada n of 8 send its midpoint, (n - 0.5) / 8: 0.0625 for the first pada, 0.4375 for the fourth, 0.9375 for the eighth. The response names the pada the fraction resolved to in ordinalOnSide. Requires a cardinal facing, since an intercardinal facing names no single side. Send this or door, never both.
    #[serde(rename = "doorPosition", skip_serializing_if = "Option::is_none")]
    pub door_position: Option<f64>,
    /// Direction the front of the house looks out toward, one of the eight compass sectors. Case and punctuation are folded, so north-east, northeast and NorthEast all resolve. Send this or facingDegrees, never both.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub facing: Option<CalculateEntrancePadaRequestFacing>,
    /// Direction the front of the house looks out toward, as a compass bearing in degrees clockwise from true north, measured looking OUT from the building. The same convention the feng shui facing endpoints use, so a bearing works unchanged across the two domains. Send this or facing, never both.
    #[serde(rename = "facingDegrees", skip_serializing_if = "Option::is_none")]
    pub facing_degrees: Option<f64>,
    /// Which division of the ground to read: 81-pada is the Paramasayika of Brihat Samhita 53.42, the grid the chapter numbers and names every devata on, and 64-pada is the Manduka of 53.55, for which the chapter gives structure only and no devata names. Defaults to 81-pada.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub grid: Option<CalculateEntrancePadaRequestGrid>,
    /// The ground the mandala is projected over. Send width and depth for a compass-aligned rectangle, or polygon for anything else. The x axis runs east and the y axis north, and the mandala is aligned to the compass rather than to the building.
    pub plot: CalculateEntrancePadaRequestPlot,
}
/// The ground the mandala is projected over. Send width and depth for a compass-aligned rectangle, or polygon for anything else. The x axis runs east and the y axis north, and the mandala is aligned to the compass rather than to the building.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateEntrancePadaRequestPlot {
    /// North-south extent of a rectangular plot, in the unit given. Send this with width for a rectangle, or send polygon instead.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub depth: Option<f64>,
    /// The plot outline as 3 to 16 vertices in plot coordinates, x east and y north, in either winding order. Use this instead of width and depth for a plot with a cut corner, an extension or an irregular boundary.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub polygon: Option<Vec<CalculateEntrancePadaRequestPlotPolygonItem>>,
    /// Unit the plot dimensions are given in. Every distance the response returns is in this same unit. The mandala projection is scale free, so this affects the areas and the marma size and nothing else.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub unit: Option<CalculateEntrancePadaRequestPlotUnit>,
    /// East-west extent of a rectangular plot, in the unit given. Send this with depth for a rectangle, or send polygon instead.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub width: Option<f64>,
}
string_enum! {
    /// Unit the plot dimensions are given in. Every distance the response returns is in this same unit. The mandala projection is scale free, so this affects the areas and the marma size and nothing else.
    CalculateEntrancePadaRequestPlotUnit {
        Feet = "feet",
        Metres = "metres",
    }
}
/// One entry of `polygon`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateEntrancePadaRequestPlotPolygonItem {
    /// Distance east of the plot origin, in the same unit as the plot. The x axis runs east.
    pub x: f64,
    /// Distance north of the plot origin, in the same unit as the plot. The y axis runs north.
    pub y: f64,
}
string_enum! {
    /// Which division of the ground to read: 81-pada is the Paramasayika of Brihat Samhita 53.42, the grid the chapter numbers and names every devata on, and 64-pada is the Manduka of 53.55, for which the chapter gives structure only and no devata names. Defaults to 81-pada.
    CalculateEntrancePadaRequestGrid {
        Variant81Pada = "81-pada",
        Variant64Pada = "64-pada",
    }
}
string_enum! {
    /// Direction the front of the house looks out toward, one of the eight compass sectors. Case and punctuation are folded, so north-east, northeast and NorthEast all resolve. Send this or facingDegrees, never both.
    CalculateEntrancePadaRequestFacing {
        North = "North",
        Northeast = "Northeast",
        East = "East",
        Southeast = "Southeast",
        South = "South",
        Southwest = "Southwest",
        West = "West",
        Northwest = "Northwest",
    }
}
/// Where the main door sits, in plot coordinates. The point is snapped to the nearest boundary of the plot, so a coordinate read off a drawing that lands slightly inside or outside still resolves. Send this or doorPosition, never both.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateEntrancePadaRequestDoor {
    /// Distance east of the plot origin, in the same unit as the plot. The x axis runs east.
    pub x: f64,
    /// Distance north of the plot origin, in the same unit as the plot. The y axis runs north.
    pub y: f64,
}
/// Path and query parameters of `calculateEntrancePada`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateEntrancePadaParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateEntrancePadaParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateEntrancePadaParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateDual`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateDualResponse {
    /// True when both systems reduce to the same single-digit energy (Pythagorean number reduced to one digit equals the Chaldean root). Agreement is read as a name whose vibrations are in harmony.
    pub agreement: bool,
    /// The `chaldean` field.
    pub chaldean: CalculateDualResponseChaldean,
    /// The name analyzed.
    pub name: String,
    /// Plain-language comparison of the two systems for this name.
    pub note: String,
    /// The `pythagorean` field.
    pub pythagorean: CalculateDualResponsePythagorean,
}
/// The `pythagorean` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateDualResponsePythagorean {
    /// Pythagorean letter breakdown and reduction.
    pub calculation: String,
    /// Core themes in the Pythagorean reading.
    pub keywords: Vec<String>,
    /// Pythagorean Expression number (1 to 9, 11, 22, 33).
    pub number: f64,
    /// Archetype of the number.
    pub title: String,
    /// Single digit or preserved master number.
    pub r#type: CalculateDualResponsePythagoreanType,
}
string_enum! {
    /// Single digit or preserved master number.
    CalculateDualResponsePythagoreanType {
        Single = "single",
        Master = "master",
    }
}
/// The `chaldean` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateDualResponseChaldean {
    /// Chaldean letter breakdown to compound and root.
    pub calculation: String,
    /// True when the Chaldean root is 4 or 8, the numbers of caution.
    pub caution: bool,
    /// Chaldean compound number (10 to 52), the hidden influence, or null.
    pub compound: Option<f64>,
    /// Cheiro compound interpretation when present.
    #[serde(rename = "compoundMeaning")]
    pub compound_meaning: Option<CalculateDualResponseChaldeanCompoundMeaning>,
    /// Planetary ruler of the Chaldean root.
    pub planet: String,
    /// Chaldean root (1 to 9).
    pub root: f64,
    /// Archetype of the Chaldean root.
    pub title: String,
    /// The sum the compound is read from: for a one-word name, its Chaldean letter total; for a longer name, the sum of each word reduced to its single number, as Cheiro works John Smith (18 to 9, 17 to 8, total 17).
    pub total: f64,
}
/// Cheiro compound interpretation when present.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateDualResponseChaldeanCompoundMeaning {
    /// Cheiro interpretation.
    pub meaning: String,
    /// Symbolic title.
    pub name: Option<String>,
    /// Tenor of the compound.
    pub nature: CalculateDualResponseChaldeanCompoundMeaningNature,
    /// The compound number.
    pub number: f64,
    /// Series equivalent for 33 to 52.
    #[serde(rename = "sameAs", skip_serializing_if = "Option::is_none")]
    pub same_as: Option<f64>,
}
string_enum! {
    /// Tenor of the compound.
    CalculateDualResponseChaldeanCompoundMeaningNature {
        Fortunate = "fortunate",
        Unfortunate = "unfortunate",
        Mixed = "mixed",
    }
}
/// Path and query parameters of `calculateDual`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateDualParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateDualParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateDualParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateDrishti`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateDrishtiResponse {
    /// Aspect table grouped by aspecting planet. useful for rendering aspect grids in astrology software.
    #[serde(rename = "aspectTable")]
    pub aspect_table: Vec<CalculateDrishtiResponseAspectTableItem>,
    /// Complete list of all Vedic aspects (drishti) between planets. Includes full (7th) and special aspects (Mars 4th/8th, Jupiter 5th/9th, Saturn 3rd/10th).
    pub aspects: Vec<CalculateDrishtiResponseAspectsItem>,
    /// Chart time the aspects were calculated for, echoed back as the local wall clock of the request (ISO 8601, no offset). This is the `date` and `time` you sent, NOT a UTC instant: hold them fixed and vary `timezone` and every longitude moves while this field does not. Combine it with the `timezone` you sent to recover the absolute moment.
    pub datetime: String,
    /// Pairs of planets aspecting each other simultaneously. Mutual aspects amplify planetary influence significantly.
    #[serde(rename = "mutualAspects")]
    pub mutual_aspects: Vec<CalculateDrishtiResponseMutualAspectsItem>,
    /// Sidereal positions of all 9 planets at the given time.
    pub planets: Vec<CalculateDrishtiResponsePlanetsItem>,
}
/// One entry of `planets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateDrishtiResponsePlanetsItem {
    /// Sidereal longitude in degrees (0-360).
    pub longitude: f64,
    /// Planet name (Sun through Ketu, all 9 Vedic grahas).
    pub name: String,
    /// Vedic zodiac sign (rashi) the planet occupies.
    pub sign: String,
}
/// One entry of `mutualAspects`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateDrishtiResponseMutualAspectsItem {
    /// The aspect type shared mutually. Mutual aspects are especially strong in Vedic astrology.
    #[serde(rename = "aspectType")]
    pub aspect_type: String,
    /// First planet in the mutual aspect pair.
    pub planet1: String,
    /// Second planet in the mutual aspect pair.
    pub planet2: String,
}
/// One entry of `aspects`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateDrishtiResponseAspectsItem {
    /// Vedic aspect type. All planets have 7th aspect. Special aspects: Mars 4th/8th, Jupiter 5th/9th, Saturn 3rd/10th.
    #[serde(rename = "aspectType")]
    pub aspect_type: CalculateDrishtiResponseAspectsItemAspectType,
    /// Planet receiving the aspect.
    #[serde(rename = "aspectedPlanet")]
    pub aspected_planet: String,
    /// Planet casting the aspect (graha drishti).
    #[serde(rename = "aspectingPlanet")]
    pub aspecting_planet: String,
    /// Angular distance from exact aspect in degrees. Smaller orb = more potent aspect.
    pub orb: f64,
    /// Aspect strength percentage (0-100). 100 = exact aspect, decreases with orb distance.
    pub strength: f64,
}
string_enum! {
    /// Vedic aspect type. All planets have 7th aspect. Special aspects: Mars 4th/8th, Jupiter 5th/9th, Saturn 3rd/10th.
    CalculateDrishtiResponseAspectsItemAspectType {
        Conjunction = "conjunction",
        Variant7th = "7th",
        Variant4th = "4th",
        Variant8th = "8th",
        Variant5th = "5th",
        Variant9th = "9th",
        Variant3rd = "3rd",
        Variant10th = "10th",
    }
}
/// One entry of `aspectTable`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateDrishtiResponseAspectTableItem {
    /// All aspects cast by this planet.
    pub aspects: Vec<CalculateDrishtiResponseAspectTableItemAspectsItem>,
    /// Planet casting aspects.
    pub planet: String,
}
/// One entry of `aspects`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateDrishtiResponseAspectTableItemAspectsItem {
    /// Vedic aspect house (7th, 4th, 8th, 5th, 9th, 3rd, 10th, or conjunction).
    #[serde(rename = "aspectType")]
    pub aspect_type: String,
    /// Planet being aspected.
    pub planet: String,
    /// Aspect strength percentage.
    pub strength: f64,
}
/// Request body of `calculateDrishti`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateDrishtiRequest {
    /// Coordinate system for longitude output. "sidereal" (Nirayana) uses Lahiri ayanamsa, the standard for Vedic astrology. "tropical" (Sayana) uses raw ecliptic longitude matching Western astrology. Defaults to "sidereal".
    #[serde(rename = "coordinateSystem", skip_serializing_if = "Option::is_none")]
    pub coordinate_system: Option<CalculateDrishtiRequestCoordinateSystem>,
    /// Date in YYYY-MM-DD format. Planetary positions are calculated for this date to determine mutual aspects (drishti).
    pub date: String,
    /// Observer latitude in decimal degrees. Used for Lagna calculation which affects house-based aspect analysis.
    pub latitude: f64,
    /// Observer longitude in decimal degrees. Affects local sidereal time for positional calculations.
    pub longitude: f64,
    /// Time in HH:MM:SS format (24-hour). Exact time affects fast-moving planets (Moon, Mercury) and aspect orbs.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5 (IST).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<CalculateDrishtiRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5 (IST).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateDrishtiRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Coordinate system for longitude output. "sidereal" (Nirayana) uses Lahiri ayanamsa, the standard for Vedic astrology. "tropical" (Sayana) uses raw ecliptic longitude matching Western astrology. Defaults to "sidereal".
    CalculateDrishtiRequestCoordinateSystem {
        Sidereal = "sidereal",
        Tropical = "tropical",
    }
}
/// Response body of `calculateDayMasterStrength`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateDayMasterStrengthResponse {
    /// Echo of the birth moment the chart was computed from.
    #[serde(rename = "birthData")]
    pub birth_data: CalculateDayMasterStrengthResponseBirthData,
    /// The three school conventions this result was computed under. Returned on every BaZi response so a chart is self-describing: two calculators can produce different pillars for one birth and both be correct, and this object says which reading you are holding.
    pub conventions: CalculateDayMasterStrengthResponseConventions,
    /// The day stem whose strength is being assessed.
    #[serde(rename = "dayMaster")]
    pub day_master: CalculateDayMasterStrengthResponseDayMaster,
    /// The three classical factors behind the verdict, each with what it found and what it contributed. These are the citable part of the reading; the score is our arithmetic over them.
    pub factors: Vec<CalculateDayMasterStrengthResponseFactorsItem>,
    /// Elements that help this chart. A weak Day Master wants its own element and the one that generates it; a strong one wants the three that drain, spend, or restrain it. Empty when the verdict is balanced, because a centred chart has no categorically favourable element and the incoming luck pillar decides. Always English, whatever the lang parameter says.
    #[serde(rename = "favorableElements")]
    pub favorable_elements: Vec<String>,
    /// Element headcount across the eight characters, the plain distribution behind the weighted verdict.
    #[serde(rename = "fiveElements")]
    pub five_elements: Vec<CalculateDayMasterStrengthResponseFiveElementsItem>,
    /// How many of the four branches store a stem of the Day Master element. Zero means the day stem is rootless, which is the single most decisive finding a strength reading can return.
    #[serde(rename = "rootCount")]
    pub root_count: f64,
    /// Composite support score, negative for an under-supported Day Master and positive for a well-supported one. A RoxyAPI weighting of the three classical factors rather than a figure from any text, published so the verdict can be audited: the three factor contributions sum to exactly this number.
    pub score: f64,
    /// State of the Day Master element in the birth month, the strongest single input. One of prosperous, supported, resting, imprisoned, dead, which render the classical five wang xiang xiu qiu si. Always English, whatever the lang parameter says; the translated reading is seasonalStateMeaning.
    #[serde(rename = "seasonalState")]
    pub seasonal_state: String,
    /// The seasonal state in hanzi. Identical under every lang.
    #[serde(rename = "seasonalStateChinese")]
    pub seasonal_state_chinese: String,
    /// What this seasonal state means for the chart.
    #[serde(rename = "seasonalStateMeaning")]
    pub seasonal_state_meaning: String,
    /// One-paragraph reading composed from the verdict, the seasonal state, and the rooting finding.
    pub summary: String,
    /// Elements that burden this chart, the complement of favorableElements. Also empty when the verdict is balanced.
    #[serde(rename = "unfavorableElements")]
    pub unfavorable_elements: Vec<String>,
    /// Strength verdict. One of very-weak, weak, balanced, strong, very-strong, banded on the composite score below: under -3 is very-weak, -3 to under -1 is weak, -1 to under 1 is balanced, 1 to under 3 is strong, 3 and above is very-strong. Always English, whatever the lang parameter says.
    pub verdict: String,
}
/// One entry of `fiveElements`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateDayMasterStrengthResponseFiveElementsItem {
    /// How many of the eight chart characters carry this element, four stems and four branch elements at one point each.
    pub count: f64,
    /// Five-phase element. Always English, whatever the lang parameter says.
    pub element: String,
    /// Element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// How represented the element is. deficient is absent, excess is three or more, balanced is one or two.
    pub level: String,
    /// What this level of representation means for the chart.
    pub reading: String,
}
/// One entry of `factors`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateDayMasterStrengthResponseFactorsItem {
    /// The factor named in hanzi. Identical under every lang.
    pub chinese: String,
    /// Points this factor contributed to the composite score, positive for support and negative for drain. The three contributions sum to score, so a caller who weights the factors differently can rebuild its own total from the same findings.
    pub contribution: f64,
    /// What the factor actually found in this chart, in one clause.
    pub detail: String,
    /// Which classical factor this is. month-command is de ling, whether the birth month season backs the Day Master element. rooting is de di, whether any branch stores a stem of that element. party is de shi, whether the other three stems, and the principal stems of the three branches outside the month, help or spend it. Always English, whatever the lang parameter says.
    pub id: String,
    /// Display name of the factor. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Tone-marked pinyin for the factor. Identical under every lang.
    pub pinyin: String,
}
/// The day stem whose strength is being assessed.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateDayMasterStrengthResponseDayMaster {
    /// The Day Master stem in hanzi.
    pub chinese: String,
    /// Five-phase element of the Day Master, the element whose support is being weighed. Always English, whatever the lang parameter says. Use elementLocalized for anything a reader sees.
    pub element: String,
    /// Element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// What this particular stem is like as a Day Master.
    pub nature: String,
    /// Tone-marked pinyin for the Day Master stem.
    pub pinyin: String,
    /// Polarity of the Day Master, yang or yin.
    pub polarity: String,
    /// Day stem identifier. Always English pinyin, whatever the lang parameter says.
    pub stem: String,
}
/// The three school conventions this result was computed under. Returned on every BaZi response so a chart is self-describing: two calculators can produce different pillars for one birth and both be correct, and this object says which reading you are holding.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateDayMasterStrengthResponseConventions {
    /// Day-boundary school actually applied. Echoes the request, or the default when it was omitted. Always English, whatever the lang parameter says, so it stays safe to compare against in code.
    #[serde(rename = "dayBoundary")]
    pub day_boundary: CalculateDayMasterStrengthResponseConventionsDayBoundary,
    /// Hour clock actually applied. Echoes the request, or the default when omitted.
    #[serde(rename = "hourClock")]
    pub hour_clock: CalculateDayMasterStrengthResponseConventionsHourClock,
    /// Year-boundary school actually applied. Echoes the request, or the default when it was omitted.
    #[serde(rename = "yearBoundary")]
    pub year_boundary: CalculateDayMasterStrengthResponseConventionsYearBoundary,
}
string_enum! {
    /// Year-boundary school actually applied. Echoes the request, or the default when it was omitted.
    CalculateDayMasterStrengthResponseConventionsYearBoundary {
        LiChun = "li-chun",
        LunarNewYear = "lunar-new-year",
    }
}
string_enum! {
    /// Hour clock actually applied. Echoes the request, or the default when omitted.
    CalculateDayMasterStrengthResponseConventionsHourClock {
        Clock = "clock",
        LocalMean = "local-mean",
        Solar = "solar",
    }
}
string_enum! {
    /// Day-boundary school actually applied. Echoes the request, or the default when it was omitted. Always English, whatever the lang parameter says, so it stays safe to compare against in code.
    CalculateDayMasterStrengthResponseConventionsDayBoundary {
        SplitZi = "split-zi",
        Midnight = "midnight",
        EarlyZi = "early-zi",
    }
}
/// Echo of the birth moment the chart was computed from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateDayMasterStrengthResponseBirthData {
    /// Birth date in YYYY-MM-DD format. Sets the year, month and day pillars. The year pillar turns at Beginning of Spring rather than on 1 January, and the month pillar turns at each of the twelve minor solar terms rather than at a calendar month boundary.
    pub date: String,
    /// Birth latitude in decimal degrees. Accepted for consistency with the other birth-data endpoints and does not affect any part of a BaZi chart. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Positive is East, negative is West. Required when hourClock is "local-mean" or "solar", which shift the hour branch to the sun over the birth place; omitting it in either case returns 400. Ignored when hourClock is "clock".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Birth time in 24-hour HH:MM:SS format. Sets the hour pillar, which is one of the four and carries the whole picture of later life and offspring. Each Earthly Branch covers two hours, so a birth within a few minutes of an odd hour can land in either. All four pillars are read in the local clock of the birth, and the day boundary is applied in that same clock; only the lunisolar calendar date itself is a world constant, fixed at UTC plus 8 so one instant has one Chinese date everywhere.
    pub time: String,
    /// Decimal UTC offset the chart was computed with, resolved from whatever the request sent. An IANA name is resolved to the offset in force at the birth, so this is the literal number applied and never the name. A local time that never happened (the skipped hour of a daylight-saving change) is moved forward past the gap, and date, time and timezone then echo the clock that was running, which the day and hour pillars are read from.
    pub timezone: f64,
}
/// Request body of `calculateDayMasterStrength`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateDayMasterStrengthRequest {
    /// Birth date in YYYY-MM-DD format. Sets the year, month and day pillars. The year pillar turns at Beginning of Spring rather than on 1 January, and the month pillar turns at each of the twelve minor solar terms rather than at a calendar month boundary.
    pub date: String,
    /// Which instant starts the sexagenary DAY, which only matters for a birth between 23:00 and 23:59. "midnight" is the classical position of the Ming compendium San Ming Tong Hui: the day turns at 00:00 and 23:00 to 23:59 is the late zi hour of the day that is ending, so the hour stem is taken from that day. "early-zi" turns the whole day at 23:00, the practice in Hong Kong, Taiwan and much of South East Asia. "split-zi" is the compromise most software implements and the default here: the day still turns at 00:00, but the hour stem is taken from the next day. The three give three different answers for a late-evening birth and identical answers for every other birth.
    #[serde(rename = "dayBoundary", skip_serializing_if = "Option::is_none")]
    pub day_boundary: Option<CalculateDayMasterStrengthRequestDayBoundary>,
    /// Which clock the day boundary and the hour branch are read from, so a correction that carries a birth across midnight moves the day pillar with the hour. "clock" is civil time exactly as a birth certificate records it, which is what most calculators use and the default here. "local-mean" shifts to the mean sun over the birth longitude, a correction of up to 59 minutes at the edge of a wide time zone. "solar" adds the equation of time on top of that, up to a further 16 minutes. Both non-civil options need "longitude" in the request and return 400 without it.
    #[serde(rename = "hourClock", skip_serializing_if = "Option::is_none")]
    pub hour_clock: Option<CalculateDayMasterStrengthRequestHourClock>,
    /// Birth latitude in decimal degrees. Accepted for consistency with the other birth-data endpoints and does not affect any part of a BaZi chart. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Positive is East, negative is West. Required when hourClock is "local-mean" or "solar", which shift the hour branch to the sun over the birth place; omitting it in either case returns 400. Ignored when hourClock is "clock".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Birth time in 24-hour HH:MM:SS format. Sets the hour pillar, which is one of the four and carries the whole picture of later life and offspring. Each Earthly Branch covers two hours, so a birth within a few minutes of an odd hour can land in either. All four pillars are read in the local clock of the birth, and the day boundary is applied in that same clock; only the lunisolar calendar date itself is a world constant, fixed at UTC plus 8 so one instant has one Chinese date everywhere.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: CalculateDayMasterStrengthRequestTimezone,
    /// Which instant starts the sexagenary YEAR. "li-chun" is Beginning of Spring, around 4 February, and is the classical rule every BaZi text uses, so it is the default on this endpoint. "lunar-new-year" is the folk rule people mean when they say which animal they are, and it falls between late January and late February. The two disagree for any birth in the weeks between them: 14 February 2026 is a Wood Snake year under lunar-new-year and a Fire Horse year under li-chun.
    #[serde(rename = "yearBoundary", skip_serializing_if = "Option::is_none")]
    pub year_boundary: Option<CalculateDayMasterStrengthRequestYearBoundary>,
}
string_enum! {
    /// Which instant starts the sexagenary YEAR. "li-chun" is Beginning of Spring, around 4 February, and is the classical rule every BaZi text uses, so it is the default on this endpoint. "lunar-new-year" is the folk rule people mean when they say which animal they are, and it falls between late January and late February. The two disagree for any birth in the weeks between them: 14 February 2026 is a Wood Snake year under lunar-new-year and a Fire Horse year under li-chun.
    CalculateDayMasterStrengthRequestYearBoundary {
        LiChun = "li-chun",
        LunarNewYear = "lunar-new-year",
    }
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateDayMasterStrengthRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Which clock the day boundary and the hour branch are read from, so a correction that carries a birth across midnight moves the day pillar with the hour. "clock" is civil time exactly as a birth certificate records it, which is what most calculators use and the default here. "local-mean" shifts to the mean sun over the birth longitude, a correction of up to 59 minutes at the edge of a wide time zone. "solar" adds the equation of time on top of that, up to a further 16 minutes. Both non-civil options need "longitude" in the request and return 400 without it.
    CalculateDayMasterStrengthRequestHourClock {
        Clock = "clock",
        LocalMean = "local-mean",
        Solar = "solar",
    }
}
string_enum! {
    /// Which instant starts the sexagenary DAY, which only matters for a birth between 23:00 and 23:59. "midnight" is the classical position of the Ming compendium San Ming Tong Hui: the day turns at 00:00 and 23:00 to 23:59 is the late zi hour of the day that is ending, so the hour stem is taken from that day. "early-zi" turns the whole day at 23:00, the practice in Hong Kong, Taiwan and much of South East Asia. "split-zi" is the compromise most software implements and the default here: the day still turns at 00:00, but the hour stem is taken from the next day. The three give three different answers for a late-evening birth and identical answers for every other birth.
    CalculateDayMasterStrengthRequestDayBoundary {
        SplitZi = "split-zi",
        Midnight = "midnight",
        EarlyZi = "early-zi",
    }
}
/// Path and query parameters of `calculateDayMasterStrength`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateDayMasterStrengthParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateDayMasterStrengthParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateDayMasterStrengthParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `calculateDashakoot`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateDashakootParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateDashakootParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateDashakootParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateConnection`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateConnectionResponse {
    /// All nine centers with their defined state in the combined connection bodygraph and which person defines each.
    pub centers: Vec<CalculateConnectionResponseCentersItem>,
    /// Every connected channel between the two people with its dynamic. A channel is connected when the two people together hold both of its gates.
    pub channels: Vec<CalculateConnectionResponseChannelsItem>,
    /// Definition of the combined connection bodygraph from connected components among its defined centers. One of None, Single, Split, Triple Split, Quadruple Split. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use combinedDefinitionLocalized for anything a reader sees.
    #[serde(rename = "combinedDefinition")]
    pub combined_definition: String,
    /// Combined definition name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(
        rename = "combinedDefinitionLocalized",
        skip_serializing_if = "Option::is_none"
    )]
    pub combined_definition_localized: Option<String>,
    /// All unique active Human Design gate numbers for person A, in ascending order, including hanging gates that do not complete a channel. Use with personBGates to draw every activation on the combined bodygraph. Gate numbers are machine identifiers and do not change with lang.
    #[serde(rename = "personAGates", skip_serializing_if = "Option::is_none")]
    pub person_agates: Option<Vec<i64>>,
    /// All unique active Human Design gate numbers for person B, in ascending order, including hanging gates that do not complete a channel. Use with personAGates to draw every activation on the combined bodygraph. Gate numbers are machine identifiers and do not change with lang.
    #[serde(rename = "personBGates", skip_serializing_if = "Option::is_none")]
    pub person_bgates: Option<Vec<i64>>,
    /// Count of each connection dynamic across all connected channels.
    pub summary: CalculateConnectionResponseSummary,
    /// Total number of connected channels between the two people. Equals the length of channels and the sum of the summary counts.
    #[serde(rename = "totalChannels")]
    pub total_channels: f64,
}
/// Count of each connection dynamic across all connected channels.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateConnectionResponseSummary {
    /// Count of companionship channels, where both people share the whole channel.
    pub companionship: f64,
    /// Count of compromise channels, a full channel meeting a single hanging gate.
    pub compromise: f64,
    /// Count of dominance channels, where one person conditions the other one way.
    pub dominance: f64,
    /// Count of electromagnetic channels, the points of mutual attraction.
    pub electromagnetic: f64,
}
/// One entry of `channels`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateConnectionResponseChannelsItem {
    /// The two centers this channel connects in the bodygraph.
    pub centers: Vec<String>,
    /// Circuit family of the channel. One of Individual, Collective, Tribal. Always English, whatever the lang parameter says. Use circuitLocalized for anything a reader sees.
    pub circuit: String,
    /// Circuit family name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "circuitLocalized", skip_serializing_if = "Option::is_none")]
    pub circuit_localized: Option<String>,
    /// Connection dynamic for this channel. Electromagnetic means each person holds one of the two gates and the channel completes only together, the classic point of attraction. Dominance means one person holds both gates and the other holds neither, a one-way conditioning. Compromise means one person holds both gates and the other holds a single hanging gate. Companionship means both people independently hold both gates, a shared and familiar frequency. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use dynamicLocalized for anything a reader sees.
    pub dynamic: String,
    /// Connection dynamic name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "dynamicLocalized", skip_serializing_if = "Option::is_none")]
    pub dynamic_localized: Option<String>,
    /// First gate of the channel.
    #[serde(rename = "gateA")]
    pub gate_a: f64,
    /// Second gate of the channel.
    #[serde(rename = "gateB")]
    pub gate_b: f64,
    /// Name of the channel whose connection dynamic is reported. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Channel name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Which of the channel two gates person A holds, from one to both.
    #[serde(rename = "personAGates")]
    pub person_agates: Vec<f64>,
    /// Which of the channel two gates person B holds, from one to both.
    #[serde(rename = "personBGates")]
    pub person_bgates: Vec<f64>,
}
/// One entry of `centers`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateConnectionResponseCentersItem {
    /// Whether the center is defined in the combined connection bodygraph, where a channel counts as defined when the two people together hold both of its gates.
    pub defined: bool,
    /// Who defines this center in their own chart. A, B, both, or empty when the center is open in both individual charts.
    #[serde(rename = "definedBy")]
    pub defined_by: Vec<String>,
    /// Center identifier. One of head, ajna, throat, g, heart, sacral, solar-plexus, spleen, root.
    pub id: String,
    /// Display name of the center. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Center name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
}
/// Request body of `calculateConnection`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateConnectionRequest {
    /// Birth moment of the first person in the connection.
    #[serde(rename = "personA")]
    pub person_a: CalculateConnectionRequestPersonA,
    /// Birth moment of the second person in the connection.
    #[serde(rename = "personB")]
    pub person_b: CalculateConnectionRequestPersonB,
}
/// Birth moment of the second person in the connection.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateConnectionRequestPersonB {
    /// Birth date in YYYY-MM-DD format. The anchor for both the Personality activations at birth and the Design activations 88 degrees of solar arc earlier.
    pub date: String,
    /// Birth latitude in decimal degrees. Optional and does not affect the bodygraph, which depends only on ecliptic longitudes. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Optional and does not affect the bodygraph. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<CalculateConnectionRequestPersonBNodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Precision matters: the profile lines and gate boundaries shift with the exact minute of birth.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: CalculateConnectionRequestPersonBTimezone,
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateConnectionRequestPersonBTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    CalculateConnectionRequestPersonBNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Birth moment of the first person in the connection.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateConnectionRequestPersonA {
    /// Birth date in YYYY-MM-DD format. The anchor for both the Personality activations at birth and the Design activations 88 degrees of solar arc earlier.
    pub date: String,
    /// Birth latitude in decimal degrees. Optional and does not affect the bodygraph, which depends only on ecliptic longitudes. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Optional and does not affect the bodygraph. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<CalculateConnectionRequestPersonANodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Precision matters: the profile lines and gate boundaries shift with the exact minute of birth.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: CalculateConnectionRequestPersonATimezone,
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateConnectionRequestPersonATimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    CalculateConnectionRequestPersonANodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Path and query parameters of `calculateConnection`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateConnectionParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateConnectionParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateConnectionParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateCompatibility`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponse {
    /// Relationship archetype based on score pattern, category strengths, and elemental balance. One of eight archetypes: Kindred Spirits, Opposites Attract, The Power Couple, The Nurturers, The Adventurers, Growth Partners, The Balancers, The Mystics.
    pub archetype: CalculateCompatibilityResponseArchetype,
    /// Synastry aspect breakdown showing the balance of harmonious, challenging, and neutral inter-chart aspects.
    #[serde(rename = "aspectBreakdown")]
    pub aspect_breakdown: CalculateCompatibilityResponseAspectBreakdown,
    /// Compatibility breakdown by life area. Each category evaluates specific planetary pair interactions that govern that domain.
    pub categories: CalculateCompatibilityResponseCategories,
    /// Potential friction points based on challenging inter-chart aspects. Each includes specific guidance for navigating the tension.
    pub challenges: Vec<String>,
    /// Elemental balance comparison. Shows how fire, earth, air, and water energy is distributed across both charts.
    #[serde(rename = "elementBalance")]
    pub element_balance: CalculateCompatibilityResponseElementBalance,
    /// Detailed compatibility interpretation analyzing the synastry aspect patterns between both charts.
    pub interpretation: String,
    /// The most significant inter-chart aspects involving personal planets (Sun through Saturn), sorted by strength. Each includes a relationship-specific interpretation.
    #[serde(rename = "keyAspects")]
    pub key_aspects: Vec<CalculateCompatibilityResponseKeyAspectsItem>,
    /// Overall compatibility score (0-100). Weighted average across romantic, emotional, intellectual, physical, and spiritual categories.
    #[serde(rename = "overallScore")]
    pub overall_score: f64,
    /// Summary of key planetary positions for both people. Includes the four planets most relevant to relationship compatibility.
    pub persons: CalculateCompatibilityResponsePersons,
    /// Sign-by-sign compatibility analysis for the four key relationship planets. Each entry describes how the two signs interact through that planetary lens.
    #[serde(rename = "signCompatibility")]
    pub sign_compatibility: CalculateCompatibilityResponseSignCompatibility,
    /// Top relationship strengths based on harmonious inter-chart aspects. Each includes the planet pair, aspect type, and relationship-specific interpretation.
    pub strengths: Vec<String>,
    /// Narrative overview of the relationship compatibility, highlighting the dominant themes.
    pub summary: String,
}
/// Sign-by-sign compatibility analysis for the four key relationship planets. Each entry describes how the two signs interact through that planetary lens.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponseSignCompatibility {
    /// Mars sign compatibility. Reveals how you handle passion, conflict, and desire.
    pub mars: CalculateCompatibilityResponseSignCompatibilityMars,
    /// Moon sign compatibility. Reveals how you process emotions and nurture each other.
    pub moon: CalculateCompatibilityResponseSignCompatibilityMoon,
    /// Sun sign compatibility. Reveals core personality dynamic as a couple.
    pub sun: CalculateCompatibilityResponseSignCompatibilitySun,
    /// Venus sign compatibility. Reveals love languages and what you find beautiful together.
    pub venus: CalculateCompatibilityResponseSignCompatibilityVenus,
}
/// Venus sign compatibility. Reveals love languages and what you find beautiful together.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponseSignCompatibilityVenus {
    /// Narrative analysis of how these two signs interact through this planet.
    pub description: String,
    /// Person 1 sign for this planet.
    #[serde(rename = "person1Sign")]
    pub person1_sign: String,
    /// Person 2 sign for this planet.
    #[serde(rename = "person2Sign")]
    pub person2_sign: String,
}
/// Sun sign compatibility. Reveals core personality dynamic as a couple.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponseSignCompatibilitySun {
    /// Narrative analysis of how these two signs interact through this planet.
    pub description: String,
    /// Person 1 sign for this planet.
    #[serde(rename = "person1Sign")]
    pub person1_sign: String,
    /// Person 2 sign for this planet.
    #[serde(rename = "person2Sign")]
    pub person2_sign: String,
}
/// Moon sign compatibility. Reveals how you process emotions and nurture each other.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponseSignCompatibilityMoon {
    /// Narrative analysis of how these two signs interact through this planet.
    pub description: String,
    /// Person 1 sign for this planet.
    #[serde(rename = "person1Sign")]
    pub person1_sign: String,
    /// Person 2 sign for this planet.
    #[serde(rename = "person2Sign")]
    pub person2_sign: String,
}
/// Mars sign compatibility. Reveals how you handle passion, conflict, and desire.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponseSignCompatibilityMars {
    /// Narrative analysis of how these two signs interact through this planet.
    pub description: String,
    /// Person 1 sign for this planet.
    #[serde(rename = "person1Sign")]
    pub person1_sign: String,
    /// Person 2 sign for this planet.
    #[serde(rename = "person2Sign")]
    pub person2_sign: String,
}
/// Summary of key planetary positions for both people. Includes the four planets most relevant to relationship compatibility.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponsePersons {
    /// Key planet positions for person 1. Sun, Moon, Venus, and Mars sign placements.
    pub person1: CalculateCompatibilityResponsePersonsPerson1,
    /// Key planet positions for person 2. Sun, Moon, Venus, and Mars sign placements.
    pub person2: CalculateCompatibilityResponsePersonsPerson2,
}
/// Key planet positions for person 2. Sun, Moon, Venus, and Mars sign placements.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponsePersonsPerson2 {
    /// Mars sign position. Passion, desire, and conflict style.
    pub mars: CalculateCompatibilityResponsePersonsPerson2Mars,
    /// Moon sign position. Emotional nature and instincts.
    pub moon: CalculateCompatibilityResponsePersonsPerson2Moon,
    /// Sun sign position. Core identity and ego.
    pub sun: CalculateCompatibilityResponsePersonsPerson2Sun,
    /// Venus sign position. Love language and relationship style.
    pub venus: CalculateCompatibilityResponsePersonsPerson2Venus,
}
/// Venus sign position. Love language and relationship style.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponsePersonsPerson2Venus {
    /// Degree within the zodiac sign (0-29.999).
    pub degree: f64,
    /// Zodiac sign this planet occupies in the tropical zodiac.
    pub sign: String,
}
/// Sun sign position. Core identity and ego.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponsePersonsPerson2Sun {
    /// Degree within the zodiac sign (0-29.999).
    pub degree: f64,
    /// Zodiac sign this planet occupies in the tropical zodiac.
    pub sign: String,
}
/// Moon sign position. Emotional nature and instincts.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponsePersonsPerson2Moon {
    /// Degree within the zodiac sign (0-29.999).
    pub degree: f64,
    /// Zodiac sign this planet occupies in the tropical zodiac.
    pub sign: String,
}
/// Mars sign position. Passion, desire, and conflict style.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponsePersonsPerson2Mars {
    /// Degree within the zodiac sign (0-29.999).
    pub degree: f64,
    /// Zodiac sign this planet occupies in the tropical zodiac.
    pub sign: String,
}
/// Key planet positions for person 1. Sun, Moon, Venus, and Mars sign placements.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponsePersonsPerson1 {
    /// Mars sign position. Passion, desire, and conflict style.
    pub mars: CalculateCompatibilityResponsePersonsPerson1Mars,
    /// Moon sign position. Emotional nature and instincts.
    pub moon: CalculateCompatibilityResponsePersonsPerson1Moon,
    /// Sun sign position. Core identity and ego.
    pub sun: CalculateCompatibilityResponsePersonsPerson1Sun,
    /// Venus sign position. Love language and relationship style.
    pub venus: CalculateCompatibilityResponsePersonsPerson1Venus,
}
/// Venus sign position. Love language and relationship style.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponsePersonsPerson1Venus {
    /// Degree within the zodiac sign (0-29.999).
    pub degree: f64,
    /// Zodiac sign this planet occupies in the tropical zodiac.
    pub sign: String,
}
/// Sun sign position. Core identity and ego.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponsePersonsPerson1Sun {
    /// Degree within the zodiac sign (0-29.999).
    pub degree: f64,
    /// Zodiac sign this planet occupies in the tropical zodiac.
    pub sign: String,
}
/// Moon sign position. Emotional nature and instincts.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponsePersonsPerson1Moon {
    /// Degree within the zodiac sign (0-29.999).
    pub degree: f64,
    /// Zodiac sign this planet occupies in the tropical zodiac.
    pub sign: String,
}
/// Mars sign position. Passion, desire, and conflict style.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponsePersonsPerson1Mars {
    /// Degree within the zodiac sign (0-29.999).
    pub degree: f64,
    /// Zodiac sign this planet occupies in the tropical zodiac.
    pub sign: String,
}
/// One entry of `keyAspects`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponseKeyAspectsItem {
    /// Relationship-specific interpretation of this aspect between the two charts.
    pub description: String,
    /// Aspect nature. Harmonious flows easily. Challenging creates growth-oriented tension.
    pub interpretation: CalculateCompatibilityResponseKeyAspectsItemInterpretation,
    /// Deviation from exact aspect in degrees. Tighter orb = stronger influence.
    pub orb: f64,
    /// First planet in the aspect.
    pub planet1: String,
    /// Second planet in the aspect.
    pub planet2: String,
    /// Aspect type (conjunction, trine, square, etc.).
    pub r#type: String,
}
string_enum! {
    /// Aspect nature. Harmonious flows easily. Challenging creates growth-oriented tension.
    CalculateCompatibilityResponseKeyAspectsItemInterpretation {
        Harmonious = "harmonious",
        Challenging = "challenging",
        Neutral = "neutral",
    }
}
/// Elemental balance comparison. Shows how fire, earth, air, and water energy is distributed across both charts.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponseElementBalance {
    /// How the elemental balance between charts shapes the relationship dynamic.
    pub description: String,
    /// Element distribution across person 1 natal planets.
    pub person1: CalculateCompatibilityResponseElementBalancePerson1,
    /// Element distribution across person 2 natal planets.
    pub person2: CalculateCompatibilityResponseElementBalancePerson2,
    /// Dominant element shared by both charts, or null if dominant elements differ.
    #[serde(rename = "sharedElement")]
    pub shared_element: Option<String>,
}
/// Element distribution across person 2 natal planets.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponseElementBalancePerson2 {
    /// Count of planets in air signs (Gemini, Libra, Aquarius).
    pub air: f64,
    /// Count of planets in earth signs (Taurus, Virgo, Capricorn).
    pub earth: f64,
    /// Count of planets in fire signs (Aries, Leo, Sagittarius).
    pub fire: f64,
    /// Count of planets in water signs (Cancer, Scorpio, Pisces).
    pub water: f64,
}
/// Element distribution across person 1 natal planets.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponseElementBalancePerson1 {
    /// Count of planets in air signs (Gemini, Libra, Aquarius).
    pub air: f64,
    /// Count of planets in earth signs (Taurus, Virgo, Capricorn).
    pub earth: f64,
    /// Count of planets in fire signs (Aries, Leo, Sagittarius).
    pub fire: f64,
    /// Count of planets in water signs (Cancer, Scorpio, Pisces).
    pub water: f64,
}
/// Compatibility breakdown by life area. Each category evaluates specific planetary pair interactions that govern that domain.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponseCategories {
    /// Emotional compatibility score based on Moon-Moon and Moon-Venus inter-aspects.
    pub emotional: f64,
    /// Intellectual compatibility score based on Mercury-Mercury and Sun-Mercury inter-aspects.
    pub intellectual: f64,
    /// Physical compatibility score based on Mars-Mars and Mars-Sun inter-aspects.
    pub physical: f64,
    /// Romantic compatibility score based on Sun-Moon, Venus-Mars, and Sun-Venus inter-aspects.
    pub romantic: f64,
    /// Spiritual compatibility score based on Jupiter-Sun and Jupiter-Jupiter inter-aspects.
    pub spiritual: f64,
}
/// Synastry aspect breakdown showing the balance of harmonious, challenging, and neutral inter-chart aspects.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponseAspectBreakdown {
    /// Count of challenging aspects (square, opposition). These create dynamic tension and growth.
    pub challenging: f64,
    /// Count of harmonious aspects (trine, sextile). These indicate natural ease and flow.
    pub harmonious: f64,
    /// Count of neutral aspects (conjunction). Outcome depends on the planets involved.
    pub neutral: f64,
    /// Total number of inter-chart aspects found between the two natal charts.
    pub total: f64,
}
/// Relationship archetype based on score pattern, category strengths, and elemental balance. One of eight archetypes: Kindred Spirits, Opposites Attract, The Power Couple, The Nurturers, The Adventurers, Growth Partners, The Balancers, The Mystics.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityResponseArchetype {
    /// Narrative description of the relationship archetype and what it means.
    pub description: String,
    /// Relationship archetype label. A headline-friendly label for the dynamic.
    pub label: String,
}
/// Request body of `calculateCompatibility`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityRequest {
    /// First person birth details (date, time, location, timezone). Required for calculating natal planetary positions.
    pub person1: CalculateCompatibilityRequestPerson1,
    /// Second person birth details. Compared against person1 to evaluate inter-chart aspects and compatibility.
    pub person2: CalculateCompatibilityRequestPerson2,
}
/// Second person birth details. Compared against person1 to evaluate inter-chart aspects and compatibility.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityRequestPerson2 {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<CalculateCompatibilityRequestPerson2NodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
    pub timezone: CalculateCompatibilityRequestPerson2Timezone,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateCompatibilityRequestPerson2Timezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    CalculateCompatibilityRequestPerson2NodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// First person birth details (date, time, location, timezone). Required for calculating natal planetary positions.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCompatibilityRequestPerson1 {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<CalculateCompatibilityRequestPerson1NodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
    pub timezone: CalculateCompatibilityRequestPerson1Timezone,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateCompatibilityRequestPerson1Timezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    CalculateCompatibilityRequestPerson1NodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Path and query parameters of `calculateCompatibility`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateCompatibilityParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateCompatibilityParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateCompatibilityParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `calculateCharaKarakas`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateCharaKarakasParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateCharaKarakasParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateCharaKarakasParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateChannels`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateChannelsResponse {
    /// The defined channels, where both gates are activated.
    pub channels: Vec<CalculateChannelsResponseChannelsItem>,
    /// The centers defined by these channels.
    #[serde(rename = "definedCenters")]
    pub defined_centers: Vec<String>,
    /// Number of defined channels in the bodygraph.
    pub total: f64,
}
/// One entry of `channels`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateChannelsResponseChannelsItem {
    /// The two centers this channel connects and defines.
    pub centers: Vec<String>,
    /// Circuit family of the channel. One of Individual, Collective, Tribal. Always English, whatever the lang parameter says. Use circuitLocalized for anything a reader sees.
    pub circuit: String,
    /// What the circuit family of this channel governs.
    #[serde(rename = "circuitDescription")]
    pub circuit_description: String,
    /// Circuit family name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "circuitLocalized", skip_serializing_if = "Option::is_none")]
    pub circuit_localized: Option<String>,
    /// What this channel wires between its two centers and the nature of the energy it carries.
    pub description: String,
    /// First gate of the channel.
    #[serde(rename = "gateA")]
    pub gate_a: f64,
    /// Second gate of the channel.
    #[serde(rename = "gateB")]
    pub gate_b: f64,
    /// Name of the defined channel. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Channel name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
}
/// Request body of `calculateChannels`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateChannelsRequest {
    /// Birth date in YYYY-MM-DD format. The anchor for both the Personality activations at birth and the Design activations 88 degrees of solar arc earlier.
    pub date: String,
    /// Birth latitude in decimal degrees. Optional and does not affect the bodygraph, which depends only on ecliptic longitudes. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Optional and does not affect the bodygraph. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<CalculateChannelsRequestNodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Precision matters: the profile lines and gate boundaries shift with the exact minute of birth.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: CalculateChannelsRequestTimezone,
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateChannelsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    CalculateChannelsRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Path and query parameters of `calculateChannels`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateChannelsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateChannelsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateChannelsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateChaldean`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateChaldeanResponse {
    /// True when the Destiny root is 4 or 8, the karmic numbers Cheiro advises adjusting a name away from for material success.
    pub caution: bool,
    /// The Destiny or name number from all letters. The primary Chaldean number, revealing the overall direction encoded in the name.
    pub destiny: CalculateChaldeanResponseDestiny,
    /// The name analyzed.
    pub name: String,
    /// The `numberMeaning` field.
    #[serde(rename = "numberMeaning")]
    pub number_meaning: CalculateChaldeanResponseNumberMeaning,
    /// The Personality number from the consonants, revealing the outer impression. Root may be 0 when the name has no consonants.
    pub personality: CalculateChaldeanResponsePersonality,
    /// The Soul Urge number from the vowels, revealing inner desire. Root may be 0 when the name has no vowels.
    #[serde(rename = "soulUrge")]
    pub soul_urge: CalculateChaldeanResponseSoulUrge,
    /// One-line plain-language summary of the Chaldean reading.
    pub summary: String,
}
/// The Soul Urge number from the vowels, revealing inner desire. Root may be 0 when the name has no vowels.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateChaldeanResponseSoulUrge {
    /// Letter-by-letter Chaldean breakdown, name by name for a longer name, summed to the total, then to compound and root.
    pub calculation: String,
    /// The interpretable compound number (10 to 52), the hidden influence behind the name, or null when the total resolves below 10.
    pub compound: Option<f64>,
    /// Cheiro compound-number interpretation when the aspect carries a compound layer.
    #[serde(rename = "compoundMeaning")]
    pub compound_meaning: Option<CalculateChaldeanResponseSoulUrgeCompoundMeaning>,
    /// The single-digit root (1 to 9), the outward expression. Chaldean does not preserve master numbers.
    pub root: f64,
    /// The sum the compound is read from: for a one-word name, its Chaldean letter total; for a longer name, the sum of each word reduced to its single number, as Cheiro works John Smith (18 to 9, 17 to 8, total 17).
    pub total: f64,
}
/// Cheiro compound-number interpretation when the aspect carries a compound layer.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateChaldeanResponseSoulUrgeCompoundMeaning {
    /// Cheiro interpretation of the hidden influence carried by this compound number.
    pub meaning: String,
    /// Classical symbolic title from Cheiro, or null when the number has no named symbol.
    pub name: Option<String>,
    /// Overall tenor of the compound. "mixed" covers conditional numbers that are fortunate only alongside a favorable single number or in a specific domain.
    pub nature: CalculateChaldeanResponseSoulUrgeCompoundMeaningNature,
    /// The compound number (10 to 52).
    pub number: f64,
    /// For numbers 33 to 52, the lower compound in the same series whose meaning this number shares.
    #[serde(rename = "sameAs", skip_serializing_if = "Option::is_none")]
    pub same_as: Option<f64>,
}
string_enum! {
    /// Overall tenor of the compound. "mixed" covers conditional numbers that are fortunate only alongside a favorable single number or in a specific domain.
    CalculateChaldeanResponseSoulUrgeCompoundMeaningNature {
        Fortunate = "fortunate",
        Unfortunate = "unfortunate",
        Mixed = "mixed",
    }
}
/// The Personality number from the consonants, revealing the outer impression. Root may be 0 when the name has no consonants.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateChaldeanResponsePersonality {
    /// Letter-by-letter Chaldean breakdown, name by name for a longer name, summed to the total, then to compound and root.
    pub calculation: String,
    /// The interpretable compound number (10 to 52), the hidden influence behind the name, or null when the total resolves below 10.
    pub compound: Option<f64>,
    /// Cheiro compound-number interpretation when the aspect carries a compound layer.
    #[serde(rename = "compoundMeaning")]
    pub compound_meaning: Option<CalculateChaldeanResponsePersonalityCompoundMeaning>,
    /// The single-digit root (1 to 9), the outward expression. Chaldean does not preserve master numbers.
    pub root: f64,
    /// The sum the compound is read from: for a one-word name, its Chaldean letter total; for a longer name, the sum of each word reduced to its single number, as Cheiro works John Smith (18 to 9, 17 to 8, total 17).
    pub total: f64,
}
/// Cheiro compound-number interpretation when the aspect carries a compound layer.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateChaldeanResponsePersonalityCompoundMeaning {
    /// Cheiro interpretation of the hidden influence carried by this compound number.
    pub meaning: String,
    /// Classical symbolic title from Cheiro, or null when the number has no named symbol.
    pub name: Option<String>,
    /// Overall tenor of the compound. "mixed" covers conditional numbers that are fortunate only alongside a favorable single number or in a specific domain.
    pub nature: CalculateChaldeanResponsePersonalityCompoundMeaningNature,
    /// The compound number (10 to 52).
    pub number: f64,
    /// For numbers 33 to 52, the lower compound in the same series whose meaning this number shares.
    #[serde(rename = "sameAs", skip_serializing_if = "Option::is_none")]
    pub same_as: Option<f64>,
}
string_enum! {
    /// Overall tenor of the compound. "mixed" covers conditional numbers that are fortunate only alongside a favorable single number or in a specific domain.
    CalculateChaldeanResponsePersonalityCompoundMeaningNature {
        Fortunate = "fortunate",
        Unfortunate = "unfortunate",
        Mixed = "mixed",
    }
}
/// The `numberMeaning` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateChaldeanResponseNumberMeaning {
    /// True for roots 4 and 8, the two numbers Cheiro counsels caution with.
    pub caution: bool,
    /// Core themes of the Destiny root.
    pub keywords: Vec<String>,
    /// Planetary interpretation of the Destiny root number.
    pub meaning: String,
    /// The Destiny root (1 to 9).
    pub number: f64,
    /// Ruling planet.
    pub planet: String,
    /// Archetype of the root number.
    pub title: String,
}
/// The Destiny or name number from all letters. The primary Chaldean number, revealing the overall direction encoded in the name.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateChaldeanResponseDestiny {
    /// Letter-by-letter Chaldean breakdown, name by name for a longer name, summed to the total, then to compound and root.
    pub calculation: String,
    /// The interpretable compound number (10 to 52), the hidden influence behind the name, or null when the total resolves below 10.
    pub compound: Option<f64>,
    /// Cheiro compound-number interpretation when the aspect carries a compound layer.
    #[serde(rename = "compoundMeaning")]
    pub compound_meaning: Option<CalculateChaldeanResponseDestinyCompoundMeaning>,
    /// The single-digit root (1 to 9), the outward expression. Chaldean does not preserve master numbers.
    pub root: f64,
    /// The sum the compound is read from: for a one-word name, its Chaldean letter total; for a longer name, the sum of each word reduced to its single number, as Cheiro works John Smith (18 to 9, 17 to 8, total 17).
    pub total: f64,
}
/// Cheiro compound-number interpretation when the aspect carries a compound layer.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateChaldeanResponseDestinyCompoundMeaning {
    /// Cheiro interpretation of the hidden influence carried by this compound number.
    pub meaning: String,
    /// Classical symbolic title from Cheiro, or null when the number has no named symbol.
    pub name: Option<String>,
    /// Overall tenor of the compound. "mixed" covers conditional numbers that are fortunate only alongside a favorable single number or in a specific domain.
    pub nature: CalculateChaldeanResponseDestinyCompoundMeaningNature,
    /// The compound number (10 to 52).
    pub number: f64,
    /// For numbers 33 to 52, the lower compound in the same series whose meaning this number shares.
    #[serde(rename = "sameAs", skip_serializing_if = "Option::is_none")]
    pub same_as: Option<f64>,
}
string_enum! {
    /// Overall tenor of the compound. "mixed" covers conditional numbers that are fortunate only alongside a favorable single number or in a specific domain.
    CalculateChaldeanResponseDestinyCompoundMeaningNature {
        Fortunate = "fortunate",
        Unfortunate = "unfortunate",
        Mixed = "mixed",
    }
}
/// Path and query parameters of `calculateChaldean`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateChaldeanParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateChaldeanParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateChaldeanParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateCenters`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCentersResponse {
    /// All nine centers with their defined state and active gates.
    pub centers: Vec<CalculateCentersResponseCentersItem>,
    /// How many of the nine centers are defined.
    #[serde(rename = "definedCount")]
    pub defined_count: f64,
}
/// One entry of `centers`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCentersResponseCentersItem {
    /// Whether this is an awareness center. The three awareness centers are Ajna, Solar Plexus, and Spleen.
    pub awareness: bool,
    /// The gland, organ, or system this center corresponds to in the body.
    pub biology: String,
    /// Whether the center is defined. A defined center is a consistent source of energy or awareness; an undefined center is open and conditioned by others.
    pub defined: bool,
    /// Active gate numbers that sit in this center.
    pub gates: Vec<f64>,
    /// Center identifier. One of head, ajna, throat, g, heart, sacral, solar-plexus, spleen, root.
    pub id: String,
    /// Whether this is a motor center (energy source). The four motors are Heart, Sacral, Solar Plexus, and Root.
    pub motor: bool,
    /// Display name of the center. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Center name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// The conditioning trap of this center when it is open. Returned on every center so a consumer can surface it the moment `defined` is false, which is where the not-self operates.
    #[serde(rename = "notSelfQuestion")]
    pub not_self_question: String,
    /// Theme text describing the center in its current defined or undefined state.
    pub theme: String,
}
/// Request body of `calculateCenters`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateCentersRequest {
    /// Birth date in YYYY-MM-DD format. The anchor for both the Personality activations at birth and the Design activations 88 degrees of solar arc earlier.
    pub date: String,
    /// Birth latitude in decimal degrees. Optional and does not affect the bodygraph, which depends only on ecliptic longitudes. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Optional and does not affect the bodygraph. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<CalculateCentersRequestNodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Precision matters: the profile lines and gate boundaries shift with the exact minute of birth.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: CalculateCentersRequestTimezone,
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateCentersRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node activations. True is what professional Human Design software uses (HumanDesign.ai, Total Human Design) and is the value RoxyAPI verifies against, so leave it unset for a standard chart. It matters only when a node sits on a gate boundary, where the choice moves a node gate. Because a gate can be half of a channel, that can change the completed channels and, with them, whether a center reads defined or open, plus the definition, authority, profile or type. A chart where only one center disagrees is the usual shape, since the type and profile often survive unchanged. If another calculator disagrees on any of those, it is almost certainly using the mean node: pass "mean" to match it. Defaults to "true".
    CalculateCentersRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Path and query parameters of `calculateCenters`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateCentersParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateCentersParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateCentersParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateBusinessName`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBusinessNameResponse {
    /// Chaldean letter breakdown of the business name.
    pub calculation: String,
    /// Chaldean compound number (10 to 52), the hidden influence, or null.
    pub compound: Option<f64>,
    /// Cheiro compound interpretation when present.
    #[serde(rename = "compoundMeaning")]
    pub compound_meaning: Option<CalculateBusinessNameResponseCompoundMeaning>,
    /// True when the compound number is one of Cheiro fortunate compounds, an extra positive signal layered over the root rating.
    #[serde(rename = "favorableCompound")]
    pub favorable_compound: bool,
    /// Plain-language guidance for using this number as a brand.
    pub guidance: String,
    /// Industries the business root favors.
    pub industries: Vec<String>,
    /// The business name analyzed.
    pub name: String,
    /// Planetary ruler of the business root.
    pub planet: String,
    /// Overall favorability of the root for business. excellent and good are growth-friendly; caution (7, 8) and avoid (4) flag the demanding and unstable roots.
    pub rating: CalculateBusinessNameResponseRating,
    /// Single-digit business root (1 to 9), the outward commercial expression.
    pub root: f64,
    /// One-line plain-language verdict for the business name.
    pub summary: String,
    /// The sum the compound is read from: for a one-word name, its Chaldean letter total; for a longer name, the sum of each word reduced to its single number, as Cheiro works John Smith (18 to 9, 17 to 8, total 17).
    pub total: f64,
}
string_enum! {
    /// Overall favorability of the root for business. excellent and good are growth-friendly; caution (7, 8) and avoid (4) flag the demanding and unstable roots.
    CalculateBusinessNameResponseRating {
        Excellent = "excellent",
        Good = "good",
        Caution = "caution",
        Avoid = "avoid",
    }
}
/// Cheiro compound interpretation when present.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBusinessNameResponseCompoundMeaning {
    /// Cheiro interpretation.
    pub meaning: String,
    /// Symbolic title, if any.
    pub name: Option<String>,
    /// Tenor of the compound.
    pub nature: CalculateBusinessNameResponseCompoundMeaningNature,
    /// The compound number.
    pub number: f64,
    /// Series equivalent for 33 to 52.
    #[serde(rename = "sameAs", skip_serializing_if = "Option::is_none")]
    pub same_as: Option<f64>,
}
string_enum! {
    /// Tenor of the compound.
    CalculateBusinessNameResponseCompoundMeaningNature {
        Fortunate = "fortunate",
        Unfortunate = "unfortunate",
        Mixed = "mixed",
    }
}
/// Path and query parameters of `calculateBusinessName`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateBusinessNameParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateBusinessNameParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateBusinessNameParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateBridgeNumbers`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBridgeNumbersResponse {
    /// Bridge between Expression and Personality numbers, a pairing this API adds beside the classical bridges. Reveals the gap between your true talents (all letters) and how others perceive you (consonants only). A high bridge means others may not see your real capabilities, requiring you to present yourself more authentically.
    #[serde(rename = "expressionPersonality")]
    pub expression_personality: CalculateBridgeNumbersResponseExpressionPersonality,
    /// Bridge between Expression and Soul Urge numbers. Reveals the gap between your outward talents (all letters) and your deepest inner desires (vowels only). A high bridge means what you are good at may differ from what your soul truly craves, calling for realignment.
    #[serde(rename = "expressionSoulUrge")]
    pub expression_soul_urge: CalculateBridgeNumbersResponseExpressionSoulUrge,
    /// Bridge between Life Path and Expression numbers. Reveals the gap between your destined life purpose (from birth date) and your natural talents and abilities (from birth name). A high bridge here means your innate skills may not directly serve your life mission without conscious effort.
    #[serde(rename = "lifePathExpression")]
    pub life_path_expression: CalculateBridgeNumbersResponseLifePathExpression,
    /// Bridge between Soul Urge and Personality numbers, one of the classical bridges. Reveals the gap between your inner self (vowels only) and the image others meet first (consonants only). A high bridge means what you want and how you come across pull apart, calling for a more transparent presentation of your real motives.
    #[serde(rename = "soulUrgePersonality")]
    pub soul_urge_personality: CalculateBridgeNumbersResponseSoulUrgePersonality,
}
/// Bridge between Soul Urge and Personality numbers, one of the classical bridges. Reveals the gap between your inner self (vowels only) and the image others meet first (consonants only). A high bridge means what you want and how you come across pull apart, calling for a more transparent presentation of your real motives.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBridgeNumbersResponseSoulUrgePersonality {
    /// Bridge number (0 to 8). The absolute difference between two core numerology numbers after reducing master numbers to single digits. 0 means the two aspects are already in natural harmony. Higher values indicate greater tension requiring conscious adjustment.
    pub bridge: i64,
    /// The `from` field.
    pub from: CalculateBridgeNumbersResponseSoulUrgePersonalityFrom,
    /// Actionable guidance for bridging the gap between these two aspects of your numerology profile. Explains what adjustments to make to bring these energies into harmony.
    pub meaning: String,
    /// The `to` field.
    pub to: CalculateBridgeNumbersResponseSoulUrgePersonalityTo,
}
/// The `to` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBridgeNumbersResponseSoulUrgePersonalityTo {
    /// Name of the second core number in this bridge pair. Identifies the other aspect of personality or destiny being compared.
    pub name: String,
    /// The reduced single-digit value (1 to 9) of the second core number used in the bridge calculation.
    pub number: f64,
}
/// The `from` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBridgeNumbersResponseSoulUrgePersonalityFrom {
    /// Name of the first core number in this bridge pair. Identifies which aspect of personality or destiny is being compared.
    pub name: String,
    /// The reduced single-digit value (1 to 9) of the first core number used in the bridge calculation.
    pub number: f64,
}
/// Bridge between Life Path and Expression numbers. Reveals the gap between your destined life purpose (from birth date) and your natural talents and abilities (from birth name). A high bridge here means your innate skills may not directly serve your life mission without conscious effort.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBridgeNumbersResponseLifePathExpression {
    /// Bridge number (0 to 8). The absolute difference between two core numerology numbers after reducing master numbers to single digits. 0 means the two aspects are already in natural harmony. Higher values indicate greater tension requiring conscious adjustment.
    pub bridge: i64,
    /// The `from` field.
    pub from: CalculateBridgeNumbersResponseLifePathExpressionFrom,
    /// Actionable guidance for bridging the gap between these two aspects of your numerology profile. Explains what adjustments to make to bring these energies into harmony.
    pub meaning: String,
    /// The `to` field.
    pub to: CalculateBridgeNumbersResponseLifePathExpressionTo,
}
/// The `to` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBridgeNumbersResponseLifePathExpressionTo {
    /// Name of the second core number in this bridge pair. Identifies the other aspect of personality or destiny being compared.
    pub name: String,
    /// The reduced single-digit value (1 to 9) of the second core number used in the bridge calculation.
    pub number: f64,
}
/// The `from` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBridgeNumbersResponseLifePathExpressionFrom {
    /// Name of the first core number in this bridge pair. Identifies which aspect of personality or destiny is being compared.
    pub name: String,
    /// The reduced single-digit value (1 to 9) of the first core number used in the bridge calculation.
    pub number: f64,
}
/// Bridge between Expression and Soul Urge numbers. Reveals the gap between your outward talents (all letters) and your deepest inner desires (vowels only). A high bridge means what you are good at may differ from what your soul truly craves, calling for realignment.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBridgeNumbersResponseExpressionSoulUrge {
    /// Bridge number (0 to 8). The absolute difference between two core numerology numbers after reducing master numbers to single digits. 0 means the two aspects are already in natural harmony. Higher values indicate greater tension requiring conscious adjustment.
    pub bridge: i64,
    /// The `from` field.
    pub from: CalculateBridgeNumbersResponseExpressionSoulUrgeFrom,
    /// Actionable guidance for bridging the gap between these two aspects of your numerology profile. Explains what adjustments to make to bring these energies into harmony.
    pub meaning: String,
    /// The `to` field.
    pub to: CalculateBridgeNumbersResponseExpressionSoulUrgeTo,
}
/// The `to` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBridgeNumbersResponseExpressionSoulUrgeTo {
    /// Name of the second core number in this bridge pair. Identifies the other aspect of personality or destiny being compared.
    pub name: String,
    /// The reduced single-digit value (1 to 9) of the second core number used in the bridge calculation.
    pub number: f64,
}
/// The `from` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBridgeNumbersResponseExpressionSoulUrgeFrom {
    /// Name of the first core number in this bridge pair. Identifies which aspect of personality or destiny is being compared.
    pub name: String,
    /// The reduced single-digit value (1 to 9) of the first core number used in the bridge calculation.
    pub number: f64,
}
/// Bridge between Expression and Personality numbers, a pairing this API adds beside the classical bridges. Reveals the gap between your true talents (all letters) and how others perceive you (consonants only). A high bridge means others may not see your real capabilities, requiring you to present yourself more authentically.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBridgeNumbersResponseExpressionPersonality {
    /// Bridge number (0 to 8). The absolute difference between two core numerology numbers after reducing master numbers to single digits. 0 means the two aspects are already in natural harmony. Higher values indicate greater tension requiring conscious adjustment.
    pub bridge: i64,
    /// The `from` field.
    pub from: CalculateBridgeNumbersResponseExpressionPersonalityFrom,
    /// Actionable guidance for bridging the gap between these two aspects of your numerology profile. Explains what adjustments to make to bring these energies into harmony.
    pub meaning: String,
    /// The `to` field.
    pub to: CalculateBridgeNumbersResponseExpressionPersonalityTo,
}
/// The `to` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBridgeNumbersResponseExpressionPersonalityTo {
    /// Name of the second core number in this bridge pair. Identifies the other aspect of personality or destiny being compared.
    pub name: String,
    /// The reduced single-digit value (1 to 9) of the second core number used in the bridge calculation.
    pub number: f64,
}
/// The `from` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBridgeNumbersResponseExpressionPersonalityFrom {
    /// Name of the first core number in this bridge pair. Identifies which aspect of personality or destiny is being compared.
    pub name: String,
    /// The reduced single-digit value (1 to 9) of the first core number used in the bridge calculation.
    pub number: f64,
}
/// Path and query parameters of `calculateBridgeNumbers`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateBridgeNumbersParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateBridgeNumbersParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateBridgeNumbersParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateBirthDay`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBirthDayResponse {
    /// Step-by-step digit reduction of the birth day. Single-digit days (1 to 9) remain as they are, a day that is or reduces to 11 or 22 keeps it, and every other two-digit day is reduced to one digit.
    pub calculation: String,
    /// Indicates whether a Karmic Debt number (13, 14, 16, or 19) corresponds to the birth day. Karmic Debt in the Birth Day position reveals past-life challenges woven directly into your natural talents, influencing how your gifts manifest.
    #[serde(rename = "hasKarmicDebt")]
    pub has_karmic_debt: bool,
    /// Detailed interpretation of the Karmic Debt number when present. Only returned when hasKarmicDebt is true.
    #[serde(rename = "karmicDebtMeaning", skip_serializing_if = "Option::is_none")]
    pub karmic_debt_meaning: Option<CalculateBirthDayResponseKarmicDebtMeaning>,
    /// The specific Karmic Debt number detected from the birth day, if any. Each debt number (13, 14, 16, 19) represents a distinct past-life lesson embedded in the talents your birth day bestows.
    #[serde(rename = "karmicDebtNumber", skip_serializing_if = "Option::is_none")]
    pub karmic_debt_number: Option<f64>,
    /// The `meaning` field.
    pub meaning: CalculateBirthDayResponseMeaning,
    /// Your Birth Day number, revealing the special talents and innate abilities you carry from the day you were born. Values range from 1 to 9 for single digits, or 11, 22 for Master Numbers (the 11th, 22nd and 29th).
    pub number: f64,
    /// Whether this is a standard single-digit number (1 to 9) or a Master Number (11, 22). Master Numbers in the Birth Day position indicate extraordinary innate gifts that are available from birth and demand conscious development.
    pub r#type: CalculateBirthDayResponseType,
}
string_enum! {
    /// Whether this is a standard single-digit number (1 to 9) or a Master Number (11, 22). Master Numbers in the Birth Day position indicate extraordinary innate gifts that are available from birth and demand conscious development.
    CalculateBirthDayResponseType {
        Single = "single",
        Master = "master",
    }
}
/// The `meaning` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBirthDayResponseMeaning {
    /// Professional paths where your birth day talents create an immediate advantage. Covers specific roles, industries, and work styles that align with your innate abilities.
    pub career: String,
    /// The flip side of your gifts. Each challenge explains how an overreliance on natural talent can become a liability without conscious balance.
    pub challenges: Vec<String>,
    /// Core interpretation of the special abilities the birth day brings and how they complement the Life Path and Expression numbers. Together with the strengths, challenges, career, relationships and spirituality fields it makes a full reading.
    pub description: String,
    /// Innate talents and natural aptitudes encoded in your birth day. These gifts are available from birth and become more refined with age.
    pub keywords: Vec<String>,
    /// How your birth day gifts shape the way you connect with others. Covers romantic chemistry, friendship dynamics, and the relationship patterns rooted in your natural temperament.
    pub relationships: String,
    /// The spiritual dimension of your natural gifts. Explores how your birth day talents serve a higher purpose and the practices that help you channel them with intention.
    pub spirituality: String,
    /// Natural-born strengths that come effortlessly. These are the talents you can rely on even without formal training or conscious development.
    pub strengths: Vec<String>,
    /// Numerology archetype for this Birth Day number. Represents the specific talent or gift you brought into this life, like "The Nurturer" for 6 or "The Seeker" for 7.
    pub title: String,
}
/// Detailed interpretation of the Karmic Debt number when present. Only returned when hasKarmicDebt is true.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBirthDayResponseKarmicDebtMeaning {
    /// The specific challenge from past lives that must be confronted.
    pub challenge: String,
    /// Title describing the karmic debt theme and core past-life pattern.
    pub description: String,
    /// Practical guidance for resolving the karmic debt.
    pub resolution: String,
}
/// Path and query parameters of `calculateBirthDay`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateBirthDayParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateBirthDayParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateBirthDayParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateBioCompatibility`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBioCompatibilityResponse {
    /// Practical relationship guidance based on the combined cycle analysis.
    pub advice: String,
    /// Potential relationship challenges to be aware of.
    pub challenges: Vec<String>,
    /// Per-cycle compatibility analysis for physical, emotional, and intellectual cycles.
    pub cycles: CalculateBioCompatibilityResponseCycles,
    /// The `dailySync` field.
    #[serde(rename = "dailySync")]
    pub daily_sync: CalculateBioCompatibilityResponseDailySync,
    /// Overall compatibility score from 0 (fully opposed) to 100 (perfectly synchronized).
    #[serde(rename = "overallScore")]
    pub overall_score: f64,
    /// The `person1` field.
    pub person1: CalculateBioCompatibilityResponsePerson1,
    /// The `person2` field.
    pub person2: CalculateBioCompatibilityResponsePerson2,
    /// Compatibility rating label. One of: Highly Aligned, Well Aligned, Moderately Aligned, Misaligned, Opposed.
    pub rating: String,
    /// Relationship strengths based on the compatibility profile.
    pub strengths: Vec<String>,
    /// Date this compatibility was calculated for.
    #[serde(rename = "targetDate")]
    pub target_date: String,
}
/// The `person2` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBioCompatibilityResponsePerson2 {
    /// Birth date of person 2.
    #[serde(rename = "birthDate")]
    pub birth_date: String,
}
/// The `person1` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBioCompatibilityResponsePerson1 {
    /// Birth date of person 1.
    #[serde(rename = "birthDate")]
    pub birth_date: String,
}
/// The `dailySync` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBioCompatibilityResponseDailySync {
    /// Absolute difference in emotional cycle values (0-200). Lower = more aligned.
    #[serde(rename = "emotionalDiff")]
    pub emotional_diff: f64,
    /// Absolute difference in intellectual cycle values (0-200). Lower = more aligned.
    #[serde(rename = "intellectualDiff")]
    pub intellectual_diff: f64,
    /// Absolute difference in physical cycle values (0-200). Lower = more aligned.
    #[serde(rename = "physicalDiff")]
    pub physical_diff: f64,
}
/// Per-cycle compatibility analysis for physical, emotional, and intellectual cycles.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBioCompatibilityResponseCycles {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<
        String,
        CalculateBioCompatibilityResponseCyclesAdditionalProperty,
    >,
}
/// How the two people sit against each other on one cycle: each value, the gap between them, an alignment score, the pair phase, and a sentence on what it means for the relationship.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBioCompatibilityResponseCyclesAdditionalProperty {
    /// Alignment score from 0 (perfectly opposed) to 100 (perfectly in sync).
    pub alignment: f64,
    /// Human-readable description of how this cycle alignment affects the relationship.
    pub description: String,
    /// Absolute difference between the two values (0-200). Lower values indicate better alignment.
    pub difference: f64,
    /// Person 1 cycle value on the target date (-100 to 100).
    #[serde(rename = "person1Value")]
    pub person1_value: f64,
    /// Person 2 cycle value on the target date (-100 to 100).
    #[serde(rename = "person2Value")]
    pub person2_value: f64,
    /// How the cycles of the two people sit against each other. One of: in_sync, complementary, neutral, opposing. This is a PAIR alignment and shares no values with the single-person cycle phase.
    pub phase: CalculateBioCompatibilityResponseCyclesAdditionalPropertyPhase,
}
string_enum! {
    /// How the cycles of the two people sit against each other. One of: in_sync, complementary, neutral, opposing. This is a PAIR alignment and shares no values with the single-person cycle phase.
    CalculateBioCompatibilityResponseCyclesAdditionalPropertyPhase {
        InSync = "in_sync",
        Complementary = "complementary",
        Neutral = "neutral",
        Opposing = "opposing",
    }
}
/// Request body of `calculateBioCompatibility`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBioCompatibilityRequest {
    /// The `person1` field.
    pub person1: CalculateBioCompatibilityRequestPerson1,
    /// The `person2` field.
    pub person2: CalculateBioCompatibilityRequestPerson2,
    /// Date to evaluate compatibility on in YYYY-MM-DD format. Defaults to today (UTC). Compatibility varies by day since biorhythm cycles are continuous.
    #[serde(rename = "targetDate", skip_serializing_if = "Option::is_none")]
    pub target_date: Option<String>,
}
/// The `person2` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBioCompatibilityRequestPerson2 {
    /// Birth date of person 2 in YYYY-MM-DD format.
    #[serde(rename = "birthDate")]
    pub birth_date: String,
}
/// The `person1` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBioCompatibilityRequestPerson1 {
    /// Birth date of person 1 in YYYY-MM-DD format.
    #[serde(rename = "birthDate")]
    pub birth_date: String,
}
/// Path and query parameters of `calculateBioCompatibility`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateBioCompatibilityParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateBioCompatibilityParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateBioCompatibilityParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `calculateBhavaBala`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateBhavaBalaParams {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<CalculateBhavaBalaParamsFocus>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateBhavaBalaParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateBhavaBalaParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    CalculateBhavaBalaParamsFocus {
        General = "general",
        Finance = "finance",
    }
}
/// Path and query parameters of `calculateBhavChalit`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateBhavChalitParams {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub focus: Option<CalculateBhavChalitParamsFocus>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateBhavChalitParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateBhavChalitParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Which signification vocabulary the houseThemes map returns. "general" gives the classical bhava significations (self, wealth, siblings, home, and so on). "finance" gives the money reading of the same twelve bhavas, so house 2 returns income and savings, 5 speculation and risk appetite, 8 sudden money and leverage, 11 gains and profits, and 12 expenses and capital outflow. Use "finance" for wealth, income, business and market timing questions in Krishnamurti Paddhati, where the significator house groups 2, 6, 10, 11 for earned income and 5, 8, 11 for speculation are read against a running dasha. Defaults to "general".
    CalculateBhavChalitParamsFocus {
        General = "general",
        Finance = "finance",
    }
}
/// Response body of `calculateBaziCompatibility`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponse {
    /// How many of the interactions break between them.
    #[serde(rename = "challengingCount")]
    pub challenging_count: f64,
    /// How the two Day Masters stand to each other by the five-phase cycle, read from person A. peer means the same element, output means A generates B, wealth means A controls B, influence means B controls A, resource means B generates A. Always English, whatever the lang parameter says.
    #[serde(rename = "dayMasterRelation")]
    pub day_master_relation: String,
    /// How many of the interactions bind the two charts together.
    #[serde(rename = "harmoniousCount")]
    pub harmonious_count: f64,
    /// Every combination, clash, harm and punishment that crosses between the two charts, with each position prefixed by its subject. Only cross-chart pairs are searched: a three-branch formation assembled from two different people is not a formation either chart holds, so trines are not reported here.
    pub interactions: Vec<CalculateBaziCompatibilityResponseInteractionsItem>,
    /// Resolved chart of the first person.
    #[serde(rename = "personA")]
    pub person_a: CalculateBaziCompatibilityResponsePersonA,
    /// Resolved chart of the second person.
    #[serde(rename = "personB")]
    pub person_b: CalculateBaziCompatibilityResponsePersonB,
    /// Compatibility score from 0 to 100. A RoxyAPI tally over the interactions listed above rather than a figure from any classical text: it starts at a neutral 50, adds for each binding interaction and subtracts for each breaking one. Recompute it yourself from the interactions array if you want a different weighting.
    pub score: f64,
    /// One-paragraph reading of the balance between binding and breaking interactions.
    pub summary: String,
}
/// Resolved chart of the second person.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponsePersonB {
    /// The three school conventions this result was computed under. Returned on every BaZi response so a chart is self-describing: two calculators can produce different pillars for one birth and both be correct, and this object says which reading you are holding.
    pub conventions: CalculateBaziCompatibilityResponsePersonBConventions,
    /// The day stem of this person.
    #[serde(rename = "dayMaster")]
    pub day_master: CalculateBaziCompatibilityResponsePersonBDayMaster,
    /// The four pillars of this person, year first.
    pub pillars: Vec<CalculateBaziCompatibilityResponsePersonBPillarsItem>,
    /// Day Master strength verdict for this person, so a reader can see which of the two chart carries more capacity. One of very-weak, weak, balanced, strong, very-strong.
    pub strength: String,
}
/// One entry of `pillars`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponsePersonBPillarsItem {
    /// The Earthly Branch of this pillar.
    pub branch: CalculateBaziCompatibilityResponsePersonBPillarsItemBranch,
    /// Stems stored inside the branch, principal first. These carry the qi a branch holds without showing it, and they are where a Day Master finds a root.
    #[serde(rename = "hiddenStems")]
    pub hidden_stems: Vec<
        CalculateBaziCompatibilityResponsePersonBPillarsItemHiddenStemsItem,
    >,
    /// Pillar identifier, the stem id and the branch id joined by a hyphen. Always English pinyin, whatever the lang parameter says.
    pub id: String,
    /// Na Yin sound element of the pillar, an older elemental reading assigned to each of the 30 stem-and-branch pairs. The hanzi name sits beside it in naYinChinese.
    #[serde(rename = "naYin")]
    pub na_yin: String,
    /// The Na Yin name in hanzi. Identical under every lang.
    #[serde(rename = "naYinChinese")]
    pub na_yin_chinese: String,
    /// Element the Na Yin resolves to. Independent of the stem element and often different from it, which is why it is reported separately rather than folded in. Always English, whatever the lang parameter says. Use naYinElementLocalized for anything a reader sees.
    #[serde(rename = "naYinElement")]
    pub na_yin_element: String,
    /// Na Yin element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "naYinElementLocalized", skip_serializing_if = "Option::is_none")]
    pub na_yin_element_localized: Option<String>,
    /// Position of this pillar in the sexagenary cycle, 1 to 60, where jia-zi is 1. The cycle runs stems and branches together, which is why only 60 of the 120 possible pairings occur.
    pub number: f64,
    /// Which of the four pillars this is. One of year, month, day, hour. The year pillar reads ancestry and early life, the month career and parents, the day the self and the partner, the hour later life and children.
    pub position: String,
    /// The Heavenly Stem of this pillar.
    pub stem: CalculateBaziCompatibilityResponsePersonBPillarsItemStem,
    /// Relation the pillar STEM holds to the Day Master. The day pillar carries day-master instead, because the day stem is the reference point every other position is measured from rather than a relation to itself.
    #[serde(rename = "tenGod")]
    pub ten_god: CalculateBaziCompatibilityResponsePersonBPillarsItemTenGod,
}
/// Relation the pillar STEM holds to the Day Master. The day pillar carries day-master instead, because the day stem is the reference point every other position is measured from rather than a relation to itself.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponsePersonBPillarsItemTenGod {
    /// Which of the five cycle relations this belongs to. peer is the same element as the Day Master, output is what the Day Master generates, wealth is what it controls, influence is what controls it, resource is what generates it, and self marks the Day Master itself. Always English, whatever the lang parameter says.
    pub category: String,
    /// The relation in traditional hanzi. Identical under every lang.
    pub chinese: String,
    /// Ten God identifier. One of friend, rob-wealth, eating-god, hurting-officer, indirect-wealth, direct-wealth, seven-killings, direct-officer, indirect-resource, direct-resource, plus day-master in the day-stem position. Always English, whatever the lang parameter says.
    pub id: String,
    /// One-line summary of what this relation contributes, for a compact rendering that has no room for the full meaning.
    pub keynote: String,
    /// Display name of the relation. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Ten God name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone-marked pinyin for the relation. Identical under every lang.
    pub pinyin: String,
}
/// The Heavenly Stem of this pillar.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponsePersonBPillarsItemStem {
    /// The stem in hanzi. Data rather than display copy, so it is identical under every lang.
    pub chinese: String,
    /// Five-phase element of the stem. One of Wood, Fire, Earth, Metal, Water. Always English, whatever the lang parameter says. Use elementLocalized for anything a reader sees.
    pub element: String,
    /// Element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Heavenly Stem identifier. One of jia, yi, bing, ding, wu, ji, geng, xin, ren, gui. Always English pinyin, whatever the lang parameter says, so it stays safe to compare against in code and to key a glyph table on.
    pub id: String,
    /// Tone-marked pinyin for the stem. Identical under every lang.
    pub pinyin: String,
    /// Polarity of the stem, yang or yin. The five odd stems are yang and the five even ones are yin, and this is half of what decides every Ten God relation in the chart.
    pub polarity: String,
}
/// One entry of `hiddenStems`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponsePersonBPillarsItemHiddenStemsItem {
    /// Rank of this stem inside the branch, by the classical day-count that divides a thirty-day month 18, 9 and 3 days between the stems a branch holds. principal is the first-ranked stem and always matches the branch element; middle is the second-ranked; residual is the third. A branch holds one to three, always returned in rank order. What each rank CONTAINS depends on the branch family: on a storage branch the second-ranked stem is the seasonal carryover from the month before and the third is the stem that branch stores as the close of its trine, while on a growth branch the second-ranked stem is the one beginning its long-life phase there and the third is the carryover. Some schools name the same three positions by that function rather than by rank, which swaps the second and third labels on the four storage branches, so compare on rank rather than assuming a name.
    pub role: String,
    /// The stem stored in the branch.
    pub stem: CalculateBaziCompatibilityResponsePersonBPillarsItemHiddenStemsItemStem,
    /// Relation this hidden stem holds to the Day Master.
    #[serde(rename = "tenGod")]
    pub ten_god: CalculateBaziCompatibilityResponsePersonBPillarsItemHiddenStemsItemTenGod,
}
/// Relation this hidden stem holds to the Day Master.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponsePersonBPillarsItemHiddenStemsItemTenGod {
    /// Which of the five cycle relations this belongs to. peer is the same element as the Day Master, output is what the Day Master generates, wealth is what it controls, influence is what controls it, resource is what generates it, and self marks the Day Master itself. Always English, whatever the lang parameter says.
    pub category: String,
    /// The relation in traditional hanzi. Identical under every lang.
    pub chinese: String,
    /// Ten God identifier. One of friend, rob-wealth, eating-god, hurting-officer, indirect-wealth, direct-wealth, seven-killings, direct-officer, indirect-resource, direct-resource, plus day-master in the day-stem position. Always English, whatever the lang parameter says.
    pub id: String,
    /// One-line summary of what this relation contributes, for a compact rendering that has no room for the full meaning.
    pub keynote: String,
    /// Display name of the relation. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Ten God name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone-marked pinyin for the relation. Identical under every lang.
    pub pinyin: String,
}
/// The stem stored in the branch.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponsePersonBPillarsItemHiddenStemsItemStem {
    /// The stem in hanzi. Data rather than display copy, so it is identical under every lang.
    pub chinese: String,
    /// Five-phase element of the stem. One of Wood, Fire, Earth, Metal, Water. Always English, whatever the lang parameter says. Use elementLocalized for anything a reader sees.
    pub element: String,
    /// Element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Heavenly Stem identifier. One of jia, yi, bing, ding, wu, ji, geng, xin, ren, gui. Always English pinyin, whatever the lang parameter says, so it stays safe to compare against in code and to key a glyph table on.
    pub id: String,
    /// Tone-marked pinyin for the stem. Identical under every lang.
    pub pinyin: String,
    /// Polarity of the stem, yang or yin. The five odd stems are yang and the five even ones are yin, and this is half of what decides every Ten God relation in the chart.
    pub polarity: String,
}
/// The Earthly Branch of this pillar.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponsePersonBPillarsItemBranch {
    /// Zodiac animal of the branch. One of rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, pig. Always English, whatever the lang parameter says. Use animalLocalized for anything a reader sees.
    pub animal: String,
    /// Zodiac animal name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "animalLocalized", skip_serializing_if = "Option::is_none")]
    pub animal_localized: Option<String>,
    /// The branch in hanzi. Identical under every lang.
    pub chinese: String,
    /// Five-phase element of the branch. Always English, whatever the lang parameter says. Use elementLocalized for anything a reader sees.
    pub element: String,
    /// Element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Earthly Branch identifier. One of zi, chou, yin, mao, chen, si, wu, wei, shen, you, xu, hai. Always English pinyin, whatever the lang parameter says. Note that "wu" is also a stem identifier: they never share a field, so a branch id is only ever read out of a branch position.
    pub id: String,
    /// Tone-marked pinyin for the branch. Identical under every lang.
    pub pinyin: String,
    /// Polarity of the branch, yang or yin.
    pub polarity: String,
}
/// The day stem of this person.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponsePersonBDayMaster {
    /// The Day Master stem in hanzi.
    pub chinese: String,
    /// Five-phase element of this Day Master. Always English, whatever the lang parameter says.
    pub element: String,
    /// Display copy of the element in the requested language. Absent for English, so an English response is unchanged.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// What this stem is like as a Day Master.
    pub nature: String,
    /// Tone-marked pinyin for the Day Master stem.
    pub pinyin: String,
    /// Polarity, yang or yin.
    pub polarity: String,
    /// Day stem identifier for this person.
    pub stem: String,
}
/// The three school conventions this result was computed under. Returned on every BaZi response so a chart is self-describing: two calculators can produce different pillars for one birth and both be correct, and this object says which reading you are holding.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponsePersonBConventions {
    /// Day-boundary school actually applied. Echoes the request, or the default when it was omitted. Always English, whatever the lang parameter says, so it stays safe to compare against in code.
    #[serde(rename = "dayBoundary")]
    pub day_boundary: CalculateBaziCompatibilityResponsePersonBConventionsDayBoundary,
    /// Hour clock actually applied. Echoes the request, or the default when omitted.
    #[serde(rename = "hourClock")]
    pub hour_clock: CalculateBaziCompatibilityResponsePersonBConventionsHourClock,
    /// Year-boundary school actually applied. Echoes the request, or the default when it was omitted.
    #[serde(rename = "yearBoundary")]
    pub year_boundary: CalculateBaziCompatibilityResponsePersonBConventionsYearBoundary,
}
string_enum! {
    /// Year-boundary school actually applied. Echoes the request, or the default when it was omitted.
    CalculateBaziCompatibilityResponsePersonBConventionsYearBoundary {
        LiChun = "li-chun",
        LunarNewYear = "lunar-new-year",
    }
}
string_enum! {
    /// Hour clock actually applied. Echoes the request, or the default when omitted.
    CalculateBaziCompatibilityResponsePersonBConventionsHourClock {
        Clock = "clock",
        LocalMean = "local-mean",
        Solar = "solar",
    }
}
string_enum! {
    /// Day-boundary school actually applied. Echoes the request, or the default when it was omitted. Always English, whatever the lang parameter says, so it stays safe to compare against in code.
    CalculateBaziCompatibilityResponsePersonBConventionsDayBoundary {
        SplitZi = "split-zi",
        Midnight = "midnight",
        EarlyZi = "early-zi",
    }
}
/// Resolved chart of the first person.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponsePersonA {
    /// The three school conventions this result was computed under. Returned on every BaZi response so a chart is self-describing: two calculators can produce different pillars for one birth and both be correct, and this object says which reading you are holding.
    pub conventions: CalculateBaziCompatibilityResponsePersonAConventions,
    /// The day stem of this person.
    #[serde(rename = "dayMaster")]
    pub day_master: CalculateBaziCompatibilityResponsePersonADayMaster,
    /// The four pillars of this person, year first.
    pub pillars: Vec<CalculateBaziCompatibilityResponsePersonAPillarsItem>,
    /// Day Master strength verdict for this person, so a reader can see which of the two chart carries more capacity. One of very-weak, weak, balanced, strong, very-strong.
    pub strength: String,
}
/// One entry of `pillars`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponsePersonAPillarsItem {
    /// The Earthly Branch of this pillar.
    pub branch: CalculateBaziCompatibilityResponsePersonAPillarsItemBranch,
    /// Stems stored inside the branch, principal first. These carry the qi a branch holds without showing it, and they are where a Day Master finds a root.
    #[serde(rename = "hiddenStems")]
    pub hidden_stems: Vec<
        CalculateBaziCompatibilityResponsePersonAPillarsItemHiddenStemsItem,
    >,
    /// Pillar identifier, the stem id and the branch id joined by a hyphen. Always English pinyin, whatever the lang parameter says.
    pub id: String,
    /// Na Yin sound element of the pillar, an older elemental reading assigned to each of the 30 stem-and-branch pairs. The hanzi name sits beside it in naYinChinese.
    #[serde(rename = "naYin")]
    pub na_yin: String,
    /// The Na Yin name in hanzi. Identical under every lang.
    #[serde(rename = "naYinChinese")]
    pub na_yin_chinese: String,
    /// Element the Na Yin resolves to. Independent of the stem element and often different from it, which is why it is reported separately rather than folded in. Always English, whatever the lang parameter says. Use naYinElementLocalized for anything a reader sees.
    #[serde(rename = "naYinElement")]
    pub na_yin_element: String,
    /// Na Yin element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "naYinElementLocalized", skip_serializing_if = "Option::is_none")]
    pub na_yin_element_localized: Option<String>,
    /// Position of this pillar in the sexagenary cycle, 1 to 60, where jia-zi is 1. The cycle runs stems and branches together, which is why only 60 of the 120 possible pairings occur.
    pub number: f64,
    /// Which of the four pillars this is. One of year, month, day, hour. The year pillar reads ancestry and early life, the month career and parents, the day the self and the partner, the hour later life and children.
    pub position: String,
    /// The Heavenly Stem of this pillar.
    pub stem: CalculateBaziCompatibilityResponsePersonAPillarsItemStem,
    /// Relation the pillar STEM holds to the Day Master. The day pillar carries day-master instead, because the day stem is the reference point every other position is measured from rather than a relation to itself.
    #[serde(rename = "tenGod")]
    pub ten_god: CalculateBaziCompatibilityResponsePersonAPillarsItemTenGod,
}
/// Relation the pillar STEM holds to the Day Master. The day pillar carries day-master instead, because the day stem is the reference point every other position is measured from rather than a relation to itself.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponsePersonAPillarsItemTenGod {
    /// Which of the five cycle relations this belongs to. peer is the same element as the Day Master, output is what the Day Master generates, wealth is what it controls, influence is what controls it, resource is what generates it, and self marks the Day Master itself. Always English, whatever the lang parameter says.
    pub category: String,
    /// The relation in traditional hanzi. Identical under every lang.
    pub chinese: String,
    /// Ten God identifier. One of friend, rob-wealth, eating-god, hurting-officer, indirect-wealth, direct-wealth, seven-killings, direct-officer, indirect-resource, direct-resource, plus day-master in the day-stem position. Always English, whatever the lang parameter says.
    pub id: String,
    /// One-line summary of what this relation contributes, for a compact rendering that has no room for the full meaning.
    pub keynote: String,
    /// Display name of the relation. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Ten God name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone-marked pinyin for the relation. Identical under every lang.
    pub pinyin: String,
}
/// The Heavenly Stem of this pillar.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponsePersonAPillarsItemStem {
    /// The stem in hanzi. Data rather than display copy, so it is identical under every lang.
    pub chinese: String,
    /// Five-phase element of the stem. One of Wood, Fire, Earth, Metal, Water. Always English, whatever the lang parameter says. Use elementLocalized for anything a reader sees.
    pub element: String,
    /// Element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Heavenly Stem identifier. One of jia, yi, bing, ding, wu, ji, geng, xin, ren, gui. Always English pinyin, whatever the lang parameter says, so it stays safe to compare against in code and to key a glyph table on.
    pub id: String,
    /// Tone-marked pinyin for the stem. Identical under every lang.
    pub pinyin: String,
    /// Polarity of the stem, yang or yin. The five odd stems are yang and the five even ones are yin, and this is half of what decides every Ten God relation in the chart.
    pub polarity: String,
}
/// One entry of `hiddenStems`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponsePersonAPillarsItemHiddenStemsItem {
    /// Rank of this stem inside the branch, by the classical day-count that divides a thirty-day month 18, 9 and 3 days between the stems a branch holds. principal is the first-ranked stem and always matches the branch element; middle is the second-ranked; residual is the third. A branch holds one to three, always returned in rank order. What each rank CONTAINS depends on the branch family: on a storage branch the second-ranked stem is the seasonal carryover from the month before and the third is the stem that branch stores as the close of its trine, while on a growth branch the second-ranked stem is the one beginning its long-life phase there and the third is the carryover. Some schools name the same three positions by that function rather than by rank, which swaps the second and third labels on the four storage branches, so compare on rank rather than assuming a name.
    pub role: String,
    /// The stem stored in the branch.
    pub stem: CalculateBaziCompatibilityResponsePersonAPillarsItemHiddenStemsItemStem,
    /// Relation this hidden stem holds to the Day Master.
    #[serde(rename = "tenGod")]
    pub ten_god: CalculateBaziCompatibilityResponsePersonAPillarsItemHiddenStemsItemTenGod,
}
/// Relation this hidden stem holds to the Day Master.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponsePersonAPillarsItemHiddenStemsItemTenGod {
    /// Which of the five cycle relations this belongs to. peer is the same element as the Day Master, output is what the Day Master generates, wealth is what it controls, influence is what controls it, resource is what generates it, and self marks the Day Master itself. Always English, whatever the lang parameter says.
    pub category: String,
    /// The relation in traditional hanzi. Identical under every lang.
    pub chinese: String,
    /// Ten God identifier. One of friend, rob-wealth, eating-god, hurting-officer, indirect-wealth, direct-wealth, seven-killings, direct-officer, indirect-resource, direct-resource, plus day-master in the day-stem position. Always English, whatever the lang parameter says.
    pub id: String,
    /// One-line summary of what this relation contributes, for a compact rendering that has no room for the full meaning.
    pub keynote: String,
    /// Display name of the relation. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Ten God name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone-marked pinyin for the relation. Identical under every lang.
    pub pinyin: String,
}
/// The stem stored in the branch.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponsePersonAPillarsItemHiddenStemsItemStem {
    /// The stem in hanzi. Data rather than display copy, so it is identical under every lang.
    pub chinese: String,
    /// Five-phase element of the stem. One of Wood, Fire, Earth, Metal, Water. Always English, whatever the lang parameter says. Use elementLocalized for anything a reader sees.
    pub element: String,
    /// Element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Heavenly Stem identifier. One of jia, yi, bing, ding, wu, ji, geng, xin, ren, gui. Always English pinyin, whatever the lang parameter says, so it stays safe to compare against in code and to key a glyph table on.
    pub id: String,
    /// Tone-marked pinyin for the stem. Identical under every lang.
    pub pinyin: String,
    /// Polarity of the stem, yang or yin. The five odd stems are yang and the five even ones are yin, and this is half of what decides every Ten God relation in the chart.
    pub polarity: String,
}
/// The Earthly Branch of this pillar.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponsePersonAPillarsItemBranch {
    /// Zodiac animal of the branch. One of rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, pig. Always English, whatever the lang parameter says. Use animalLocalized for anything a reader sees.
    pub animal: String,
    /// Zodiac animal name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "animalLocalized", skip_serializing_if = "Option::is_none")]
    pub animal_localized: Option<String>,
    /// The branch in hanzi. Identical under every lang.
    pub chinese: String,
    /// Five-phase element of the branch. Always English, whatever the lang parameter says. Use elementLocalized for anything a reader sees.
    pub element: String,
    /// Element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Earthly Branch identifier. One of zi, chou, yin, mao, chen, si, wu, wei, shen, you, xu, hai. Always English pinyin, whatever the lang parameter says. Note that "wu" is also a stem identifier: they never share a field, so a branch id is only ever read out of a branch position.
    pub id: String,
    /// Tone-marked pinyin for the branch. Identical under every lang.
    pub pinyin: String,
    /// Polarity of the branch, yang or yin.
    pub polarity: String,
}
/// The day stem of this person.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponsePersonADayMaster {
    /// The Day Master stem in hanzi.
    pub chinese: String,
    /// Five-phase element of this Day Master. Always English, whatever the lang parameter says.
    pub element: String,
    /// Display copy of the element in the requested language. Absent for English, so an English response is unchanged.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// What this stem is like as a Day Master.
    pub nature: String,
    /// Tone-marked pinyin for the Day Master stem.
    pub pinyin: String,
    /// Polarity, yang or yin.
    pub polarity: String,
    /// Day stem identifier for this person.
    pub stem: String,
}
/// The three school conventions this result was computed under. Returned on every BaZi response so a chart is self-describing: two calculators can produce different pillars for one birth and both be correct, and this object says which reading you are holding.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponsePersonAConventions {
    /// Day-boundary school actually applied. Echoes the request, or the default when it was omitted. Always English, whatever the lang parameter says, so it stays safe to compare against in code.
    #[serde(rename = "dayBoundary")]
    pub day_boundary: CalculateBaziCompatibilityResponsePersonAConventionsDayBoundary,
    /// Hour clock actually applied. Echoes the request, or the default when omitted.
    #[serde(rename = "hourClock")]
    pub hour_clock: CalculateBaziCompatibilityResponsePersonAConventionsHourClock,
    /// Year-boundary school actually applied. Echoes the request, or the default when it was omitted.
    #[serde(rename = "yearBoundary")]
    pub year_boundary: CalculateBaziCompatibilityResponsePersonAConventionsYearBoundary,
}
string_enum! {
    /// Year-boundary school actually applied. Echoes the request, or the default when it was omitted.
    CalculateBaziCompatibilityResponsePersonAConventionsYearBoundary {
        LiChun = "li-chun",
        LunarNewYear = "lunar-new-year",
    }
}
string_enum! {
    /// Hour clock actually applied. Echoes the request, or the default when omitted.
    CalculateBaziCompatibilityResponsePersonAConventionsHourClock {
        Clock = "clock",
        LocalMean = "local-mean",
        Solar = "solar",
    }
}
string_enum! {
    /// Day-boundary school actually applied. Echoes the request, or the default when it was omitted. Always English, whatever the lang parameter says, so it stays safe to compare against in code.
    CalculateBaziCompatibilityResponsePersonAConventionsDayBoundary {
        SplitZi = "split-zi",
        Midnight = "midnight",
        EarlyZi = "early-zi",
    }
}
/// One entry of `interactions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityResponseInteractionsItem {
    /// The interaction named in hanzi. Identical under every lang.
    pub chinese: String,
    /// Punishments only. True when the third branch of the group is also present in the chart, which is what a complete three-punishment means. False marks the partial case, where only two of the three are in play.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub complete: Option<bool>,
    /// Identifier of the pairing itself, the member ids joined by hyphens in canonical order.
    pub id: String,
    /// What this kind of interaction does between the positions it joins.
    pub meaning: String,
    /// The stem or branch ids taking part, in the same order as positions.
    pub members: Vec<String>,
    /// Tone-marked pinyin for the interaction. Identical under every lang.
    pub pinyin: String,
    /// The chart positions taking part, in the same order as members. On a two-person reading these are prefixed with the subject, for example personA.day.
    pub positions: Vec<String>,
    /// Whether the interaction binds or breaks. harmonious for combinations and trines, challenging for clashes, harms and punishments. Always English, whatever the lang parameter says.
    pub quality: String,
    /// Element the formation resolves to. Present on stem combinations and on complete trines, absent on everything else. Branch six combinations deliberately carry none: the classical sources assign transformed elements to the stem pairs and not to these, and one of the six is contested between schools.
    #[serde(rename = "transformsTo", skip_serializing_if = "Option::is_none")]
    pub transforms_to: Option<String>,
    /// Kind of interaction. stem-combination and six-combination bind two positions, trine binds three, and clash, harm, punishment and stem-clash break them. Always English, whatever the lang parameter says.
    pub r#type: String,
    /// Class of a punishment, present on punishments only. ungrateful is the tiger, snake and monkey group, bullying the ox, dog and goat group, discourteous the rat and rabbit pair, and self a branch doubled against itself.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub variety: Option<String>,
}
/// Request body of `calculateBaziCompatibility`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityRequest {
    /// Birth moment of the first person. Each subject carries its own school switches, so two charts built under different conventions can still be compared.
    #[serde(rename = "personA")]
    pub person_a: CalculateBaziCompatibilityRequestPersonA,
    /// Birth moment of the second person.
    #[serde(rename = "personB")]
    pub person_b: CalculateBaziCompatibilityRequestPersonB,
}
/// Birth moment of the second person.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityRequestPersonB {
    /// Birth date in YYYY-MM-DD format. Sets the year, month and day pillars. The year pillar turns at Beginning of Spring rather than on 1 January, and the month pillar turns at each of the twelve minor solar terms rather than at a calendar month boundary.
    pub date: String,
    /// Which instant starts the sexagenary DAY, which only matters for a birth between 23:00 and 23:59. "midnight" is the classical position of the Ming compendium San Ming Tong Hui: the day turns at 00:00 and 23:00 to 23:59 is the late zi hour of the day that is ending, so the hour stem is taken from that day. "early-zi" turns the whole day at 23:00, the practice in Hong Kong, Taiwan and much of South East Asia. "split-zi" is the compromise most software implements and the default here: the day still turns at 00:00, but the hour stem is taken from the next day. The three give three different answers for a late-evening birth and identical answers for every other birth.
    #[serde(rename = "dayBoundary", skip_serializing_if = "Option::is_none")]
    pub day_boundary: Option<CalculateBaziCompatibilityRequestPersonBDayBoundary>,
    /// Which clock the day boundary and the hour branch are read from, so a correction that carries a birth across midnight moves the day pillar with the hour. "clock" is civil time exactly as a birth certificate records it, which is what most calculators use and the default here. "local-mean" shifts to the mean sun over the birth longitude, a correction of up to 59 minutes at the edge of a wide time zone. "solar" adds the equation of time on top of that, up to a further 16 minutes. Both non-civil options need "longitude" in the request and return 400 without it.
    #[serde(rename = "hourClock", skip_serializing_if = "Option::is_none")]
    pub hour_clock: Option<CalculateBaziCompatibilityRequestPersonBHourClock>,
    /// Birth latitude in decimal degrees. Accepted for consistency with the other birth-data endpoints and does not affect any part of a BaZi chart. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Positive is East, negative is West. Required when hourClock is "local-mean" or "solar", which shift the hour branch to the sun over the birth place; omitting it in either case returns 400. Ignored when hourClock is "clock".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Birth time in 24-hour HH:MM:SS format. Sets the hour pillar, which is one of the four and carries the whole picture of later life and offspring. Each Earthly Branch covers two hours, so a birth within a few minutes of an odd hour can land in either. All four pillars are read in the local clock of the birth, and the day boundary is applied in that same clock; only the lunisolar calendar date itself is a world constant, fixed at UTC plus 8 so one instant has one Chinese date everywhere.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: CalculateBaziCompatibilityRequestPersonBTimezone,
    /// Which instant starts the sexagenary YEAR. "li-chun" is Beginning of Spring, around 4 February, and is the classical rule every BaZi text uses, so it is the default on this endpoint. "lunar-new-year" is the folk rule people mean when they say which animal they are, and it falls between late January and late February. The two disagree for any birth in the weeks between them: 14 February 2026 is a Wood Snake year under lunar-new-year and a Fire Horse year under li-chun.
    #[serde(rename = "yearBoundary", skip_serializing_if = "Option::is_none")]
    pub year_boundary: Option<CalculateBaziCompatibilityRequestPersonBYearBoundary>,
}
string_enum! {
    /// Which instant starts the sexagenary YEAR. "li-chun" is Beginning of Spring, around 4 February, and is the classical rule every BaZi text uses, so it is the default on this endpoint. "lunar-new-year" is the folk rule people mean when they say which animal they are, and it falls between late January and late February. The two disagree for any birth in the weeks between them: 14 February 2026 is a Wood Snake year under lunar-new-year and a Fire Horse year under li-chun.
    CalculateBaziCompatibilityRequestPersonBYearBoundary {
        LiChun = "li-chun",
        LunarNewYear = "lunar-new-year",
    }
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateBaziCompatibilityRequestPersonBTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Which clock the day boundary and the hour branch are read from, so a correction that carries a birth across midnight moves the day pillar with the hour. "clock" is civil time exactly as a birth certificate records it, which is what most calculators use and the default here. "local-mean" shifts to the mean sun over the birth longitude, a correction of up to 59 minutes at the edge of a wide time zone. "solar" adds the equation of time on top of that, up to a further 16 minutes. Both non-civil options need "longitude" in the request and return 400 without it.
    CalculateBaziCompatibilityRequestPersonBHourClock {
        Clock = "clock",
        LocalMean = "local-mean",
        Solar = "solar",
    }
}
string_enum! {
    /// Which instant starts the sexagenary DAY, which only matters for a birth between 23:00 and 23:59. "midnight" is the classical position of the Ming compendium San Ming Tong Hui: the day turns at 00:00 and 23:00 to 23:59 is the late zi hour of the day that is ending, so the hour stem is taken from that day. "early-zi" turns the whole day at 23:00, the practice in Hong Kong, Taiwan and much of South East Asia. "split-zi" is the compromise most software implements and the default here: the day still turns at 00:00, but the hour stem is taken from the next day. The three give three different answers for a late-evening birth and identical answers for every other birth.
    CalculateBaziCompatibilityRequestPersonBDayBoundary {
        SplitZi = "split-zi",
        Midnight = "midnight",
        EarlyZi = "early-zi",
    }
}
/// Birth moment of the first person. Each subject carries its own school switches, so two charts built under different conventions can still be compared.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityRequestPersonA {
    /// Birth date in YYYY-MM-DD format. Sets the year, month and day pillars. The year pillar turns at Beginning of Spring rather than on 1 January, and the month pillar turns at each of the twelve minor solar terms rather than at a calendar month boundary.
    pub date: String,
    /// Which instant starts the sexagenary DAY, which only matters for a birth between 23:00 and 23:59. "midnight" is the classical position of the Ming compendium San Ming Tong Hui: the day turns at 00:00 and 23:00 to 23:59 is the late zi hour of the day that is ending, so the hour stem is taken from that day. "early-zi" turns the whole day at 23:00, the practice in Hong Kong, Taiwan and much of South East Asia. "split-zi" is the compromise most software implements and the default here: the day still turns at 00:00, but the hour stem is taken from the next day. The three give three different answers for a late-evening birth and identical answers for every other birth.
    #[serde(rename = "dayBoundary", skip_serializing_if = "Option::is_none")]
    pub day_boundary: Option<CalculateBaziCompatibilityRequestPersonADayBoundary>,
    /// Which clock the day boundary and the hour branch are read from, so a correction that carries a birth across midnight moves the day pillar with the hour. "clock" is civil time exactly as a birth certificate records it, which is what most calculators use and the default here. "local-mean" shifts to the mean sun over the birth longitude, a correction of up to 59 minutes at the edge of a wide time zone. "solar" adds the equation of time on top of that, up to a further 16 minutes. Both non-civil options need "longitude" in the request and return 400 without it.
    #[serde(rename = "hourClock", skip_serializing_if = "Option::is_none")]
    pub hour_clock: Option<CalculateBaziCompatibilityRequestPersonAHourClock>,
    /// Birth latitude in decimal degrees. Accepted for consistency with the other birth-data endpoints and does not affect any part of a BaZi chart. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Positive is East, negative is West. Required when hourClock is "local-mean" or "solar", which shift the hour branch to the sun over the birth place; omitting it in either case returns 400. Ignored when hourClock is "clock".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Birth time in 24-hour HH:MM:SS format. Sets the hour pillar, which is one of the four and carries the whole picture of later life and offspring. Each Earthly Branch covers two hours, so a birth within a few minutes of an odd hour can land in either. All four pillars are read in the local clock of the birth, and the day boundary is applied in that same clock; only the lunisolar calendar date itself is a world constant, fixed at UTC plus 8 so one instant has one Chinese date everywhere.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: CalculateBaziCompatibilityRequestPersonATimezone,
    /// Which instant starts the sexagenary YEAR. "li-chun" is Beginning of Spring, around 4 February, and is the classical rule every BaZi text uses, so it is the default on this endpoint. "lunar-new-year" is the folk rule people mean when they say which animal they are, and it falls between late January and late February. The two disagree for any birth in the weeks between them: 14 February 2026 is a Wood Snake year under lunar-new-year and a Fire Horse year under li-chun.
    #[serde(rename = "yearBoundary", skip_serializing_if = "Option::is_none")]
    pub year_boundary: Option<CalculateBaziCompatibilityRequestPersonAYearBoundary>,
}
string_enum! {
    /// Which instant starts the sexagenary YEAR. "li-chun" is Beginning of Spring, around 4 February, and is the classical rule every BaZi text uses, so it is the default on this endpoint. "lunar-new-year" is the folk rule people mean when they say which animal they are, and it falls between late January and late February. The two disagree for any birth in the weeks between them: 14 February 2026 is a Wood Snake year under lunar-new-year and a Fire Horse year under li-chun.
    CalculateBaziCompatibilityRequestPersonAYearBoundary {
        LiChun = "li-chun",
        LunarNewYear = "lunar-new-year",
    }
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateBaziCompatibilityRequestPersonATimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Which clock the day boundary and the hour branch are read from, so a correction that carries a birth across midnight moves the day pillar with the hour. "clock" is civil time exactly as a birth certificate records it, which is what most calculators use and the default here. "local-mean" shifts to the mean sun over the birth longitude, a correction of up to 59 minutes at the edge of a wide time zone. "solar" adds the equation of time on top of that, up to a further 16 minutes. Both non-civil options need "longitude" in the request and return 400 without it.
    CalculateBaziCompatibilityRequestPersonAHourClock {
        Clock = "clock",
        LocalMean = "local-mean",
        Solar = "solar",
    }
}
string_enum! {
    /// Which instant starts the sexagenary DAY, which only matters for a birth between 23:00 and 23:59. "midnight" is the classical position of the Ming compendium San Ming Tong Hui: the day turns at 00:00 and 23:00 to 23:59 is the late zi hour of the day that is ending, so the hour stem is taken from that day. "early-zi" turns the whole day at 23:00, the practice in Hong Kong, Taiwan and much of South East Asia. "split-zi" is the compromise most software implements and the default here: the day still turns at 00:00, but the hour stem is taken from the next day. The three give three different answers for a late-evening birth and identical answers for every other birth.
    CalculateBaziCompatibilityRequestPersonADayBoundary {
        SplitZi = "split-zi",
        Midnight = "midnight",
        EarlyZi = "early-zi",
    }
}
/// Path and query parameters of `calculateBaziCompatibility`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateBaziCompatibilityParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateBaziCompatibilityParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateBaziCompatibilityParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateAyurvedicConstitution`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAyurvedicConstitutionResponse {
    /// The blended reading. The factors are cited and this is not, which is why it carries a convention label.
    pub composite: CalculateAyurvedicConstitutionResponseComposite,
    /// The conventions this reading was produced under.
    pub conventions: CalculateAyurvedicConstitutionResponseConventions,
    /// The three scored factors, in the order they are weighted.
    pub factors: Vec<CalculateAyurvedicConstitutionResponseFactorsItem>,
    /// The sidereal frame this reading was cast in.
    pub frame: CalculateAyurvedicConstitutionResponseFrame,
    /// The rising sign, lowercase and always English. It is the best attested of the three factors and carries the heaviest weight.
    #[serde(rename = "lagnaSign")]
    pub lagna_sign: String,
    /// Scope of the response.
    pub meta: CalculateAyurvedicConstitutionResponseMeta,
    /// The sign the Moon occupies, lowercase and always English. It is read through the same sign table as the rising sign, on the warrant of the verse that equates the two.
    #[serde(rename = "moonSign")]
    pub moon_sign: String,
    /// The graha to humour and graha to constituent table, as reference. It is informational and does not vary with the request.
    #[serde(rename = "planetDoshas")]
    pub planet_doshas: Vec<CalculateAyurvedicConstitutionResponsePlanetDoshasItem>,
    /// The seven grahas ranked by shadbala, strongest first. Rahu and Ketu are not ranked, because shadbala is defined over the seven.
    #[serde(rename = "strengthRanking")]
    pub strength_ranking: Vec<CalculateAyurvedicConstitutionResponseStrengthRankingItem>,
    /// The reading in prose, composed from the factors rather than selected from stock text, and translated in place.
    pub summary: String,
}
/// One graha of the strength ranking.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAyurvedicConstitutionResponseStrengthRankingItem {
    /// Graha name, as a Vedic birth chart returns it.
    pub graha: String,
    /// Position in the ranking, 1 for the strongest of the seven.
    pub rank: f64,
    /// Whether this graha reached the strength cutoff and therefore contributed to the reading. More than one true value is what makes the reading a blend.
    pub strong: bool,
    /// Total shadbala in virupas, the six-fold strength measure. Higher is stronger, and the ranking below is taken from it.
    #[serde(rename = "totalVirupas")]
    pub total_virupas: f64,
}
/// One graha of the informational seven-graha table. Rahu and Ketu are absent because the verses assign a humour to the seven grahas only, and nothing classical supplies one for the nodes.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAyurvedicConstitutionResponsePlanetDoshasItem {
    /// The bodily constituent this graha rules, in English. Saturn returns a deliberately neutral rendering, because the one Sanskrit word behind it is attested as sinew, tendon, muscle and nerve alike and the two published translations split on it.
    pub dhatu: String,
    /// The same constituent in Sanskrit. Read this rather than the English wherever the two translations disagree. These seven are not the standard seven dhatus and three of them will not line up against such a list.
    #[serde(rename = "dhatuSanskrit")]
    pub dhatu_sanskrit: String,
    /// Where one claim in this response comes from.
    #[serde(rename = "dhatuSource")]
    pub dhatu_source: CalculateAyurvedicConstitutionResponsePlanetDoshasItemDhatuSource,
    /// Where one claim in this response comes from.
    #[serde(rename = "doshaSource")]
    pub dosha_source: CalculateAyurvedicConstitutionResponsePlanetDoshasItemDoshaSource,
    /// The humours the verses give this graha. The Moon and Venus rows carry vata before kapha in both published translations, which is the row material in general circulation most often reverses.
    pub doshas: Vec<String>,
    /// Graha name, matching the name a Vedic birth chart uses, so this table joins to a chart with nothing in between.
    pub graha: String,
    /// The graha name in Sanskrit, in the standard diacritic transliteration.
    #[serde(rename = "sanskritName")]
    pub sanskrit_name: String,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAyurvedicConstitutionResponsePlanetDoshasItemDoshaSource {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAyurvedicConstitutionResponsePlanetDoshasItemDhatuSource {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// Scope of the response.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAyurvedicConstitutionResponseMeta {
    /// The scope of everything in this response, in the requested language. Present on every response from this API, and intended to be shown to the reader rather than stripped.
    pub disclaimer: String,
}
/// The sidereal frame this reading was cast in.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAyurvedicConstitutionResponseFrame {
    /// The sidereal frame the chart was cast in, echoing the request. Always English, so it is safe to compare against.
    pub ayanamsa: String,
    /// The frame offset in degrees at the birth instant, read once and used for both sign factors and for the strength ranking, so the three cannot come from frames a fraction of a degree apart.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
}
/// One cited factor of the reading.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAyurvedicConstitutionResponseFactorsItem {
    /// The humours this factor carries, as the Sanskrit identifiers vata, pitta and kapha. Never translated, so they stay safe to compare against. Where a factor carries more than one they are stored in the standing order and that order means nothing, because the two translations of the source order them differently and their sets are identical.
    pub doshas: Vec<String>,
    /// Which factor this is. One of lagna-sign, moon-sign or strongest-planet. Always English and stable, so it is safe to switch on. There are three and only three, because the two indicators often listed beside them, the lagna lord and the Sun, carry no classical rule that they show the native humour.
    pub id: String,
    /// What this factor read: a sign id for the two sign factors, or the space-separated grahas that reached the strength cutoff for the third.
    pub input: String,
    /// Where one claim in this response comes from.
    pub source: CalculateAyurvedicConstitutionResponseFactorsItemSource,
    /// How much of the composite this factor is given. The weights are a RoxyAPI convention and no primary text states them, which is why every one of them is published here rather than kept private.
    pub weight: f64,
}
/// Where one claim in this response comes from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAyurvedicConstitutionResponseFactorsItemSource {
    /// Chapter or sthana, as printed in that edition. Use it with the verse to find the passage in any copy.
    pub chapter: String,
    /// A recorded disagreement between sources, or a stated limit on what the citation covers. Present only where one exists, and never resolved silently in favour of one reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Whether the cited translation may be quoted. When false the verse reference is the citation and the translator wording is not reproduced anywhere in this API, so a caller reproducing a source must go to the verse rather than to us.
    #[serde(rename = "publicDomain")]
    pub public_domain: bool,
    /// Title of the work the claim is taken from, as it should be cited.
    pub text: String,
    /// The named translator, or null where the English shipped here was written from the Sanskrit because no public-domain translation of that work exists.
    pub translation: Option<String>,
    /// Verse or verse range, printed as the source prints it, so it is a string and not always numeric. Where the claim sits in an appended note or a commentary rather than in a numbered verse, this value is prose, as in "note to 20". Join it to the chapter with a dot only when it is numeric, and otherwise render it after the chapter with a comma, so the pair reads "18, note to 20" rather than "18.note to 20".
    pub verse: String,
    /// Publication year of the named translation, or null where no translation is cited. Use it with publicDomain to judge what may be quoted.
    pub year: Option<f64>,
}
/// The conventions this reading was produced under.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAyurvedicConstitutionResponseConventions {
    /// Which sidereal frame the chart was cast in. Echoes the request, and is repeated here beside the other conventions so one object answers what was chosen.
    pub ayanamsa: String,
    /// Which sign table the two sign factors were read through. Echoes the request.
    #[serde(rename = "signDoshaScheme")]
    pub sign_dosha_scheme: String,
}
/// The blended reading. The factors are cited and this is not, which is why it carries a convention label.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAyurvedicConstitutionResponseComposite {
    /// The version of the blending convention this composite was built under. It is ours and not classical, and it is versioned so a caller comparing two readings taken months apart can tell whether the rule moved.
    pub convention: String,
    /// The humour holding the largest share. A Sanskrit identifier, never translated.
    pub dominant: String,
    /// Share of kapha in whole percent.
    pub kapha: f64,
    /// Share of pitta in whole percent.
    pub pitta: f64,
    /// The humour holding the second largest share. Reported whether or not it reached the margin that would put it in the type label.
    pub secondary: String,
    /// The derived label: one humour when it leads clearly, two joined by a hyphen when the second is within the published margin, and sama when all three sit inside that band. Built from Sanskrit identifiers, so it stays the same string in every language.
    pub r#type: String,
    /// Share of vata in whole percent. The three shares always sum to exactly 100, by largest remainder, so a caller can render them as a bar without normalising first.
    pub vata: f64,
    /// Every number behind the blend, published so a caller who disagrees can re-weigh the factors themselves.
    pub weighting: CalculateAyurvedicConstitutionResponseCompositeWeighting,
}
/// Every number behind the blend, published so a caller who disagrees can re-weigh the factors themselves.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAyurvedicConstitutionResponseCompositeWeighting {
    /// Percentage-point gap below which the second humour joins the type label. When all three sit inside it the label is sama.
    #[serde(rename = "dualTypeMargin")]
    pub dual_type_margin: f64,
    /// Weight given to the rising sign factor.
    #[serde(rename = "lagnaSign")]
    pub lagna_sign: f64,
    /// Weight given to the Moon sign factor, lower than the rising sign because its classical warrant is the narrower of the two.
    #[serde(rename = "moonSign")]
    pub moon_sign: f64,
    /// Fraction of the leading shadbala total at which a second graha also counts as strong. The verse licenses a blended result where several planets attain strength and gives no number for several, so this one is ours.
    #[serde(rename = "strongPlanetThreshold")]
    pub strong_planet_threshold: f64,
    /// Weight given to the strongest graha factor.
    #[serde(rename = "strongestPlanet")]
    pub strongest_planet: f64,
}
/// Path and query parameters of `calculateAyurvedicConstitution`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateAyurvedicConstitutionParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateAyurvedicConstitutionParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateAyurvedicConstitutionParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateAyadi`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAyadiResponse {
    /// The switches this calculation resolved, echoed so it can be reproduced years later without knowing what the defaults were on the day it was made.
    pub conventions: CalculateAyadiResponseConventions,
    /// What was actually divided, in whole cubits. Every remainder is unit sensitive and the formulas are integer arithmetic, so a measure sent in feet or metres is converted and rounded and the rounded figure is published here rather than left for you to infer.
    pub measures: CalculateAyadiResponseMeasures,
    /// The six proportional formulas, each with its measure, multiplier, divisor, remainder and the member that remainder names.
    pub vargas: Vec<CalculateAyadiResponseVargasItem>,
    /// The seventh formula of the perimeter family, which takes the QUOTIENT of the perimeter times eight over twenty seven where rksha takes the remainder. An age or span rather than a member of a named group, and not part of the Manasara six.
    pub vayas: f64,
    /// The two verdict rules the texts actually state: the yoni must be one of the four favourable members, and the aya remainder should exceed the vyaya remainder.
    pub verdict: CalculateAyadiResponseVerdict,
}
/// The two verdict rules the texts actually state: the yoni must be one of the four favourable members, and the aya remainder should exceed the vyaya remainder.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAyadiResponseVerdict {
    /// How the aya compares with the vyaya: aya-greater is conducive to prosperity, equal carries no defect, aya-lesser is defective, and zero-remainder means one of the two divided exactly, which the text calls auspicious in its own right. Always English, safe to compare against.
    #[serde(rename = "ayaVyaya")]
    pub aya_vyaya: String,
    /// The verdict as a sentence, for a report. Composed from the yoni and the aya against vyaya rule, and translated in place when lang is set.
    pub reading: String,
    /// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
    pub source: CalculateAyadiResponseVerdictSource,
    /// Whether the yoni is one of the four favourable members. A remainder of zero is a reject rather than the eighth name, because a zero remainder would face the building north-east and the reference rule says the proportions must be altered instead.
    #[serde(rename = "yoniAuspicious")]
    pub yoni_auspicious: bool,
}
/// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAyadiResponseVerdictSource {
    /// Why a convention rule says what it says. Present only when text is convention, and it names the tradition the rule comes from rather than a verse.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub basis: Option<String>,
    /// Chapter of the primary text. Absent on a convention, which has no chapter to cite.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chapter: Option<f64>,
    /// Whether the cited edition is in the public domain. True on the 1884 Brihat Samhita edition, whose verses are quoted. False on the 1933 Manasara edition behind the Ayadi formulas, from which only the multipliers, divisors and names are taken, never a sentence.
    #[serde(rename = "publicDomain", skip_serializing_if = "Option::is_none")]
    pub public_domain: Option<bool>,
    /// The primary text this verdict rests on, or the literal value convention where no verse states the rule. Always English, safe to compare against.
    pub text: String,
    /// Translator of the edition the verse was read in. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation: Option<String>,
    /// Verse or verse range inside the chapter. Absent on a convention. A range is written with a hyphen, as in 115-117.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub verse: Option<String>,
    /// Publication year of that edition. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<f64>,
}
/// One entry of `vargas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAyadiResponseVargasItem {
    /// Whether this remainder is favourable under the rule the text states for that group: the odd yonis, the odd nakshatras, and four of the seven varas. Absent where no source states a rule for the group.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auspicious: Option<bool>,
    /// What the product was divided by, which is also the size of the group named.
    pub divisor: f64,
    /// The first member of the group, for the two groups where that is all any source gives. Present on aya and on vyaya, and on nothing else.
    #[serde(rename = "firstName", skip_serializing_if = "Option::is_none")]
    pub first_name: Option<String>,
    /// What the yoni name means in plain words. Present on the yoni row only, and translated in place when lang is set.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub gloss: Option<String>,
    /// How many members the group has. Aya is a group of twelve and vyaya a group of ten, which is stated in the text even though the names are not.
    #[serde(rename = "groupSize")]
    pub group_size: f64,
    /// What the measure was multiplied by, per the formula of the chosen text family.
    pub multiplier: f64,
    /// The member the remainder names. Present for the four groups whose names are sourced: the eight yonis, the 27 nakshatras, the 30 tithis and the seven varas. Absent for aya and vyaya, whose names beyond the first are printed in no public-domain source and are never invented here.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Which measure the formula multiplied: length, breadth, circumference, perimeter or area. This is where the three text families differ most, since the Manasara reads three measures separately and the perimeter family reads one.
    pub operand: String,
    /// The measure in whole hasta, after any conversion and rounding. This is the number actually multiplied, so a surprising remainder can be traced to it.
    #[serde(rename = "operandValue")]
    pub operand_value: f64,
    /// The measure times the multiplier, shown so the arithmetic can be checked by hand.
    pub product: f64,
    /// What the division left. This is the Ayadi result: the remainder, not the quotient, names the member of the group.
    pub remainder: f64,
    /// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
    pub source: CalculateAyadiResponseVargasItemSource,
    /// Which of the six proportional formulas this row is: aya, vyaya, yoni, rksha, tithi or vara. Always English, safe to compare against.
    pub varga: String,
}
/// Where a verdict comes from: a chapter and verse of a named public-domain edition, or the literal convention with the practice it rests on. Every verdict in this domain carries one.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAyadiResponseVargasItemSource {
    /// Why a convention rule says what it says. Present only when text is convention, and it names the tradition the rule comes from rather than a verse.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub basis: Option<String>,
    /// Chapter of the primary text. Absent on a convention, which has no chapter to cite.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub chapter: Option<f64>,
    /// Whether the cited edition is in the public domain. True on the 1884 Brihat Samhita edition, whose verses are quoted. False on the 1933 Manasara edition behind the Ayadi formulas, from which only the multipliers, divisors and names are taken, never a sentence.
    #[serde(rename = "publicDomain", skip_serializing_if = "Option::is_none")]
    pub public_domain: Option<bool>,
    /// The primary text this verdict rests on, or the literal value convention where no verse states the rule. Always English, safe to compare against.
    pub text: String,
    /// Translator of the edition the verse was read in. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub translation: Option<String>,
    /// Verse or verse range inside the chapter. Absent on a convention. A range is written with a hyphen, as in 115-117.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub verse: Option<String>,
    /// Publication year of that edition. Absent on a convention.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<f64>,
}
/// What was actually divided, in whole cubits. Every remainder is unit sensitive and the formulas are integer arithmetic, so a measure sent in feet or metres is converted and rounded and the rounded figure is published here rather than left for you to infer.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAyadiResponseMeasures {
    /// Length times breadth in whole hasta squared, which is the measure the Utpala yoni formula reads.
    pub area: f64,
    /// Breadth in whole hasta, after conversion and rounding.
    pub breadth: f64,
    /// Circumference in whole hasta, defaulting to the perimeter.
    pub circumference: f64,
    /// Length in whole hasta, after conversion and rounding.
    pub length: f64,
    /// Perimeter in whole hasta, either as you sent it or as twice length plus twice breadth.
    pub perimeter: f64,
}
/// The switches this calculation resolved, echoed so it can be reproduced years later without knowing what the defaults were on the day it was made.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAyadiResponseConventions {
    /// Which family of formulas was applied. Echoes the resolved value.
    #[serde(rename = "ayadiText")]
    pub ayadi_text: String,
    /// How long one hasta was taken to be, in inches. Echoed because the remainders are unit sensitive and a stored reading cannot be reproduced without it.
    #[serde(rename = "hastaInches")]
    pub hasta_inches: f64,
    /// Which unit the dimensions arrived in. Echoes the resolved value.
    pub unit: String,
    /// Which of the two perimeter vyaya formulas was applied. Echoed even under the Manasara family, which has one vyaya formula and ignores it, so a stored response always says what was resolved.
    #[serde(rename = "vyayaFormula")]
    pub vyaya_formula: String,
}
/// Request body of `calculateAyadi`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAyadiRequest {
    /// Which family of Ayadi formulas to apply. manasara takes length, breadth and circumference separately and is double sourced. perimeter-texts runs every formula on the perimeter alone and is the family the usual worked example is printed for. utpala supplies a yoni formula from the length times the breadth and nothing else, so the other five vargas fall back to the perimeter family and the response says so. Defaults to manasara.
    #[serde(rename = "ayadiText", skip_serializing_if = "Option::is_none")]
    pub ayadi_text: Option<CalculateAyadiRequestAyadiText>,
    /// Breadth of the building or room, in the unit given. Under the Manasara family this is the measure the vyaya and yoni formulas multiply.
    pub breadth: f64,
    /// Circumference or height, if the Manasara vara and tithi formulas should read something other than the perimeter. Defaults to the perimeter, which is what a rectangular plan supplies.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub circumference: Option<f64>,
    /// Length of one hasta, the classical cubit, in inches. Defaults to 18, which is 24 angula at three quarters of an inch each and is the value three independent sources agree on. Raise it if your lineage measures the cubit differently; the value used is echoed on the response so a stored reading can be reproduced years later. Only used when unit is feet or metres.
    #[serde(rename = "hastaInches", skip_serializing_if = "Option::is_none")]
    pub hasta_inches: Option<f64>,
    /// Length of the building or room, in the unit given. Under the Manasara family this is the measure the aya and rksha formulas multiply; under the perimeter family it only feeds the perimeter.
    pub length: f64,
    /// Perimeter of the plan, if it is not simply twice the length plus twice the breadth. The perimeter family runs every formula on this one measure, so it is the number that decides all six remainders there.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub perimeter: Option<f64>,
    /// Unit the Ayadi dimensions are given in. Every remainder is unit sensitive, so this is an input and never assumed: the same building measured in cubits and in feet gives different remainders. hasta is the classical cubit and needs no conversion; feet and metres are converted using hastaInches and rounded to whole cubits, and the rounded figures are returned. Defaults to hasta.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub unit: Option<CalculateAyadiRequestUnit>,
    /// Which vyaya formula the perimeter family uses. The printed table gives two joined by the word or and states no rule for choosing. p9-10 multiplies by nine and divides by ten, which is the only divisor consistent with the ten member vyaya group, so its remainder can be placed in that group and it is the default. p3-14 multiplies by three and divides by fourteen, and its remainder maps to no group any source enumerates. Ignored when ayadiText is manasara, which has one vyaya formula.
    #[serde(rename = "vyayaFormula", skip_serializing_if = "Option::is_none")]
    pub vyaya_formula: Option<CalculateAyadiRequestVyayaFormula>,
}
string_enum! {
    /// Which vyaya formula the perimeter family uses. The printed table gives two joined by the word or and states no rule for choosing. p9-10 multiplies by nine and divides by ten, which is the only divisor consistent with the ten member vyaya group, so its remainder can be placed in that group and it is the default. p3-14 multiplies by three and divides by fourteen, and its remainder maps to no group any source enumerates. Ignored when ayadiText is manasara, which has one vyaya formula.
    CalculateAyadiRequestVyayaFormula {
        P910 = "p9-10",
        P314 = "p3-14",
    }
}
string_enum! {
    /// Unit the Ayadi dimensions are given in. Every remainder is unit sensitive, so this is an input and never assumed: the same building measured in cubits and in feet gives different remainders. hasta is the classical cubit and needs no conversion; feet and metres are converted using hastaInches and rounded to whole cubits, and the rounded figures are returned. Defaults to hasta.
    CalculateAyadiRequestUnit {
        Hasta = "hasta",
        Feet = "feet",
        Metres = "metres",
    }
}
string_enum! {
    /// Which family of Ayadi formulas to apply. manasara takes length, breadth and circumference separately and is double sourced. perimeter-texts runs every formula on the perimeter alone and is the family the usual worked example is printed for. utpala supplies a yoni formula from the length times the breadth and nothing else, so the other five vargas fall back to the perimeter family and the response says so. Defaults to manasara.
    CalculateAyadiRequestAyadiText {
        Manasara = "manasara",
        PerimeterTexts = "perimeter-texts",
        Utpala = "utpala",
    }
}
/// Path and query parameters of `calculateAyadi`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateAyadiParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateAyadiParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateAyadiParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `calculateAspects`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateAspectsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateAspectsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateAspectsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `calculateArudhaPadas`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateArudhaPadasParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateArudhaPadasParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateArudhaPadasParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Path and query parameters of `calculateArabicLots`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateArabicLotsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateArabicLotsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateArabicLotsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `calculateAnnualForecast`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAnnualForecastResponse {
    /// Zodiac animal of the year branch. Always English, whatever the lang parameter says. Use animalLocalized for anything a reader sees.
    pub animal: String,
    /// Display copy of the animal name in the requested language. Absent for English, so an English response is unchanged.
    #[serde(rename = "animalLocalized", skip_serializing_if = "Option::is_none")]
    pub animal_localized: Option<String>,
    /// The sexagenary pillar of the year being read.
    #[serde(rename = "annualPillar")]
    pub annual_pillar: CalculateAnnualForecastResponseAnnualPillar,
    /// True when the year returns the birth animal, which is exactly the case where yearBranchRelation is same. Surfaced as its own boolean because it is the one relation most consumers render on its own.
    #[serde(rename = "benMingNian")]
    pub ben_ming_nian: bool,
    /// Echo of the birth moment the chart was computed from.
    #[serde(rename = "birthData")]
    pub birth_data: CalculateAnnualForecastResponseBirthData,
    /// Relation the principal hidden stem of the annual branch holds to the natal Day Master, the slower half of the same reading.
    #[serde(rename = "branchTenGod")]
    pub branch_ten_god: CalculateAnnualForecastResponseBranchTenGod,
    /// The three school conventions this result was computed under. Returned on every BaZi response so a chart is self-describing: two calculators can produce different pillars for one birth and both be correct, and this object says which reading you are holding.
    pub conventions: CalculateAnnualForecastResponseConventions,
    /// Every combination, clash, harm and punishment the annual pillar forms with each of the four natal pillars. Positions are named natal.year through natal.hour against annual.
    pub interactions: Vec<CalculateAnnualForecastResponseInteractionsItem>,
    /// One-paragraph reading of what the year asks of this chart.
    pub summary: String,
    /// Relation the ANNUAL STEM holds to the natal Day Master. This is the single most useful line of an annual reading: it says what the year asks of the chart.
    #[serde(rename = "tenGod")]
    pub ten_god: CalculateAnnualForecastResponseTenGod,
    /// Echo of the year requested, which the annual pillar below was resolved for.
    pub year: f64,
    /// How the annual branch stands to the NATAL YEAR branch. same is the twelve-yearly return of the birth animal, the year commonly called ben ming nian. clash, harm and punishment are the three breaking relations, and none means the two branches form no structural relation at all. Always English, whatever the lang parameter says.
    #[serde(rename = "yearBranchRelation")]
    pub year_branch_relation: String,
    /// What this relation between the annual branch and the natal year branch means.
    #[serde(rename = "yearBranchRelationMeaning")]
    pub year_branch_relation_meaning: String,
}
/// Relation the ANNUAL STEM holds to the natal Day Master. This is the single most useful line of an annual reading: it says what the year asks of the chart.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAnnualForecastResponseTenGod {
    /// Which of the five cycle relations this belongs to. peer is the same element as the Day Master, output is what the Day Master generates, wealth is what it controls, influence is what controls it, resource is what generates it, and self marks the Day Master itself. Always English, whatever the lang parameter says.
    pub category: String,
    /// The relation in traditional hanzi. Identical under every lang.
    pub chinese: String,
    /// Ten God identifier. One of friend, rob-wealth, eating-god, hurting-officer, indirect-wealth, direct-wealth, seven-killings, direct-officer, indirect-resource, direct-resource, plus day-master in the day-stem position. Always English, whatever the lang parameter says.
    pub id: String,
    /// One-line summary of what this relation contributes, for a compact rendering that has no room for the full meaning.
    pub keynote: String,
    /// Display name of the relation. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Ten God name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone-marked pinyin for the relation. Identical under every lang.
    pub pinyin: String,
}
/// One entry of `interactions`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAnnualForecastResponseInteractionsItem {
    /// The interaction named in hanzi. Identical under every lang.
    pub chinese: String,
    /// Punishments only. True when the third branch of the group is also present in the chart, which is what a complete three-punishment means. False marks the partial case, where only two of the three are in play.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub complete: Option<bool>,
    /// Identifier of the pairing itself, the member ids joined by hyphens in canonical order.
    pub id: String,
    /// What this kind of interaction does between the positions it joins.
    pub meaning: String,
    /// The stem or branch ids taking part, in the same order as positions.
    pub members: Vec<String>,
    /// Tone-marked pinyin for the interaction. Identical under every lang.
    pub pinyin: String,
    /// The chart positions taking part, in the same order as members. On a two-person reading these are prefixed with the subject, for example personA.day.
    pub positions: Vec<String>,
    /// Whether the interaction binds or breaks. harmonious for combinations and trines, challenging for clashes, harms and punishments. Always English, whatever the lang parameter says.
    pub quality: String,
    /// Element the formation resolves to. Present on stem combinations and on complete trines, absent on everything else. Branch six combinations deliberately carry none: the classical sources assign transformed elements to the stem pairs and not to these, and one of the six is contested between schools.
    #[serde(rename = "transformsTo", skip_serializing_if = "Option::is_none")]
    pub transforms_to: Option<String>,
    /// Kind of interaction. stem-combination and six-combination bind two positions, trine binds three, and clash, harm, punishment and stem-clash break them. Always English, whatever the lang parameter says.
    pub r#type: String,
    /// Class of a punishment, present on punishments only. ungrateful is the tiger, snake and monkey group, bullying the ox, dog and goat group, discourteous the rat and rabbit pair, and self a branch doubled against itself.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub variety: Option<String>,
}
/// The three school conventions this result was computed under. Returned on every BaZi response so a chart is self-describing: two calculators can produce different pillars for one birth and both be correct, and this object says which reading you are holding.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAnnualForecastResponseConventions {
    /// Day-boundary school actually applied. Echoes the request, or the default when it was omitted. Always English, whatever the lang parameter says, so it stays safe to compare against in code.
    #[serde(rename = "dayBoundary")]
    pub day_boundary: CalculateAnnualForecastResponseConventionsDayBoundary,
    /// Hour clock actually applied. Echoes the request, or the default when omitted.
    #[serde(rename = "hourClock")]
    pub hour_clock: CalculateAnnualForecastResponseConventionsHourClock,
    /// Year-boundary school actually applied. Echoes the request, or the default when it was omitted.
    #[serde(rename = "yearBoundary")]
    pub year_boundary: CalculateAnnualForecastResponseConventionsYearBoundary,
}
string_enum! {
    /// Year-boundary school actually applied. Echoes the request, or the default when it was omitted.
    CalculateAnnualForecastResponseConventionsYearBoundary {
        LiChun = "li-chun",
        LunarNewYear = "lunar-new-year",
    }
}
string_enum! {
    /// Hour clock actually applied. Echoes the request, or the default when omitted.
    CalculateAnnualForecastResponseConventionsHourClock {
        Clock = "clock",
        LocalMean = "local-mean",
        Solar = "solar",
    }
}
string_enum! {
    /// Day-boundary school actually applied. Echoes the request, or the default when it was omitted. Always English, whatever the lang parameter says, so it stays safe to compare against in code.
    CalculateAnnualForecastResponseConventionsDayBoundary {
        SplitZi = "split-zi",
        Midnight = "midnight",
        EarlyZi = "early-zi",
    }
}
/// Relation the principal hidden stem of the annual branch holds to the natal Day Master, the slower half of the same reading.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAnnualForecastResponseBranchTenGod {
    /// Which of the five cycle relations this belongs to. peer is the same element as the Day Master, output is what the Day Master generates, wealth is what it controls, influence is what controls it, resource is what generates it, and self marks the Day Master itself. Always English, whatever the lang parameter says.
    pub category: String,
    /// The relation in traditional hanzi. Identical under every lang.
    pub chinese: String,
    /// Ten God identifier. One of friend, rob-wealth, eating-god, hurting-officer, indirect-wealth, direct-wealth, seven-killings, direct-officer, indirect-resource, direct-resource, plus day-master in the day-stem position. Always English, whatever the lang parameter says.
    pub id: String,
    /// One-line summary of what this relation contributes, for a compact rendering that has no room for the full meaning.
    pub keynote: String,
    /// Display name of the relation. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Ten God name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tone-marked pinyin for the relation. Identical under every lang.
    pub pinyin: String,
}
/// Echo of the birth moment the chart was computed from.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAnnualForecastResponseBirthData {
    /// Birth date in YYYY-MM-DD format. Sets the year, month and day pillars. The year pillar turns at Beginning of Spring rather than on 1 January, and the month pillar turns at each of the twelve minor solar terms rather than at a calendar month boundary.
    pub date: String,
    /// Birth latitude in decimal degrees. Accepted for consistency with the other birth-data endpoints and does not affect any part of a BaZi chart. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Positive is East, negative is West. Required when hourClock is "local-mean" or "solar", which shift the hour branch to the sun over the birth place; omitting it in either case returns 400. Ignored when hourClock is "clock".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Birth time in 24-hour HH:MM:SS format. Sets the hour pillar, which is one of the four and carries the whole picture of later life and offspring. Each Earthly Branch covers two hours, so a birth within a few minutes of an odd hour can land in either. All four pillars are read in the local clock of the birth, and the day boundary is applied in that same clock; only the lunisolar calendar date itself is a world constant, fixed at UTC plus 8 so one instant has one Chinese date everywhere.
    pub time: String,
    /// Decimal UTC offset the chart was computed with, resolved from whatever the request sent. An IANA name is resolved to the offset in force at the birth, so this is the literal number applied and never the name. A local time that never happened (the skipped hour of a daylight-saving change) is moved forward past the gap, and date, time and timezone then echo the clock that was running, which the day and hour pillars are read from.
    pub timezone: f64,
}
/// The sexagenary pillar of the year being read.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAnnualForecastResponseAnnualPillar {
    /// Earthly Branch of the year.
    pub branch: CalculateAnnualForecastResponseAnnualPillarBranch,
    /// Annual pillar identifier, the stem id and the branch id joined by a hyphen.
    pub id: String,
    /// Na Yin sound element of the annual pillar.
    #[serde(rename = "naYin")]
    pub na_yin: String,
    /// The Na Yin name in hanzi. Identical under every lang.
    #[serde(rename = "naYinChinese")]
    pub na_yin_chinese: String,
    /// Position of the annual pillar in the sexagenary cycle, 1 to 60.
    pub number: f64,
    /// Heavenly Stem of the year.
    pub stem: CalculateAnnualForecastResponseAnnualPillarStem,
}
/// Heavenly Stem of the year.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAnnualForecastResponseAnnualPillarStem {
    /// The stem in hanzi. Data rather than display copy, so it is identical under every lang.
    pub chinese: String,
    /// Five-phase element of the stem. One of Wood, Fire, Earth, Metal, Water. Always English, whatever the lang parameter says. Use elementLocalized for anything a reader sees.
    pub element: String,
    /// Element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Heavenly Stem identifier. One of jia, yi, bing, ding, wu, ji, geng, xin, ren, gui. Always English pinyin, whatever the lang parameter says, so it stays safe to compare against in code and to key a glyph table on.
    pub id: String,
    /// Tone-marked pinyin for the stem. Identical under every lang.
    pub pinyin: String,
    /// Polarity of the stem, yang or yin. The five odd stems are yang and the five even ones are yin, and this is half of what decides every Ten God relation in the chart.
    pub polarity: String,
}
/// Earthly Branch of the year.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAnnualForecastResponseAnnualPillarBranch {
    /// Zodiac animal of the branch. One of rat, ox, tiger, rabbit, dragon, snake, horse, goat, monkey, rooster, dog, pig. Always English, whatever the lang parameter says. Use animalLocalized for anything a reader sees.
    pub animal: String,
    /// Zodiac animal name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "animalLocalized", skip_serializing_if = "Option::is_none")]
    pub animal_localized: Option<String>,
    /// The branch in hanzi. Identical under every lang.
    pub chinese: String,
    /// Five-phase element of the branch. Always English, whatever the lang parameter says. Use elementLocalized for anything a reader sees.
    pub element: String,
    /// Element name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "elementLocalized", skip_serializing_if = "Option::is_none")]
    pub element_localized: Option<String>,
    /// Earthly Branch identifier. One of zi, chou, yin, mao, chen, si, wu, wei, shen, you, xu, hai. Always English pinyin, whatever the lang parameter says. Note that "wu" is also a stem identifier: they never share a field, so a branch id is only ever read out of a branch position.
    pub id: String,
    /// Tone-marked pinyin for the branch. Identical under every lang.
    pub pinyin: String,
    /// Polarity of the branch, yang or yin.
    pub polarity: String,
}
/// Request body of `calculateAnnualForecast`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateAnnualForecastRequest {
    /// Birth date in YYYY-MM-DD format. Sets the year, month and day pillars. The year pillar turns at Beginning of Spring rather than on 1 January, and the month pillar turns at each of the twelve minor solar terms rather than at a calendar month boundary.
    pub date: String,
    /// Which instant starts the sexagenary DAY, which only matters for a birth between 23:00 and 23:59. "midnight" is the classical position of the Ming compendium San Ming Tong Hui: the day turns at 00:00 and 23:00 to 23:59 is the late zi hour of the day that is ending, so the hour stem is taken from that day. "early-zi" turns the whole day at 23:00, the practice in Hong Kong, Taiwan and much of South East Asia. "split-zi" is the compromise most software implements and the default here: the day still turns at 00:00, but the hour stem is taken from the next day. The three give three different answers for a late-evening birth and identical answers for every other birth.
    #[serde(rename = "dayBoundary", skip_serializing_if = "Option::is_none")]
    pub day_boundary: Option<CalculateAnnualForecastRequestDayBoundary>,
    /// Which clock the day boundary and the hour branch are read from, so a correction that carries a birth across midnight moves the day pillar with the hour. "clock" is civil time exactly as a birth certificate records it, which is what most calculators use and the default here. "local-mean" shifts to the mean sun over the birth longitude, a correction of up to 59 minutes at the edge of a wide time zone. "solar" adds the equation of time on top of that, up to a further 16 minutes. Both non-civil options need "longitude" in the request and return 400 without it.
    #[serde(rename = "hourClock", skip_serializing_if = "Option::is_none")]
    pub hour_clock: Option<CalculateAnnualForecastRequestHourClock>,
    /// Birth latitude in decimal degrees. Accepted for consistency with the other birth-data endpoints and does not affect any part of a BaZi chart. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub latitude: Option<f64>,
    /// Birth longitude in decimal degrees. Positive is East, negative is West. Required when hourClock is "local-mean" or "solar", which shift the hour branch to the sun over the birth place; omitting it in either case returns 400. Ignored when hourClock is "clock".
    #[serde(skip_serializing_if = "Option::is_none")]
    pub longitude: Option<f64>,
    /// Birth time in 24-hour HH:MM:SS format. Sets the hour pillar, which is one of the four and carries the whole picture of later life and offspring. Each Earthly Branch covers two hours, so a birth within a few minutes of an odd hour can land in either. All four pillars are read in the local clock of the birth, and the day boundary is applied in that same clock; only the lunisolar calendar date itself is a world constant, fixed at UTC plus 8 so one instant has one Chinese date everywhere.
    pub time: String,
    /// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
    pub timezone: CalculateAnnualForecastRequestTimezone,
    /// Gregorian year to read against the natal chart. The annual pillar for that year is resolved under the same year boundary the request selected, so a li-chun reading and a lunar-new-year reading of the same calendar year can differ.
    pub year: i64,
    /// Which instant starts the sexagenary YEAR. "li-chun" is Beginning of Spring, around 4 February, and is the classical rule every BaZi text uses, so it is the default on this endpoint. "lunar-new-year" is the folk rule people mean when they say which animal they are, and it falls between late January and late February. The two disagree for any birth in the weeks between them: 14 February 2026 is a Wood Snake year under lunar-new-year and a Fire Horse year under li-chun.
    #[serde(rename = "yearBoundary", skip_serializing_if = "Option::is_none")]
    pub year_boundary: Option<CalculateAnnualForecastRequestYearBoundary>,
}
string_enum! {
    /// Which instant starts the sexagenary YEAR. "li-chun" is Beginning of Spring, around 4 February, and is the classical rule every BaZi text uses, so it is the default on this endpoint. "lunar-new-year" is the folk rule people mean when they say which animal they are, and it falls between late January and late February. The two disagree for any birth in the weeks between them: 14 February 2026 is a Wood Snake year under lunar-new-year and a Fire Horse year under li-chun.
    CalculateAnnualForecastRequestYearBoundary {
        LiChun = "li-chun",
        LunarNewYear = "lunar-new-year",
    }
}
/// IANA name (e.g. "America/New_York", "Europe/London", "UTC"), decimal hours (e.g. -5 for EST, 1 for CET), or a fixed UTC offset (e.g. "-05:00", "+01:00"). Prefer the IANA name: it is resolved to the offset in force at the birth date and time, historical daylight-saving rules included, while a fixed offset or decimal is taken literally and will be wrong if it does not match the daylight-saving state at that moment. On a transition day a time in the repeated hour is read as its first occurrence and a time in the skipped hour is moved forward past the gap. Invalid timezones return 400 with a validation error.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum CalculateAnnualForecastRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Which clock the day boundary and the hour branch are read from, so a correction that carries a birth across midnight moves the day pillar with the hour. "clock" is civil time exactly as a birth certificate records it, which is what most calculators use and the default here. "local-mean" shifts to the mean sun over the birth longitude, a correction of up to 59 minutes at the edge of a wide time zone. "solar" adds the equation of time on top of that, up to a further 16 minutes. Both non-civil options need "longitude" in the request and return 400 without it.
    CalculateAnnualForecastRequestHourClock {
        Clock = "clock",
        LocalMean = "local-mean",
        Solar = "solar",
    }
}
string_enum! {
    /// Which instant starts the sexagenary DAY, which only matters for a birth between 23:00 and 23:59. "midnight" is the classical position of the Ming compendium San Ming Tong Hui: the day turns at 00:00 and 23:00 to 23:59 is the late zi hour of the day that is ending, so the hour stem is taken from that day. "early-zi" turns the whole day at 23:00, the practice in Hong Kong, Taiwan and much of South East Asia. "split-zi" is the compromise most software implements and the default here: the day still turns at 00:00, but the hour stem is taken from the next day. The three give three different answers for a late-evening birth and identical answers for every other birth.
    CalculateAnnualForecastRequestDayBoundary {
        SplitZi = "split-zi",
        Midnight = "midnight",
        EarlyZi = "early-zi",
    }
}
/// Path and query parameters of `calculateAnnualForecast`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateAnnualForecastParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<CalculateAnnualForecastParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    CalculateAnnualForecastParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Response body of `generateBirthChart`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponse {
    /// The `aquarius` field.
    pub aquarius: BirthChartResponseAquarius,
    /// The `aries` field.
    pub aries: BirthChartResponseAries,
    /// The `cancer` field.
    pub cancer: BirthChartResponseCancer,
    /// The `capricorn` field.
    pub capricorn: BirthChartResponseCapricorn,
    /// Combust planets (astangata graha): grahas within their combustion orb of the Sun. Combustion weakens a planet significations. Empty when no planet is combust.
    pub combustion: Vec<BirthChartResponseCombustionItem>,
    /// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
    pub frame: BirthChartResponseFrame,
    /// The `gemini` field.
    pub gemini: BirthChartResponseGemini,
    /// The twelve bhavas (houses) in order, each with its classical name and significations. Houses are counted whole-sign from the Lagna.
    pub houses: Vec<BirthChartResponseHousesItem>,
    /// Planet-in-rashi and planet-in-nakshatra interpretation summaries, keyed by planet name. Translated when a supported lang is requested.
    pub interpretations: BirthChartResponseInterpretations,
    /// The `leo` field.
    pub leo: BirthChartResponseLeo,
    /// The `libra` field.
    pub libra: BirthChartResponseLibra,
    /// Quick lookup of all planet positions keyed by planet name. Contains Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn, Rahu, Ketu, and Lagna (Ascendant).
    pub meta: BirthChartResponseMeta,
    /// Uranus, Neptune and Pluto, present only when modernPlanets true was sent. Deliberately separate from meta and deliberately without dignity, avastha, combustion or aspect fields: those are constructs of the nine-graha system and the modern planets rule no sign, so no classical value exists for them. Order is always Uranus, Neptune, Pluto.
    #[serde(rename = "modernPlanets", skip_serializing_if = "Option::is_none")]
    pub modern_planets: Option<Vec<BirthChartResponseModernPlanetsItem>>,
    /// The `pisces` field.
    pub pisces: BirthChartResponsePisces,
    /// Planetary wars (graha yuddha): pairs of visible planets within 1 degree of each other. Empty when no two planets are in war.
    #[serde(rename = "planetaryWar")]
    pub planetary_war: Vec<BirthChartResponsePlanetaryWarItem>,
    /// The `sagittarius` field.
    pub sagittarius: BirthChartResponseSagittarius,
    /// The `scorpio` field.
    pub scorpio: BirthChartResponseScorpio,
    /// The `taurus` field.
    pub taurus: BirthChartResponseTaurus,
    /// The `virgo` field.
    pub virgo: BirthChartResponseVirgo,
    /// Forty-four classical yogas detected against this chart. Twelve conjunction and dignity yogas: Gajakesari (three-rule parashara definition), Sunapha, Anapha, Dhurdhura, Kemadruma, Chandra Mangala, Budha-Aditya, and the five Pancha Mahapurusha (Ruchaka, Bhadra, Hamsa, Malavya, Sasa). Plus all 32 Nabhasa distribution yogas across the Asraya, Dala, Akriti and Sankhya families, which read how the seven visible grahas are spread over the whole chart rather than any single conjunction, and which apply the four classical precedence norms so an outranked yoga is returned as absent with evidence naming the norm that silenced it. Each entry carries an `id` (matches `GET /yoga/{id}` for full glossary lookup), a `present` boolean, a `quality` (Positive, Negative, or Both = auspicious, inauspicious, or context-dependent), and classical-text `evidence` for the rule that triggered or failed. Filter on `present === true` for the active list.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub yogas: Option<Vec<BirthChartResponseYogasItem>>,
}
/// One entry of `yogas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseYogasItem {
    /// Brief classical formation rule. Identifies the planetary placement, lordship, dignity, aspect pattern, sign modality, or whole-chart bhava distribution required for the yoga to form.
    pub description: String,
    /// Human-readable rationale naming the specific rule that triggered or failed the detection, including planetary positions, dignity, kendradhipati status, lordship, malefic drishti, sign modality, or whole-chart bhava distribution. For a Nabhasa yoga that matched its own rule but was outranked, this names the precedence norm that silenced it, for example that an Akriti yoga outranks Asraya or that any other Nabhasa family suppresses Sankhya. English in every language, like the per-graha stateSource on POST /daily, because it is provenance to be checked against a text rather than display copy.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub evidence: Option<String>,
    /// Classical grouping, ALWAYS present on a detection verdict: one of the four Nabhasa families (asraya, dala, akriti, sankhya) or classical for the twelve single-combination yogas such as Gajakesari and the Pancha Mahapurusha. Group the verdict list on this key to render a Nabhasa result the way the tradition arranges it. Never translated, so grouping works identically under any lang.
    pub family: BirthChartResponseYogasItemFamily,
    /// Glossary id (lowercase, kebab-case) matching an entry in the 301-entry planetary-yoga catalog. Use with GET /yoga/{id} to retrieve the full glossary text.
    pub id: String,
    /// Classical Sanskrit name of the yoga as referenced in BPHS (Brihat Parashara Hora Shastra), Phaladeepika, and B.V. Raman *Three Hundred Important Combinations*.
    pub name: String,
    /// True if every classical condition for the yoga is satisfied by the given chart. False means one of TWO different things: the rule failed, or the rule held and a stronger family outranked it. Read `suppressedBy` to tell those apart, which is exact and locale-independent; `evidence` says the same thing in English prose.
    pub present: bool,
    /// Overall nature. Auspicious yogas (Pancha Mahapurusha, Gajakesari) bestow benefits; inauspicious yogas (Kemadruma) indicate challenges; Both denotes context-dependent effects.
    pub quality: BirthChartResponseYogasItemQuality,
    /// Classical phala (life-effect) description of the yoga when present, sourced from the parashari and phaladeepika tradition.
    pub result: String,
    /// Set ONLY when this yoga matched its own classical rule and was then silenced by a higher-ranking family, so `present` is false for a reason a practitioner reads very differently from a failed rule. Names the family that took precedence, under the four classical norms: Akriti outranks Asraya, and Akriti, Asraya and Dala each outrank Sankhya. Absent means the rule genuinely did not hold.
    #[serde(rename = "suppressedBy", skip_serializing_if = "Option::is_none")]
    pub suppressed_by: Option<BirthChartResponseYogasItemSuppressedBy>,
}
string_enum! {
    /// Set ONLY when this yoga matched its own classical rule and was then silenced by a higher-ranking family, so `present` is false for a reason a practitioner reads very differently from a failed rule. Names the family that took precedence, under the four classical norms: Akriti outranks Asraya, and Akriti, Asraya and Dala each outrank Sankhya. Absent means the rule genuinely did not hold.
    BirthChartResponseYogasItemSuppressedBy {
        Classical = "classical",
        Asraya = "asraya",
        Dala = "dala",
        Akriti = "akriti",
        Sankhya = "sankhya",
    }
}
string_enum! {
    /// Overall nature. Auspicious yogas (Pancha Mahapurusha, Gajakesari) bestow benefits; inauspicious yogas (Kemadruma) indicate challenges; Both denotes context-dependent effects.
    BirthChartResponseYogasItemQuality {
        Positive = "Positive",
        Negative = "Negative",
        Both = "Both",
    }
}
string_enum! {
    /// Classical grouping, ALWAYS present on a detection verdict: one of the four Nabhasa families (asraya, dala, akriti, sankhya) or classical for the twelve single-combination yogas such as Gajakesari and the Pancha Mahapurusha. Group the verdict list on this key to render a Nabhasa result the way the tradition arranges it. Never translated, so grouping works identically under any lang.
    BirthChartResponseYogasItemFamily {
        Classical = "classical",
        Asraya = "asraya",
        Dala = "dala",
        Akriti = "akriti",
        Sankhya = "sankhya",
    }
}
/// The `virgo` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseVirgo {
    /// Zodiac sign name in lowercase. Always equals the key of the block it sits in, so the aries block carries "aries" and the pisces block carries "pisces".
    pub rashi: String,
    /// Planets placed in this zodiac sign.
    pub signs: Vec<BirthChartResponseVirgoSignsItem>,
}
/// One entry of `signs`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseVirgoSignsItem {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awastha: Option<BirthChartResponseVirgoSignsItemAwastha>,
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deeptadi: Option<BirthChartResponseVirgoSignsItemDeeptadi>,
    /// Planet (graha) placed in this sign.
    pub graha: String,
    /// Bhava (house) number 1-12, counted whole-sign from the Lagna (house 1 is the Lagna rashi). Present on the D1 birth chart; divisional charts (navamsa, varga) omit it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub house: Option<i64>,
    /// True if planet is in retrograde motion (appears to move backward). Retrograde planets have altered significations.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub jagradadi: Option<BirthChartResponseVirgoSignsItemJagradadi>,
    /// Sidereal longitude in degrees (0-360) using Lahiri ayanamsa.
    pub longitude: f64,
    /// The `nakshatra` field.
    pub nakshatra: BirthChartResponseVirgoSignsItemNakshatra,
}
/// The `nakshatra` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseVirgoSignsItemNakshatra {
    /// Nakshatra index (1-27) in the zodiac sequence starting from Ashwini.
    pub key: f64,
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    pub lord: BirthChartResponseVirgoSignsItemNakshatraLord,
    /// Nakshatra (lunar mansion, 1 of 27) the planet occupies.
    pub name: String,
    /// Nakshatra pada (quarter, 1-4). Each nakshatra has 4 padas of 3 degrees 20 each.
    pub pada: f64,
}
string_enum! {
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    BirthChartResponseVirgoSignsItemNakshatraLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    BirthChartResponseVirgoSignsItemJagradadi {
        Jagrat = "Jagrat",
        Swapna = "Swapna",
        Sushupti = "Sushupti",
    }
}
string_enum! {
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    BirthChartResponseVirgoSignsItemDeeptadi {
        Dipta = "Dipta",
        Svastha = "Svastha",
        Pramudita = "Pramudita",
        Shanta = "Shanta",
        Dina = "Dina",
        Duhkhita = "Duhkhita",
        Vikala = "Vikala",
        Khala = "Khala",
        Kopa = "Kopa",
    }
}
string_enum! {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    BirthChartResponseVirgoSignsItemAwastha {
        Bala = "Bala",
        Kumara = "Kumara",
        Yuva = "Yuva",
        Vriddha = "Vriddha",
        Mrita = "Mrita",
    }
}
/// The `taurus` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseTaurus {
    /// Zodiac sign name in lowercase. Always equals the key of the block it sits in, so the aries block carries "aries" and the pisces block carries "pisces".
    pub rashi: String,
    /// Planets placed in this zodiac sign.
    pub signs: Vec<BirthChartResponseTaurusSignsItem>,
}
/// One entry of `signs`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseTaurusSignsItem {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awastha: Option<BirthChartResponseTaurusSignsItemAwastha>,
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deeptadi: Option<BirthChartResponseTaurusSignsItemDeeptadi>,
    /// Planet (graha) placed in this sign.
    pub graha: String,
    /// Bhava (house) number 1-12, counted whole-sign from the Lagna (house 1 is the Lagna rashi). Present on the D1 birth chart; divisional charts (navamsa, varga) omit it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub house: Option<i64>,
    /// True if planet is in retrograde motion (appears to move backward). Retrograde planets have altered significations.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub jagradadi: Option<BirthChartResponseTaurusSignsItemJagradadi>,
    /// Sidereal longitude in degrees (0-360) using Lahiri ayanamsa.
    pub longitude: f64,
    /// The `nakshatra` field.
    pub nakshatra: BirthChartResponseTaurusSignsItemNakshatra,
}
/// The `nakshatra` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseTaurusSignsItemNakshatra {
    /// Nakshatra index (1-27) in the zodiac sequence starting from Ashwini.
    pub key: f64,
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    pub lord: BirthChartResponseTaurusSignsItemNakshatraLord,
    /// Nakshatra (lunar mansion, 1 of 27) the planet occupies.
    pub name: String,
    /// Nakshatra pada (quarter, 1-4). Each nakshatra has 4 padas of 3 degrees 20 each.
    pub pada: f64,
}
string_enum! {
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    BirthChartResponseTaurusSignsItemNakshatraLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    BirthChartResponseTaurusSignsItemJagradadi {
        Jagrat = "Jagrat",
        Swapna = "Swapna",
        Sushupti = "Sushupti",
    }
}
string_enum! {
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    BirthChartResponseTaurusSignsItemDeeptadi {
        Dipta = "Dipta",
        Svastha = "Svastha",
        Pramudita = "Pramudita",
        Shanta = "Shanta",
        Dina = "Dina",
        Duhkhita = "Duhkhita",
        Vikala = "Vikala",
        Khala = "Khala",
        Kopa = "Kopa",
    }
}
string_enum! {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    BirthChartResponseTaurusSignsItemAwastha {
        Bala = "Bala",
        Kumara = "Kumara",
        Yuva = "Yuva",
        Vriddha = "Vriddha",
        Mrita = "Mrita",
    }
}
/// The `scorpio` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseScorpio {
    /// Zodiac sign name in lowercase. Always equals the key of the block it sits in, so the aries block carries "aries" and the pisces block carries "pisces".
    pub rashi: String,
    /// Planets placed in this zodiac sign.
    pub signs: Vec<BirthChartResponseScorpioSignsItem>,
}
/// One entry of `signs`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseScorpioSignsItem {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awastha: Option<BirthChartResponseScorpioSignsItemAwastha>,
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deeptadi: Option<BirthChartResponseScorpioSignsItemDeeptadi>,
    /// Planet (graha) placed in this sign.
    pub graha: String,
    /// Bhava (house) number 1-12, counted whole-sign from the Lagna (house 1 is the Lagna rashi). Present on the D1 birth chart; divisional charts (navamsa, varga) omit it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub house: Option<i64>,
    /// True if planet is in retrograde motion (appears to move backward). Retrograde planets have altered significations.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub jagradadi: Option<BirthChartResponseScorpioSignsItemJagradadi>,
    /// Sidereal longitude in degrees (0-360) using Lahiri ayanamsa.
    pub longitude: f64,
    /// The `nakshatra` field.
    pub nakshatra: BirthChartResponseScorpioSignsItemNakshatra,
}
/// The `nakshatra` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseScorpioSignsItemNakshatra {
    /// Nakshatra index (1-27) in the zodiac sequence starting from Ashwini.
    pub key: f64,
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    pub lord: BirthChartResponseScorpioSignsItemNakshatraLord,
    /// Nakshatra (lunar mansion, 1 of 27) the planet occupies.
    pub name: String,
    /// Nakshatra pada (quarter, 1-4). Each nakshatra has 4 padas of 3 degrees 20 each.
    pub pada: f64,
}
string_enum! {
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    BirthChartResponseScorpioSignsItemNakshatraLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    BirthChartResponseScorpioSignsItemJagradadi {
        Jagrat = "Jagrat",
        Swapna = "Swapna",
        Sushupti = "Sushupti",
    }
}
string_enum! {
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    BirthChartResponseScorpioSignsItemDeeptadi {
        Dipta = "Dipta",
        Svastha = "Svastha",
        Pramudita = "Pramudita",
        Shanta = "Shanta",
        Dina = "Dina",
        Duhkhita = "Duhkhita",
        Vikala = "Vikala",
        Khala = "Khala",
        Kopa = "Kopa",
    }
}
string_enum! {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    BirthChartResponseScorpioSignsItemAwastha {
        Bala = "Bala",
        Kumara = "Kumara",
        Yuva = "Yuva",
        Vriddha = "Vriddha",
        Mrita = "Mrita",
    }
}
/// The `sagittarius` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseSagittarius {
    /// Zodiac sign name in lowercase. Always equals the key of the block it sits in, so the aries block carries "aries" and the pisces block carries "pisces".
    pub rashi: String,
    /// Planets placed in this zodiac sign.
    pub signs: Vec<BirthChartResponseSagittariusSignsItem>,
}
/// One entry of `signs`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseSagittariusSignsItem {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awastha: Option<BirthChartResponseSagittariusSignsItemAwastha>,
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deeptadi: Option<BirthChartResponseSagittariusSignsItemDeeptadi>,
    /// Planet (graha) placed in this sign.
    pub graha: String,
    /// Bhava (house) number 1-12, counted whole-sign from the Lagna (house 1 is the Lagna rashi). Present on the D1 birth chart; divisional charts (navamsa, varga) omit it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub house: Option<i64>,
    /// True if planet is in retrograde motion (appears to move backward). Retrograde planets have altered significations.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub jagradadi: Option<BirthChartResponseSagittariusSignsItemJagradadi>,
    /// Sidereal longitude in degrees (0-360) using Lahiri ayanamsa.
    pub longitude: f64,
    /// The `nakshatra` field.
    pub nakshatra: BirthChartResponseSagittariusSignsItemNakshatra,
}
/// The `nakshatra` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseSagittariusSignsItemNakshatra {
    /// Nakshatra index (1-27) in the zodiac sequence starting from Ashwini.
    pub key: f64,
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    pub lord: BirthChartResponseSagittariusSignsItemNakshatraLord,
    /// Nakshatra (lunar mansion, 1 of 27) the planet occupies.
    pub name: String,
    /// Nakshatra pada (quarter, 1-4). Each nakshatra has 4 padas of 3 degrees 20 each.
    pub pada: f64,
}
string_enum! {
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    BirthChartResponseSagittariusSignsItemNakshatraLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    BirthChartResponseSagittariusSignsItemJagradadi {
        Jagrat = "Jagrat",
        Swapna = "Swapna",
        Sushupti = "Sushupti",
    }
}
string_enum! {
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    BirthChartResponseSagittariusSignsItemDeeptadi {
        Dipta = "Dipta",
        Svastha = "Svastha",
        Pramudita = "Pramudita",
        Shanta = "Shanta",
        Dina = "Dina",
        Duhkhita = "Duhkhita",
        Vikala = "Vikala",
        Khala = "Khala",
        Kopa = "Kopa",
    }
}
string_enum! {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    BirthChartResponseSagittariusSignsItemAwastha {
        Bala = "Bala",
        Kumara = "Kumara",
        Yuva = "Yuva",
        Vriddha = "Vriddha",
        Mrita = "Mrita",
    }
}
/// One entry of `planetaryWar`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponsePlanetaryWarItem {
    /// Angular separation between the two grahas in degrees.
    pub distance: f64,
    /// First graha in the planetary war (graha yuddha) pair.
    pub planet1: String,
    /// Second graha in the planetary war (graha yuddha) pair.
    pub planet2: String,
    /// Graha that wins the planetary war, the one with the more northerly ecliptic latitude. The winner keeps its strength, the loser is weakened.
    pub winner: String,
}
/// The `pisces` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponsePisces {
    /// Zodiac sign name in lowercase. Always equals the key of the block it sits in, so the aries block carries "aries" and the pisces block carries "pisces".
    pub rashi: String,
    /// Planets placed in this zodiac sign.
    pub signs: Vec<BirthChartResponsePiscesSignsItem>,
}
/// One entry of `signs`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponsePiscesSignsItem {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awastha: Option<BirthChartResponsePiscesSignsItemAwastha>,
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deeptadi: Option<BirthChartResponsePiscesSignsItemDeeptadi>,
    /// Planet (graha) placed in this sign.
    pub graha: String,
    /// Bhava (house) number 1-12, counted whole-sign from the Lagna (house 1 is the Lagna rashi). Present on the D1 birth chart; divisional charts (navamsa, varga) omit it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub house: Option<i64>,
    /// True if planet is in retrograde motion (appears to move backward). Retrograde planets have altered significations.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub jagradadi: Option<BirthChartResponsePiscesSignsItemJagradadi>,
    /// Sidereal longitude in degrees (0-360) using Lahiri ayanamsa.
    pub longitude: f64,
    /// The `nakshatra` field.
    pub nakshatra: BirthChartResponsePiscesSignsItemNakshatra,
}
/// The `nakshatra` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponsePiscesSignsItemNakshatra {
    /// Nakshatra index (1-27) in the zodiac sequence starting from Ashwini.
    pub key: f64,
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    pub lord: BirthChartResponsePiscesSignsItemNakshatraLord,
    /// Nakshatra (lunar mansion, 1 of 27) the planet occupies.
    pub name: String,
    /// Nakshatra pada (quarter, 1-4). Each nakshatra has 4 padas of 3 degrees 20 each.
    pub pada: f64,
}
string_enum! {
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    BirthChartResponsePiscesSignsItemNakshatraLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    BirthChartResponsePiscesSignsItemJagradadi {
        Jagrat = "Jagrat",
        Swapna = "Swapna",
        Sushupti = "Sushupti",
    }
}
string_enum! {
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    BirthChartResponsePiscesSignsItemDeeptadi {
        Dipta = "Dipta",
        Svastha = "Svastha",
        Pramudita = "Pramudita",
        Shanta = "Shanta",
        Dina = "Dina",
        Duhkhita = "Duhkhita",
        Vikala = "Vikala",
        Khala = "Khala",
        Kopa = "Kopa",
    }
}
string_enum! {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    BirthChartResponsePiscesSignsItemAwastha {
        Bala = "Bala",
        Kumara = "Kumara",
        Yuva = "Yuva",
        Vriddha = "Vriddha",
        Mrita = "Mrita",
    }
}
/// One entry of `modernPlanets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseModernPlanetsItem {
    /// Degrees advanced into the sign, 0 to 30. This is the figure a chart displays beside the sign.
    #[serde(rename = "degreeInRashi")]
    pub degree_in_rashi: f64,
    /// True when the body appears to move backward. All three are retrograde for roughly 40 percent of each year, so this is the normal case rather than the exception.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Sidereal longitude in degrees (0-360), in the same ayanamsa frame as every other position in this response.
    pub longitude: f64,
    /// Nakshatra placement. Reported because it is purely positional; it does not imply the body participates in Vimshottari dasha, which is built on the Moon alone.
    pub nakshatra: BirthChartResponseModernPlanetsItemNakshatra,
    /// Modern planet name. These three are outside the classical Navagraha and are returned only when modernPlanets true is sent.
    pub planet: BirthChartResponseModernPlanetsItemPlanet,
    /// Zodiac sign (rashi) the body occupies.
    pub rashi: String,
    /// Sanskrit name Indian software prints for this body: Arun for Uranus, Varun for Neptune, Yam for Pluto. Transliterated rather than translated, the same treatment as rashi and nakshatra lord names, so it is identical in every locale.
    #[serde(rename = "sanskritName")]
    pub sanskrit_name: BirthChartResponseModernPlanetsItemSanskritName,
}
string_enum! {
    /// Sanskrit name Indian software prints for this body: Arun for Uranus, Varun for Neptune, Yam for Pluto. Transliterated rather than translated, the same treatment as rashi and nakshatra lord names, so it is identical in every locale.
    BirthChartResponseModernPlanetsItemSanskritName {
        Arun = "Arun",
        Varun = "Varun",
        Yam = "Yam",
    }
}
string_enum! {
    /// Modern planet name. These three are outside the classical Navagraha and are returned only when modernPlanets true is sent.
    BirthChartResponseModernPlanetsItemPlanet {
        Uranus = "Uranus",
        Neptune = "Neptune",
        Pluto = "Pluto",
    }
}
/// Nakshatra placement. Reported because it is purely positional; it does not imply the body participates in Vimshottari dasha, which is built on the Moon alone.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseModernPlanetsItemNakshatra {
    /// Nakshatra index (1-27) starting from Ashwini.
    pub key: f64,
    /// Vimshottari ruling planet of this nakshatra.
    pub lord: BirthChartResponseModernPlanetsItemNakshatraLord,
    /// Nakshatra (lunar mansion, 1 of 27) the body occupies.
    pub name: String,
    /// Nakshatra pada (quarter, 1-4).
    pub pada: f64,
}
string_enum! {
    /// Vimshottari ruling planet of this nakshatra.
    BirthChartResponseModernPlanetsItemNakshatraLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
/// Quick lookup of all planet positions keyed by planet name. Contains Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn, Rahu, Ketu, and Lagna (Ascendant).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseMeta {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<
        String,
        BirthChartResponseMetaAdditionalProperty,
    >,
}
/// One graha placement: rashi, sidereal longitude, nakshatra with pada and lord, whole-sign bhava, retrogression, and the Baladi, Jagradadi and Deeptadi avastha states.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseMetaAdditionalProperty {
    /// Localized readings for this graha avastha states, present only when avasthaInfo true was sent. Each key mirrors the state field of the same name and carries a short meaning plus a one-sentence classical interpretation, so a client can label Yuva or Swapna without a second lookup call.
    #[serde(rename = "avasthaInfo", skip_serializing_if = "Option::is_none")]
    pub avastha_info: Option<BirthChartResponseMetaAdditionalPropertyAvasthaInfo>,
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awastha: Option<BirthChartResponseMetaAdditionalPropertyAwastha>,
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deeptadi: Option<BirthChartResponseMetaAdditionalPropertyDeeptadi>,
    /// Planet (graha) name. One of 9 Navagraha (Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn, Rahu, Ketu) or Lagna (Ascendant). Used for matching transits and dasha lords to natal positions.
    pub graha: String,
    /// Bhava (house) number 1-12, counted whole-sign from the Lagna (house 1 is the Lagna rashi; Lagna itself is house 1). Present on the D1 birth chart; divisional charts omit it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub house: Option<i64>,
    /// True if the planet is in retrograde motion (appears to move backward through the zodiac). Retrograde planets carry intensified or internalized significations in Vedic interpretation.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub jagradadi: Option<BirthChartResponseMetaAdditionalPropertyJagradadi>,
    /// Sidereal longitude in degrees (0-360) using Lahiri ayanamsa. Precise position used for aspect calculations, divisional chart mapping, and transit analysis.
    pub longitude: f64,
    /// Nakshatra (lunar mansion) data for this planet. Nakshatras are the 27-fold division of the zodiac central to Vedic timing and compatibility systems.
    pub nakshatra: BirthChartResponseMetaAdditionalPropertyNakshatra,
    /// Zodiac sign (rashi) the planet occupies in the birth chart. One of 12 Vedic rashis from Aries (Mesha) to Pisces (Meena).
    pub rashi: String,
}
/// Nakshatra (lunar mansion) data for this planet. Nakshatras are the 27-fold division of the zodiac central to Vedic timing and compatibility systems.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseMetaAdditionalPropertyNakshatra {
    /// Nakshatra sequence number (1-27) in zodiac order starting from Ashwini. Used for Tara Bala compatibility and dasha calculations.
    pub key: f64,
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    pub lord: BirthChartResponseMetaAdditionalPropertyNakshatraLord,
    /// Nakshatra (lunar mansion) the planet occupies. One of 27 Vedic nakshatras spanning 13 degrees 20 minutes each. Determines dasha lord and behavioral qualities.
    pub name: String,
    /// Nakshatra pada (quarter, 1-4). Each nakshatra divides into 4 padas of 3 degrees 20 minutes. Pada determines Navamsa sign and refines personality traits.
    pub pada: f64,
}
string_enum! {
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    BirthChartResponseMetaAdditionalPropertyNakshatraLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    BirthChartResponseMetaAdditionalPropertyJagradadi {
        Jagrat = "Jagrat",
        Swapna = "Swapna",
        Sushupti = "Sushupti",
    }
}
string_enum! {
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    BirthChartResponseMetaAdditionalPropertyDeeptadi {
        Dipta = "Dipta",
        Svastha = "Svastha",
        Pramudita = "Pramudita",
        Shanta = "Shanta",
        Dina = "Dina",
        Duhkhita = "Duhkhita",
        Vikala = "Vikala",
        Khala = "Khala",
        Kopa = "Kopa",
    }
}
string_enum! {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    BirthChartResponseMetaAdditionalPropertyAwastha {
        Bala = "Bala",
        Kumara = "Kumara",
        Yuva = "Yuva",
        Vriddha = "Vriddha",
        Mrita = "Mrita",
    }
}
/// Localized readings for this graha avastha states, present only when avasthaInfo true was sent. Each key mirrors the state field of the same name and carries a short meaning plus a one-sentence classical interpretation, so a client can label Yuva or Swapna without a second lookup call.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseMetaAdditionalPropertyAvasthaInfo {
    /// The `awastha` field.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awastha: Option<BirthChartResponseMetaAdditionalPropertyAvasthaInfoAwastha>,
    /// The `deeptadi` field.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deeptadi: Option<BirthChartResponseMetaAdditionalPropertyAvasthaInfoDeeptadi>,
    /// The `jagradadi` field.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub jagradadi: Option<BirthChartResponseMetaAdditionalPropertyAvasthaInfoJagradadi>,
}
/// The `jagradadi` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseMetaAdditionalPropertyAvasthaInfoJagradadi {
    /// Single-sentence classical reading of what the state does to the graha results, sourced from BPHS ch. 45, Saravali ch. 5 and Phaladeepika ch. 9. Localized by the lang query parameter.
    pub interpretation: String,
    /// One or two word gloss of the state, suitable for a table cell beside the graha.
    pub meaning: String,
}
/// The `deeptadi` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseMetaAdditionalPropertyAvasthaInfoDeeptadi {
    /// Single-sentence classical reading of what the state does to the graha results, sourced from BPHS ch. 45, Saravali ch. 5 and Phaladeepika ch. 9. Localized by the lang query parameter.
    pub interpretation: String,
    /// One or two word gloss of the state, suitable for a table cell beside the graha.
    pub meaning: String,
}
/// The `awastha` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseMetaAdditionalPropertyAvasthaInfoAwastha {
    /// Single-sentence classical reading of what the state does to the graha results, sourced from BPHS ch. 45, Saravali ch. 5 and Phaladeepika ch. 9. Localized by the lang query parameter.
    pub interpretation: String,
    /// One or two word gloss of the state, suitable for a table cell beside the graha.
    pub meaning: String,
}
/// The `libra` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseLibra {
    /// Zodiac sign name in lowercase. Always equals the key of the block it sits in, so the aries block carries "aries" and the pisces block carries "pisces".
    pub rashi: String,
    /// Planets placed in this zodiac sign.
    pub signs: Vec<BirthChartResponseLibraSignsItem>,
}
/// One entry of `signs`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseLibraSignsItem {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awastha: Option<BirthChartResponseLibraSignsItemAwastha>,
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deeptadi: Option<BirthChartResponseLibraSignsItemDeeptadi>,
    /// Planet (graha) placed in this sign.
    pub graha: String,
    /// Bhava (house) number 1-12, counted whole-sign from the Lagna (house 1 is the Lagna rashi). Present on the D1 birth chart; divisional charts (navamsa, varga) omit it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub house: Option<i64>,
    /// True if planet is in retrograde motion (appears to move backward). Retrograde planets have altered significations.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub jagradadi: Option<BirthChartResponseLibraSignsItemJagradadi>,
    /// Sidereal longitude in degrees (0-360) using Lahiri ayanamsa.
    pub longitude: f64,
    /// The `nakshatra` field.
    pub nakshatra: BirthChartResponseLibraSignsItemNakshatra,
}
/// The `nakshatra` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseLibraSignsItemNakshatra {
    /// Nakshatra index (1-27) in the zodiac sequence starting from Ashwini.
    pub key: f64,
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    pub lord: BirthChartResponseLibraSignsItemNakshatraLord,
    /// Nakshatra (lunar mansion, 1 of 27) the planet occupies.
    pub name: String,
    /// Nakshatra pada (quarter, 1-4). Each nakshatra has 4 padas of 3 degrees 20 each.
    pub pada: f64,
}
string_enum! {
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    BirthChartResponseLibraSignsItemNakshatraLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    BirthChartResponseLibraSignsItemJagradadi {
        Jagrat = "Jagrat",
        Swapna = "Swapna",
        Sushupti = "Sushupti",
    }
}
string_enum! {
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    BirthChartResponseLibraSignsItemDeeptadi {
        Dipta = "Dipta",
        Svastha = "Svastha",
        Pramudita = "Pramudita",
        Shanta = "Shanta",
        Dina = "Dina",
        Duhkhita = "Duhkhita",
        Vikala = "Vikala",
        Khala = "Khala",
        Kopa = "Kopa",
    }
}
string_enum! {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    BirthChartResponseLibraSignsItemAwastha {
        Bala = "Bala",
        Kumara = "Kumara",
        Yuva = "Yuva",
        Vriddha = "Vriddha",
        Mrita = "Mrita",
    }
}
/// The `leo` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseLeo {
    /// Zodiac sign name in lowercase. Always equals the key of the block it sits in, so the aries block carries "aries" and the pisces block carries "pisces".
    pub rashi: String,
    /// Planets placed in this zodiac sign.
    pub signs: Vec<BirthChartResponseLeoSignsItem>,
}
/// One entry of `signs`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseLeoSignsItem {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awastha: Option<BirthChartResponseLeoSignsItemAwastha>,
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deeptadi: Option<BirthChartResponseLeoSignsItemDeeptadi>,
    /// Planet (graha) placed in this sign.
    pub graha: String,
    /// Bhava (house) number 1-12, counted whole-sign from the Lagna (house 1 is the Lagna rashi). Present on the D1 birth chart; divisional charts (navamsa, varga) omit it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub house: Option<i64>,
    /// True if planet is in retrograde motion (appears to move backward). Retrograde planets have altered significations.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub jagradadi: Option<BirthChartResponseLeoSignsItemJagradadi>,
    /// Sidereal longitude in degrees (0-360) using Lahiri ayanamsa.
    pub longitude: f64,
    /// The `nakshatra` field.
    pub nakshatra: BirthChartResponseLeoSignsItemNakshatra,
}
/// The `nakshatra` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseLeoSignsItemNakshatra {
    /// Nakshatra index (1-27) in the zodiac sequence starting from Ashwini.
    pub key: f64,
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    pub lord: BirthChartResponseLeoSignsItemNakshatraLord,
    /// Nakshatra (lunar mansion, 1 of 27) the planet occupies.
    pub name: String,
    /// Nakshatra pada (quarter, 1-4). Each nakshatra has 4 padas of 3 degrees 20 each.
    pub pada: f64,
}
string_enum! {
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    BirthChartResponseLeoSignsItemNakshatraLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    BirthChartResponseLeoSignsItemJagradadi {
        Jagrat = "Jagrat",
        Swapna = "Swapna",
        Sushupti = "Sushupti",
    }
}
string_enum! {
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    BirthChartResponseLeoSignsItemDeeptadi {
        Dipta = "Dipta",
        Svastha = "Svastha",
        Pramudita = "Pramudita",
        Shanta = "Shanta",
        Dina = "Dina",
        Duhkhita = "Duhkhita",
        Vikala = "Vikala",
        Khala = "Khala",
        Kopa = "Kopa",
    }
}
string_enum! {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    BirthChartResponseLeoSignsItemAwastha {
        Bala = "Bala",
        Kumara = "Kumara",
        Yuva = "Yuva",
        Vriddha = "Vriddha",
        Mrita = "Mrita",
    }
}
/// Planet-in-rashi and planet-in-nakshatra interpretation summaries, keyed by planet name. Translated when a supported lang is requested.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseInterpretations {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<
        String,
        BirthChartResponseInterpretationsAdditionalProperty,
    >,
}
/// The two composed readings for one graha: what its rashi placement says, and what its nakshatra placement says. Both are full sentences ready to render.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseInterpretationsAdditionalProperty {
    /// Interpretation of the planet placement in its nakshatra.
    pub nakshatra: String,
    /// Interpretation of the planet placement in its rashi (sign).
    pub rashi: String,
}
/// One entry of `houses`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseHousesItem {
    /// Significations of the bhava (house). Present when an interpretation entry exists for this house.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Classical name of the bhava (house). Present when an interpretation entry exists for this house.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Bhava (house) number 1-12. House 1 is the Lagna (Ascendant), house 7 the partnership axis, house 10 the career axis.
    pub number: i64,
    /// Significations of the bhava as short keywords, the compact form of description. Bhava 1 covers self, body and vitality; 2 wealth and speech; 7 marriage and partnership; 10 career and status. Suited to chart labels, table cells and legends where the full classical description is too long, and identical to the houseThemes map returned by the Vimshottari dasha and KP chart routes. Localized by the lang query parameter.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub themes: Option<Vec<String>>,
}
/// The `gemini` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseGemini {
    /// Zodiac sign name in lowercase. Always equals the key of the block it sits in, so the aries block carries "aries" and the pisces block carries "pisces".
    pub rashi: String,
    /// Planets placed in this zodiac sign.
    pub signs: Vec<BirthChartResponseGeminiSignsItem>,
}
/// One entry of `signs`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseGeminiSignsItem {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awastha: Option<BirthChartResponseGeminiSignsItemAwastha>,
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deeptadi: Option<BirthChartResponseGeminiSignsItemDeeptadi>,
    /// Planet (graha) placed in this sign.
    pub graha: String,
    /// Bhava (house) number 1-12, counted whole-sign from the Lagna (house 1 is the Lagna rashi). Present on the D1 birth chart; divisional charts (navamsa, varga) omit it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub house: Option<i64>,
    /// True if planet is in retrograde motion (appears to move backward). Retrograde planets have altered significations.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub jagradadi: Option<BirthChartResponseGeminiSignsItemJagradadi>,
    /// Sidereal longitude in degrees (0-360) using Lahiri ayanamsa.
    pub longitude: f64,
    /// The `nakshatra` field.
    pub nakshatra: BirthChartResponseGeminiSignsItemNakshatra,
}
/// The `nakshatra` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseGeminiSignsItemNakshatra {
    /// Nakshatra index (1-27) in the zodiac sequence starting from Ashwini.
    pub key: f64,
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    pub lord: BirthChartResponseGeminiSignsItemNakshatraLord,
    /// Nakshatra (lunar mansion, 1 of 27) the planet occupies.
    pub name: String,
    /// Nakshatra pada (quarter, 1-4). Each nakshatra has 4 padas of 3 degrees 20 each.
    pub pada: f64,
}
string_enum! {
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    BirthChartResponseGeminiSignsItemNakshatraLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    BirthChartResponseGeminiSignsItemJagradadi {
        Jagrat = "Jagrat",
        Swapna = "Swapna",
        Sushupti = "Sushupti",
    }
}
string_enum! {
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    BirthChartResponseGeminiSignsItemDeeptadi {
        Dipta = "Dipta",
        Svastha = "Svastha",
        Pramudita = "Pramudita",
        Shanta = "Shanta",
        Dina = "Dina",
        Duhkhita = "Duhkhita",
        Vikala = "Vikala",
        Khala = "Khala",
        Kopa = "Kopa",
    }
}
string_enum! {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    BirthChartResponseGeminiSignsItemAwastha {
        Bala = "Bala",
        Kumara = "Kumara",
        Yuva = "Yuva",
        Vriddha = "Vriddha",
        Mrita = "Mrita",
    }
}
/// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseFrame {
    /// Sidereal frame this chart was cast in, echoing the ayanamsa request field. "lahiri" when the field was omitted.
    pub ayanamsa: String,
    /// Degrees actually subtracted from every tropical longitude to produce this chart, read at the birth instant. Subtract it back to recover the tropical positions, or compare it against your reference software to confirm you are in the same frame before chasing a placement difference.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
}
/// One entry of `combustion`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseCombustionItem {
    /// Angular separation from the Sun in degrees.
    #[serde(rename = "distanceFromSun")]
    pub distance_from_sun: f64,
    /// Combustion orb in degrees applied for this graha. A planet within this orb of the Sun is treated as combust, weakening its results.
    pub orb: f64,
    /// Graha that is combust (too close to the Sun, astangata).
    pub planet: String,
}
/// The `capricorn` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseCapricorn {
    /// Zodiac sign name in lowercase. Always equals the key of the block it sits in, so the aries block carries "aries" and the pisces block carries "pisces".
    pub rashi: String,
    /// Planets placed in this zodiac sign.
    pub signs: Vec<BirthChartResponseCapricornSignsItem>,
}
/// One entry of `signs`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseCapricornSignsItem {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awastha: Option<BirthChartResponseCapricornSignsItemAwastha>,
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deeptadi: Option<BirthChartResponseCapricornSignsItemDeeptadi>,
    /// Planet (graha) placed in this sign.
    pub graha: String,
    /// Bhava (house) number 1-12, counted whole-sign from the Lagna (house 1 is the Lagna rashi). Present on the D1 birth chart; divisional charts (navamsa, varga) omit it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub house: Option<i64>,
    /// True if planet is in retrograde motion (appears to move backward). Retrograde planets have altered significations.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub jagradadi: Option<BirthChartResponseCapricornSignsItemJagradadi>,
    /// Sidereal longitude in degrees (0-360) using Lahiri ayanamsa.
    pub longitude: f64,
    /// The `nakshatra` field.
    pub nakshatra: BirthChartResponseCapricornSignsItemNakshatra,
}
/// The `nakshatra` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseCapricornSignsItemNakshatra {
    /// Nakshatra index (1-27) in the zodiac sequence starting from Ashwini.
    pub key: f64,
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    pub lord: BirthChartResponseCapricornSignsItemNakshatraLord,
    /// Nakshatra (lunar mansion, 1 of 27) the planet occupies.
    pub name: String,
    /// Nakshatra pada (quarter, 1-4). Each nakshatra has 4 padas of 3 degrees 20 each.
    pub pada: f64,
}
string_enum! {
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    BirthChartResponseCapricornSignsItemNakshatraLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    BirthChartResponseCapricornSignsItemJagradadi {
        Jagrat = "Jagrat",
        Swapna = "Swapna",
        Sushupti = "Sushupti",
    }
}
string_enum! {
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    BirthChartResponseCapricornSignsItemDeeptadi {
        Dipta = "Dipta",
        Svastha = "Svastha",
        Pramudita = "Pramudita",
        Shanta = "Shanta",
        Dina = "Dina",
        Duhkhita = "Duhkhita",
        Vikala = "Vikala",
        Khala = "Khala",
        Kopa = "Kopa",
    }
}
string_enum! {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    BirthChartResponseCapricornSignsItemAwastha {
        Bala = "Bala",
        Kumara = "Kumara",
        Yuva = "Yuva",
        Vriddha = "Vriddha",
        Mrita = "Mrita",
    }
}
/// The `cancer` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseCancer {
    /// Zodiac sign name in lowercase. Always equals the key of the block it sits in, so the aries block carries "aries" and the pisces block carries "pisces".
    pub rashi: String,
    /// Planets placed in this zodiac sign.
    pub signs: Vec<BirthChartResponseCancerSignsItem>,
}
/// One entry of `signs`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseCancerSignsItem {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awastha: Option<BirthChartResponseCancerSignsItemAwastha>,
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deeptadi: Option<BirthChartResponseCancerSignsItemDeeptadi>,
    /// Planet (graha) placed in this sign.
    pub graha: String,
    /// Bhava (house) number 1-12, counted whole-sign from the Lagna (house 1 is the Lagna rashi). Present on the D1 birth chart; divisional charts (navamsa, varga) omit it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub house: Option<i64>,
    /// True if planet is in retrograde motion (appears to move backward). Retrograde planets have altered significations.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub jagradadi: Option<BirthChartResponseCancerSignsItemJagradadi>,
    /// Sidereal longitude in degrees (0-360) using Lahiri ayanamsa.
    pub longitude: f64,
    /// The `nakshatra` field.
    pub nakshatra: BirthChartResponseCancerSignsItemNakshatra,
}
/// The `nakshatra` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseCancerSignsItemNakshatra {
    /// Nakshatra index (1-27) in the zodiac sequence starting from Ashwini.
    pub key: f64,
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    pub lord: BirthChartResponseCancerSignsItemNakshatraLord,
    /// Nakshatra (lunar mansion, 1 of 27) the planet occupies.
    pub name: String,
    /// Nakshatra pada (quarter, 1-4). Each nakshatra has 4 padas of 3 degrees 20 each.
    pub pada: f64,
}
string_enum! {
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    BirthChartResponseCancerSignsItemNakshatraLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    BirthChartResponseCancerSignsItemJagradadi {
        Jagrat = "Jagrat",
        Swapna = "Swapna",
        Sushupti = "Sushupti",
    }
}
string_enum! {
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    BirthChartResponseCancerSignsItemDeeptadi {
        Dipta = "Dipta",
        Svastha = "Svastha",
        Pramudita = "Pramudita",
        Shanta = "Shanta",
        Dina = "Dina",
        Duhkhita = "Duhkhita",
        Vikala = "Vikala",
        Khala = "Khala",
        Kopa = "Kopa",
    }
}
string_enum! {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    BirthChartResponseCancerSignsItemAwastha {
        Bala = "Bala",
        Kumara = "Kumara",
        Yuva = "Yuva",
        Vriddha = "Vriddha",
        Mrita = "Mrita",
    }
}
/// The `aries` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseAries {
    /// Zodiac sign name in lowercase. Always equals the key of the block it sits in, so the aries block carries "aries" and the pisces block carries "pisces".
    pub rashi: String,
    /// Planets placed in this zodiac sign.
    pub signs: Vec<BirthChartResponseAriesSignsItem>,
}
/// One entry of `signs`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseAriesSignsItem {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awastha: Option<BirthChartResponseAriesSignsItemAwastha>,
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deeptadi: Option<BirthChartResponseAriesSignsItemDeeptadi>,
    /// Planet (graha) placed in this sign.
    pub graha: String,
    /// Bhava (house) number 1-12, counted whole-sign from the Lagna (house 1 is the Lagna rashi). Present on the D1 birth chart; divisional charts (navamsa, varga) omit it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub house: Option<i64>,
    /// True if planet is in retrograde motion (appears to move backward). Retrograde planets have altered significations.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub jagradadi: Option<BirthChartResponseAriesSignsItemJagradadi>,
    /// Sidereal longitude in degrees (0-360) using Lahiri ayanamsa.
    pub longitude: f64,
    /// The `nakshatra` field.
    pub nakshatra: BirthChartResponseAriesSignsItemNakshatra,
}
/// The `nakshatra` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseAriesSignsItemNakshatra {
    /// Nakshatra index (1-27) in the zodiac sequence starting from Ashwini.
    pub key: f64,
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    pub lord: BirthChartResponseAriesSignsItemNakshatraLord,
    /// Nakshatra (lunar mansion, 1 of 27) the planet occupies.
    pub name: String,
    /// Nakshatra pada (quarter, 1-4). Each nakshatra has 4 padas of 3 degrees 20 each.
    pub pada: f64,
}
string_enum! {
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    BirthChartResponseAriesSignsItemNakshatraLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    BirthChartResponseAriesSignsItemJagradadi {
        Jagrat = "Jagrat",
        Swapna = "Swapna",
        Sushupti = "Sushupti",
    }
}
string_enum! {
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    BirthChartResponseAriesSignsItemDeeptadi {
        Dipta = "Dipta",
        Svastha = "Svastha",
        Pramudita = "Pramudita",
        Shanta = "Shanta",
        Dina = "Dina",
        Duhkhita = "Duhkhita",
        Vikala = "Vikala",
        Khala = "Khala",
        Kopa = "Kopa",
    }
}
string_enum! {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    BirthChartResponseAriesSignsItemAwastha {
        Bala = "Bala",
        Kumara = "Kumara",
        Yuva = "Yuva",
        Vriddha = "Vriddha",
        Mrita = "Mrita",
    }
}
/// The `aquarius` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseAquarius {
    /// Zodiac sign name in lowercase. Always equals the key of the block it sits in, so the aries block carries "aries" and the pisces block carries "pisces".
    pub rashi: String,
    /// Planets placed in this zodiac sign.
    pub signs: Vec<BirthChartResponseAquariusSignsItem>,
}
/// One entry of `signs`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseAquariusSignsItem {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub awastha: Option<BirthChartResponseAquariusSignsItemAwastha>,
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deeptadi: Option<BirthChartResponseAquariusSignsItemDeeptadi>,
    /// Planet (graha) placed in this sign.
    pub graha: String,
    /// Bhava (house) number 1-12, counted whole-sign from the Lagna (house 1 is the Lagna rashi). Present on the D1 birth chart; divisional charts (navamsa, varga) omit it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub house: Option<i64>,
    /// True if planet is in retrograde motion (appears to move backward). Retrograde planets have altered significations.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub jagradadi: Option<BirthChartResponseAquariusSignsItemJagradadi>,
    /// Sidereal longitude in degrees (0-360) using Lahiri ayanamsa.
    pub longitude: f64,
    /// The `nakshatra` field.
    pub nakshatra: BirthChartResponseAquariusSignsItemNakshatra,
}
/// The `nakshatra` value.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartResponseAquariusSignsItemNakshatra {
    /// Nakshatra index (1-27) in the zodiac sequence starting from Ashwini.
    pub key: f64,
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    pub lord: BirthChartResponseAquariusSignsItemNakshatraLord,
    /// Nakshatra (lunar mansion, 1 of 27) the planet occupies.
    pub name: String,
    /// Nakshatra pada (quarter, 1-4). Each nakshatra has 4 padas of 3 degrees 20 each.
    pub pada: f64,
}
string_enum! {
    /// Vimshottari ruling planet of this nakshatra. One of the nine grahas (Ketu, Venus, Sun, Moon, Mars, Rahu, Jupiter, Saturn, Mercury). Drives the dasha sequence and the nakshatra qualities.
    BirthChartResponseAquariusSignsItemNakshatraLord {
        Ketu = "Ketu",
        Venus = "Venus",
        Sun = "Sun",
        Moon = "Moon",
        Mars = "Mars",
        Rahu = "Rahu",
        Jupiter = "Jupiter",
        Saturn = "Saturn",
        Mercury = "Mercury",
    }
}
string_enum! {
    /// Jagradadi avastha, the waking state of the graha set by its sign dignity: Jagrat (awake, own sign or exaltation, full results), Swapna (dreaming, a friendly or neutral sign, medium results), Sushupti (sleeping, an enemy sign or debilitation, no results). Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna own no sign and are omitted.
    BirthChartResponseAquariusSignsItemJagradadi {
        Jagrat = "Jagrat",
        Swapna = "Swapna",
        Sushupti = "Sushupti",
    }
}
string_enum! {
    /// Deeptadi avastha, the dispositional state of the graha, one of nine: Dipta (exalted, blazing), Svastha (own sign, healthy), Pramudita (great friend sign, delighted), Shanta (friendly sign, at peace), Dina (neutral sign, helpless), Duhkhita (enemy sign, sorrowful), Khala (great enemy sign, harsh), Vikala (joined by a natural malefic, disabled), Kopa (eclipsed by the Sun, enraged). Where more than one applies the more severe is returned, so combustion outranks a malefic conjunction, which outranks the sign reading. Present for the seven classical grahas on the D1 chart; Rahu, Ketu and the Lagna are omitted.
    BirthChartResponseAquariusSignsItemDeeptadi {
        Dipta = "Dipta",
        Svastha = "Svastha",
        Pramudita = "Pramudita",
        Shanta = "Shanta",
        Dina = "Dina",
        Duhkhita = "Duhkhita",
        Vikala = "Vikala",
        Khala = "Khala",
        Kopa = "Kopa",
    }
}
string_enum! {
    /// Baladi avastha, the planetary age-state set by the graha degree within its sign: Bala (infant), Kumara (child), Yuva (adult, strongest results), Vriddha (old), Mrita (dead, weakest). Bands run forward in odd signs and reversed in even signs. D1 birth chart only.
    BirthChartResponseAquariusSignsItemAwastha {
        Bala = "Bala",
        Kumara = "Kumara",
        Yuva = "Yuva",
        Vriddha = "Vriddha",
        Mrita = "Mrita",
    }
}
/// Request body of `generateBirthChart`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BirthChartRequest {
    /// Set true to include a localized meaning and one-sentence classical interpretation beside each graha avastha state, under avasthaInfo on that graha in meta. Defaults to false, so an existing integration is byte-identical until it opts in. Saves a second call to GET /avasthas and the client-side join that would otherwise be needed to turn Yuva or Swapna into readable text.
    #[serde(rename = "avasthaInfo", skip_serializing_if = "Option::is_none")]
    pub avastha_info: Option<bool>,
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<BirthChartRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Set true to also return Uranus, Neptune and Pluto, under the Sanskrit names Arun, Varun and Yam that Indian software prints for them. They arrive in a separate modernPlanets array, NOT inside meta, because classical Jyotish is defined over nine grahas: the moderns rule no sign, so they have no dignity, avastha, combustion or aspect strength and it would be fabrication to report one. Each carries longitude, rashi, degree in sign, nakshatra with pada and lord, and retrograde status. Defaults to false, so an existing integration is byte-identical until it opts in.
    #[serde(rename = "modernPlanets", skip_serializing_if = "Option::is_none")]
    pub modern_planets: Option<bool>,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<BirthChartRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum BirthChartRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    BirthChartRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Complete Bhava Bala (house strength) analysis per Brihat Parashara Hora Shastra, with a localized house-meaning legend.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BhavaBalaResponse {
    /// Bhava Bala for all twelve houses in order, house 1 first. Each entry carries its own components so a client can explain a score rather than just display it.
    pub bhavas: Vec<BhavaBalaResponseBhavasItem>,
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    pub focus: BhavaBalaResponseFocus,
    /// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
    pub frame: BhavaBalaResponseFrame,
    /// House frame the bhavas were built on. Always sripati: Bhava Bala is defined on unequal bhava madhyas, not on whole signs.
    #[serde(rename = "houseSystem")]
    pub house_system: String,
    /// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
    #[serde(rename = "houseThemes")]
    pub house_themes: BhavaBalaResponseHouseThemes,
}
/// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BhavaBalaResponseHouseThemes {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, Vec<String>>,
}
/// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BhavaBalaResponseFrame {
    /// Sidereal frame this chart was cast in, echoing the ayanamsa request field. "lahiri" when the field was omitted.
    pub ayanamsa: String,
    /// Degrees actually subtracted from every tropical longitude to produce this chart, read at the birth instant. Subtract it back to recover the tropical positions, or compare it against your reference software to confirm you are in the same frame before chasing a placement difference.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
}
string_enum! {
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    BhavaBalaResponseFocus {
        General = "general",
        Finance = "finance",
    }
}
/// Bhava Bala for a single house, with the three classical components, the madhya it was measured at, and its rank.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BhavaBalaResponseBhavasItem {
    /// Bhavadhipati Bala in virupas: the total Shadbala of the house lord, carried across unchanged. The dominant term of the three, typically 250 to 650. Two bhavas ruled by the same graha therefore share this value exactly.
    #[serde(rename = "bhavadhipatiBala")]
    pub bhavadhipati_bala: f64,
    /// Bhava Digbala (directional strength) in virupas, 0 to 60 in steps of 10. Each rashi class is strongest in one cardinal bhava (human signs at the Lagna, quadruped at the 10th, watery at the 4th, Scorpio at the 7th) and loses 10 virupas per bhava of separation, reaching 0 at the seventh from it.
    #[serde(rename = "digBala")]
    pub dig_bala: f64,
    /// Bhava Drishti Bala (aspectual strength) in virupas, computed on the bhava madhya exactly as Graha Drik Bala is computed on a graha. Benefic aspects add and malefic aspects subtract, so this term is often negative.
    #[serde(rename = "drishtiBala")]
    pub drishti_bala: f64,
    /// Bhava (house) number 1 to 12, counted from the Lagna. House 1 is the Ascendant bhava, house 10 the career bhava, house 7 the partnership bhava.
    pub house: f64,
    /// Bhavadhipati (house lord), the ruler of the sign holding the madhya. Its Shadbala is what this bhava inherits, so a house ruled by a strong graha starts strong.
    pub lord: String,
    /// Bhava madhya (mid-cusp) longitude in degrees, sidereal Lahiri. The point every strength component below is measured at. Bhavas 1, 4, 7 and 10 sit on the Ascendant, IC, Descendant and Midheaven; the rest trisect the quadrants between them.
    pub madhya: f64,
    /// Strength rank among the twelve bhavas, 1 = strongest. Ranked on totalVirupas, so it never disagrees with the published totals.
    pub rank: f64,
    /// Zodiac sign holding this bhavas madhya (mid-cusp). Under the Sripati house system the bhavas are unequal, so this is NOT always the nth sign from the Lagna, and two bhavas can share a sign while another sign holds none.
    pub rashi: String,
    /// Total Bhava Bala in rupas (totalVirupas / 60). 1 rupa equals 60 virupas. Rupas are the conventional unit in classical tables.
    #[serde(rename = "totalRupas")]
    pub total_rupas: f64,
    /// Total Bhava Bala in virupas, the sum of the three components above. Use it to compare houses within one chart: the strongest bhavas are the life areas that unfold with least resistance.
    #[serde(rename = "totalVirupas")]
    pub total_virupas: f64,
}
/// Request body of `calculateBhavaBala`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BhavaBalaRequest {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<BhavaBalaRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<BhavaBalaRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum BhavaBalaRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    BhavaBalaRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Bhav Chalit (Chalit Kundli): every graha placed by unequal Sripati bhava, with the whole-sign placement beside it for comparison.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BhavChalitResponse {
    /// Sidereal Lahiri Ascendant in degrees. The madhya of bhava 1.
    pub ascendant: f64,
    /// The twelve Sripati bhavas in order with their boundaries and occupants.
    pub bhavas: Vec<BhavChalitResponseBhavasItem>,
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    pub focus: BhavChalitResponseFocus,
    /// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
    pub frame: BhavChalitResponseFrame,
    /// All nine grahas with both their Chalit bhava and their whole-sign Rashi house, plus a moved flag.
    pub grahas: Vec<BhavChalitResponseGrahasItem>,
    /// House frame used to build the bhavas. Always sripati for the Chalit chart.
    #[serde(rename = "houseSystem")]
    pub house_system: String,
    /// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
    #[serde(rename = "houseThemes")]
    pub house_themes: BhavChalitResponseHouseThemes,
    /// Sidereal Lahiri Midheaven in degrees. The madhya of bhava 10.
    pub midheaven: f64,
    /// How many of the nine grahas change house between the Rashi chart and the Chalit chart. Zero is a perfectly normal result and means the two charts agree for this nativity.
    #[serde(rename = "movedCount")]
    pub moved_count: f64,
}
/// Significations of each of the twelve bhavas (houses), keyed by house number 1 to 12, as short keywords. Bhava 1 is the Lagna (self, body, vitality), 2 wealth and speech, 4 home and mother, 7 marriage and partnership, 10 career and status, 11 gains. Use it to label the house numbers returned elsewhere in the response: a Vimshottari dasha period signifying houses 2, 7 and 8, or a KP significator carrying houses 11 and 6, becomes readable text without a separate lookup call. Returned once per response rather than repeated per period, and localized by the lang query parameter alongside every other interpretation field.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BhavChalitResponseHouseThemes {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, Vec<String>>,
}
/// One graha placed in both frames, with a flag marking the placements that move.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BhavChalitResponseGrahasItem {
    /// Bhava the graha falls in under the unequal Sripati cusps. This is the Bhav Chalit placement and the reason the chart exists.
    pub bhava: f64,
    /// Graha name. All nine are placed, the seven classical grahas plus the lunar nodes Rahu and Ketu.
    pub graha: String,
    /// Sidereal Lahiri longitude in degrees.
    pub longitude: f64,
    /// True when bhava and rashiHouse disagree, i.e. the graha changes house between the Rashi chart and the Chalit chart. These are the placements a practitioner opens this chart to check.
    pub moved: bool,
    /// Zodiac sign the graha occupies. Identical to the Rashi (D1) chart.
    pub rashi: String,
    /// House the same graha occupies in the whole-sign Rashi chart, counted from the Lagna sign. Returned alongside bhava so the difference is visible without a second request.
    #[serde(rename = "rashiHouse")]
    pub rashi_house: f64,
}
/// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BhavChalitResponseFrame {
    /// Sidereal frame this chart was cast in, echoing the ayanamsa request field. "lahiri" when the field was omitted.
    pub ayanamsa: String,
    /// Degrees actually subtracted from every tropical longitude to produce this chart, read at the birth instant. Subtract it back to recover the tropical positions, or compare it against your reference software to confirm you are in the same frame before chasing a placement difference.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
}
string_enum! {
    /// Which signification vocabulary produced the houseThemes keywords in this response, echoing the focus query parameter. Always present, and "general" when the parameter was omitted. Read it to label a rendered house legend, or to tell two cached responses apart when only one asked for the finance lens.
    BhavChalitResponseFocus {
        General = "general",
        Finance = "finance",
    }
}
/// One Sripati bhava with its boundaries and occupants.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BhavChalitResponseBhavasItem {
    /// Bhava sandhi closing this bhava. Identical to the next bhavas start, so the twelve bhavas tile the zodiac with no gap.
    pub end: f64,
    /// Grahas falling inside this bhava. Empty when the bhava is unoccupied.
    pub grahas: Vec<String>,
    /// Bhava number 1 to 12.
    pub house: f64,
    /// Bhava madhya (mid-cusp) in degrees. Bhavas 1, 4, 7 and 10 sit exactly on the Ascendant, IC, Descendant and Midheaven; the other eight trisect the quadrant arcs between them.
    pub madhya: f64,
    /// Sign holding the madhya. Because bhavas are unequal, two bhavas can share a sign while another sign holds no madhya at all.
    pub rashi: String,
    /// Width of the bhava in degrees. Rarely 30: the Ascendant and Midheaven are only 90 degrees apart by coincidence of latitude and epoch, so quadrants stretch and squeeze and the bhavas with them.
    pub span: f64,
    /// Bhava sandhi (junction) opening this bhava, in degrees. The midpoint between this madhya and the previous one. A graha exactly on a sandhi belongs to the bhava it opens.
    pub start: f64,
}
/// Request body of `calculateBhavChalit`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BhavChalitRequest {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<BhavChalitRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<BhavChalitRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum BhavChalitRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    BhavChalitRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// One entry of `cards`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct BasicCard {
    /// Whether this card belongs to the Major Arcana (22 trump cards representing major life themes) or Minor Arcana (56 suit cards for daily situations).
    pub arcana: BasicCardArcana,
    /// Unique card identifier in kebab-case, with no leading article on Major Arcana (e.g. fool, star, ace-of-cups, queen-of-swords). This is the canonical form, whatever spelling was requested.
    pub id: String,
    /// URL to the tarot card artwork image in the Rider-Waite-Smith style.
    #[serde(rename = "imageUrl")]
    pub image_url: String,
    /// Display name of the tarot card as it appears in the Rider-Waite-Smith tradition.
    pub name: String,
    /// Card number within its arcana. Major Arcana: 0 (Fool) through 21 (World). Minor Arcana: 1 (Ace) through 14 (King).
    pub number: f64,
    /// Suit of the card (Minor Arcana only). Cups=emotions, Wands=creativity, Swords=intellect, Pentacles=material. Null for Major Arcana cards.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub suit: Option<BasicCardSuit>,
}
string_enum! {
    /// Suit of the card (Minor Arcana only). Cups=emotions, Wands=creativity, Swords=intellect, Pentacles=material. Null for Major Arcana cards.
    BasicCardSuit {
        Cups = "cups",
        Wands = "wands",
        Swords = "swords",
        Pentacles = "pentacles",
    }
}
string_enum! {
    /// Whether this card belongs to the Major Arcana (22 trump cards representing major life themes) or Minor Arcana (56 suit cards for daily situations).
    BasicCardArcana {
        Major = "major",
        Minor = "minor",
    }
}
/// Request body of `getRitucharya`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AyurvedaRitucharyaRequest {
    /// The date to resolve, in YYYY-MM-DD format. The season is read at midday UTC on this date, because a season boundary is an instant and a calendar day has to be reduced to one; on a day that carries a boundary, the half the midday falls in is the answer. Within about two months of either end of the supported span, a date whose season opens or closes outside that span answers 400.
    pub date: String,
    /// Which half of the world the season names are stated for. Defaults to "northern", which is the half the primary text describes. It is NEVER inferred from a latitude: a silent flip would change the answer without the caller asking, and no classical text handles the southern case at all. Passing "southern" rotates the six season names by three places, following a modern almanac rather than a verse, and the response says so and states what was not rotated with them.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub hemisphere: Option<AyurvedaRitucharyaRequestHemisphere>,
    /// Which zodiac the solar-month boundaries are measured in. "sayana" is the tropical reading, which is what published almanacs use for seasons and is the default. "nirayana" is the sidereal reading in the Lahiri frame, which runs about 24 days later. The gap is the size of the ayanamsa, so near a boundary the two answer with different seasons for the same date, which is why the value is echoed in every response.
    #[serde(rename = "rituZodiac", skip_serializing_if = "Option::is_none")]
    pub ritu_zodiac: Option<AyurvedaRitucharyaRequestRituZodiac>,
    /// Which six-season division the year is cut into. "sutrasthana-6" is the standard set of sisira, vasanta, grisma, varsa, sarad and hemanta, and is the default. "vimana-8" is the alternate division in which three seasons of extreme character alternate with three of moderate character and pravrt, the season of the first rains, replaces sisira. The alternate is not a relabelling: five of the six boundaries move, and because its verse gives no solar-month boundaries the month allocation is a RoxyAPI convention, stated in the response.
    #[serde(rename = "ritucharyaScheme", skip_serializing_if = "Option::is_none")]
    pub ritucharya_scheme: Option<AyurvedaRitucharyaRequestRitucharyaScheme>,
}
string_enum! {
    /// Which six-season division the year is cut into. "sutrasthana-6" is the standard set of sisira, vasanta, grisma, varsa, sarad and hemanta, and is the default. "vimana-8" is the alternate division in which three seasons of extreme character alternate with three of moderate character and pravrt, the season of the first rains, replaces sisira. The alternate is not a relabelling: five of the six boundaries move, and because its verse gives no solar-month boundaries the month allocation is a RoxyAPI convention, stated in the response.
    AyurvedaRitucharyaRequestRitucharyaScheme {
        Sutrasthana6 = "sutrasthana-6",
        Vimana8 = "vimana-8",
    }
}
string_enum! {
    /// Which zodiac the solar-month boundaries are measured in. "sayana" is the tropical reading, which is what published almanacs use for seasons and is the default. "nirayana" is the sidereal reading in the Lahiri frame, which runs about 24 days later. The gap is the size of the ayanamsa, so near a boundary the two answer with different seasons for the same date, which is why the value is echoed in every response.
    AyurvedaRitucharyaRequestRituZodiac {
        Sayana = "sayana",
        Nirayana = "nirayana",
    }
}
string_enum! {
    /// Which half of the world the season names are stated for. Defaults to "northern", which is the half the primary text describes. It is NEVER inferred from a latitude: a silent flip would change the answer without the caller asking, and no classical text handles the southern case at all. Passing "southern" rotates the six season names by three places, following a modern almanac rather than a verse, and the response says so and states what was not rotated with them.
    AyurvedaRitucharyaRequestHemisphere {
        Northern = "northern",
        Southern = "southern",
    }
}
/// Request body of `getDinacharyaSchedule`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AyurvedaDinacharyaRequest {
    /// The local calendar date, in YYYY-MM-DD format. Sunrise and sunset are computed for this date at the given place, and the whole routine follows from them, so the answer changes through the year at any latitude away from the equator.
    pub date: String,
    /// How the six dosha periods are cut. "sunrise-anchored" divides the actual day and the actual night at this place into thirds, which is the division the frame chapter states, and is the default. "clock-hours" is the modern grid of six four-hour blocks from six in the morning; no classical text assigns clock hours, and the grid is only exact at an equinox near the equator. Both sets are returned whichever is chosen, so a caller can show one and reconcile against the other.
    #[serde(rename = "doshaClock", skip_serializing_if = "Option::is_none")]
    pub dosha_clock: Option<AyurvedaDinacharyaRequestDoshaClock>,
    /// Latitude in decimal degrees. It sets how long the day and the night actually are, which is the whole difference between this and a printed timetable: at 51 north in June the day runs about sixteen and a half hours and its thirds are five and a half hours each.
    pub latitude: f64,
    /// Longitude in decimal degrees. It sets the clock time of sunrise at this place.
    pub longitude: f64,
    /// Timezone as an IANA name such as "Europe/London", or as decimal hours from UTC such as 5.5. An IANA name is resolved to the offset in force on the requested date, and on the clock-hour grid at the local hour each block opens, so on a daylight-saving change every block keeps its printed hour and one that falls in the skipped hour moves forward past it. It decides which local day is meant and, on the clock-hour grid, where the blocks fall. Defaults to 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<AyurvedaDinacharyaRequestTimezone>,
}
/// Timezone as an IANA name such as "Europe/London", or as decimal hours from UTC such as 5.5. An IANA name is resolved to the offset in force on the requested date, and on the clock-hour grid at the local hour each block opens, so on a daylight-saving change every block keeps its printed hour and one that falls in the skipped hour moves forward past it. It decides which local day is meant and, on the clock-hour grid, where the blocks fall. Defaults to 0.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum AyurvedaDinacharyaRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// How the six dosha periods are cut. "sunrise-anchored" divides the actual day and the actual night at this place into thirds, which is the division the frame chapter states, and is the default. "clock-hours" is the modern grid of six four-hour blocks from six in the morning; no classical text assigns clock hours, and the grid is only exact at an equinox near the equator. Both sets are returned whichever is chosen, so a caller can show one and reconcile against the other.
    AyurvedaDinacharyaRequestDoshaClock {
        SunriseAnchored = "sunrise-anchored",
        ClockHours = "clock-hours",
    }
}
/// Request body of `calculateAyurvedicConstitution`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AyurvedaConstitutionRequest {
    /// Sidereal frame the chart is cast in. "lahiri" is the traditional Vedic standard used by most software and is the default. "raman" sits about 1.45 degrees below it. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue. The frame rotates the whole zodiac, so a graha within 1.45 degrees of a boundary can change rashi when you switch, which moves both sign factors of the reading.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<AyurvedaConstitutionRequestAyanamsa>,
    /// Custom sidereal frame value in degrees. Required when ayanamsa is "custom" and ignored otherwise. Use it to reconcile exactly against a specific reference program.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. It sets the sidereal positions the whole reading is built from, so an approximate date gives an approximate constitution.
    pub date: String,
    /// Birth latitude in decimal degrees. It sets the local sidereal time behind the rising sign, and it feeds the strength of each graha through the sunrise at that place.
    pub latitude: f64,
    /// Birth longitude in decimal degrees. It sets the local sidereal time behind the rising sign, together with the latitude.
    pub longitude: f64,
    /// Which classical sign table the rising sign and the Moon sign are read through. "satyacharya" is the twelve-sign extract appended to Brihat Jataka 18.20, carried in two independent public-domain translations that agree on all twelve rows, and is the default. "bphs" is the Brihat Parasara Hora Sastra rule by elemental triplicity. The two agree exactly on three signs of twelve, overlap in part on seven, and share no humour at all on Scorpio or Sagittarius, so the choice can change the reading outright and is echoed in the response.
    #[serde(rename = "signDoshaScheme", skip_serializing_if = "Option::is_none")]
    pub sign_dosha_scheme: Option<AyurvedaConstitutionRequestSignDoshaScheme>,
    /// Birth time in 24-hour HH:MM:SS format. The rising sign turns roughly every two hours and carries the heaviest weight of the three factors, so time is the input a reading is most sensitive to.
    pub time: String,
    /// Timezone as an IANA name such as "Asia/Kolkata", or as decimal hours from UTC such as 5.5. An IANA name is resolved to the offset in force on the birth date, so a summer-time birth is placed correctly. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<AyurvedaConstitutionRequestTimezone>,
}
/// Timezone as an IANA name such as "Asia/Kolkata", or as decimal hours from UTC such as 5.5. An IANA name is resolved to the offset in force on the birth date, so a summer-time birth is placed correctly. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum AyurvedaConstitutionRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Which classical sign table the rising sign and the Moon sign are read through. "satyacharya" is the twelve-sign extract appended to Brihat Jataka 18.20, carried in two independent public-domain translations that agree on all twelve rows, and is the default. "bphs" is the Brihat Parasara Hora Sastra rule by elemental triplicity. The two agree exactly on three signs of twelve, overlap in part on seven, and share no humour at all on Scorpio or Sagittarius, so the choice can change the reading outright and is echoed in the response.
    AyurvedaConstitutionRequestSignDoshaScheme {
        Satyacharya = "satyacharya",
        Bphs = "bphs",
    }
}
string_enum! {
    /// Sidereal frame the chart is cast in. "lahiri" is the traditional Vedic standard used by most software and is the default. "raman" sits about 1.45 degrees below it. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue. The frame rotates the whole zodiac, so a graha within 1.45 degrees of a boundary can change rashi when you switch, which moves both sign factors of the reading.
    AyurvedaConstitutionRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Response body of `generateAstrocartography`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AstrocartographyResponse {
    /// Echo of the birth moment and place used to compute every planetary line.
    #[serde(rename = "birthDetails")]
    pub birth_details: AstrocartographyResponseBirthDetails,
    /// One entry per body, each carrying its Midheaven, Imum Coeli, Ascendant, and Descendant planetary lines for relocation mapping.
    pub lines: Vec<AstrocartographyResponseLinesItem>,
    /// Short overview of the astrocartography map for previews and report intros.
    pub summary: String,
}
/// One entry of `lines`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AstrocartographyResponseLinesItem {
    /// Ascendant (rising) line. Places where the body was on the eastern horizon, tied to identity, vitality, and self-expression.
    pub ascendant: AstrocartographyResponseLinesItemAscendant,
    /// Equatorial declination of the body in degrees (-90 to 90), which sets how far the rising and setting lines curve.
    pub declination: f64,
    /// Descendant (setting) line. Places where the body was on the western horizon, tied to relationships and partnerships.
    pub descendant: AstrocartographyResponseLinesItemDescendant,
    /// Imum Coeli (IC) line, opposite the MC. Places where the body was anti-culminating, tied to home, family, and inner foundations.
    pub ic: AstrocartographyResponseLinesItemIc,
    /// Midheaven (MC) line. Places along this meridian where the body was culminating overhead, tied to public life, career, and reputation.
    pub mc: AstrocartographyResponseLinesItemMc,
    /// Celestial body this set of planetary lines belongs to. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use planetLocalized for anything a reader sees.
    pub planet: String,
    /// Body name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "planetLocalized", skip_serializing_if = "Option::is_none")]
    pub planet_localized: Option<String>,
    /// Equatorial right ascension of the body in degrees (0 to 360), the basis for every line.
    #[serde(rename = "rightAscension")]
    pub right_ascension: f64,
    /// Unicode astronomical symbol for this body.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub symbol: Option<String>,
}
/// Midheaven (MC) line. Places along this meridian where the body was culminating overhead, tied to public life, career, and reputation.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AstrocartographyResponseLinesItemMc {
    /// Plain language meaning of this Midheaven planetary line for relocation, suitable for chart reports and AI agents.
    pub interpretation: String,
    /// Constant geographic longitude of this vertical meridian line in decimal degrees. The body culminates (MC) along it, so plot it as a straight north to south line.
    pub longitude: f64,
}
/// Imum Coeli (IC) line, opposite the MC. Places where the body was anti-culminating, tied to home, family, and inner foundations.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AstrocartographyResponseLinesItemIc {
    /// Plain language meaning of this Imum Coeli planetary line for relocation, suitable for chart reports and AI agents.
    pub interpretation: String,
    /// Constant geographic longitude of this vertical meridian line in decimal degrees. The body anti-culminates (IC) along it, so plot it as a straight north to south line.
    pub longitude: f64,
}
/// Descendant (setting) line. Places where the body was on the western horizon, tied to relationships and partnerships.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AstrocartographyResponseLinesItemDescendant {
    /// Absolute latitude in degrees beyond which the body never crosses the horizon, so the line has no points past it. Null when the line spans the full sampled range.
    #[serde(rename = "circumpolarBeyond")]
    pub circumpolar_beyond: Option<f64>,
    /// Plain language meaning of this setting (Descendant) planetary line for relocation, suitable for chart reports and AI agents.
    pub interpretation: String,
    /// Sampled geographic points tracing this setting line from 70 South to 70 North. Join them in latitude order to draw the curved planetary line on a world map.
    pub points: Vec<AstrocartographyResponseLinesItemDescendantPointsItem>,
}
/// One entry of `points`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AstrocartographyResponseLinesItemDescendantPointsItem {
    /// Geographic latitude of this sampled point in decimal degrees.
    pub latitude: f64,
    /// Geographic longitude in decimal degrees where the body sits exactly on the western (setting) horizon at this latitude.
    pub longitude: f64,
}
/// Ascendant (rising) line. Places where the body was on the eastern horizon, tied to identity, vitality, and self-expression.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AstrocartographyResponseLinesItemAscendant {
    /// Absolute latitude in degrees beyond which the body never crosses the horizon, so the line has no points past it. Null when the line spans the full sampled range.
    #[serde(rename = "circumpolarBeyond")]
    pub circumpolar_beyond: Option<f64>,
    /// Plain language meaning of this rising (Ascendant) planetary line for relocation, suitable for chart reports and AI agents.
    pub interpretation: String,
    /// Sampled geographic points tracing this rising line from 70 South to 70 North. Join them in latitude order to draw the curved planetary line on a world map.
    pub points: Vec<AstrocartographyResponseLinesItemAscendantPointsItem>,
}
/// One entry of `points`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AstrocartographyResponseLinesItemAscendantPointsItem {
    /// Geographic latitude of this sampled point in decimal degrees.
    pub latitude: f64,
    /// Geographic longitude in decimal degrees where the body sits exactly on the eastern (rising) horizon at this latitude.
    pub longitude: f64,
}
/// Echo of the birth moment and place used to compute every planetary line.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AstrocartographyResponseBirthDetails {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone offset from UTC in decimal hours, resolved for the birth date. Examples: New York = -5 in winter and -4 in summer, London = 0, India = 5.5, Tokyo = 9.
    pub timezone: f64,
}
/// Response body of `generateAsteroids`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AsteroidsResponse {
    /// The four classical asteroid goddesses in canonical order: Ceres, Pallas, Juno, and Vesta, each with its tropical position, house, motion, and interpretation.
    pub asteroids: Vec<AsteroidsResponseAsteroidsItem>,
    /// Echo of the birth moment and place used to compute every asteroid.
    #[serde(rename = "birthDetails")]
    pub birth_details: AsteroidsResponseBirthDetails,
    /// House system actually used to place the asteroids, after any polar fallback to Whole Sign.
    #[serde(rename = "houseSystem")]
    pub house_system: AsteroidsResponseHouseSystem,
    /// Short overview of the asteroid set for previews and report intros.
    pub summary: String,
}
string_enum! {
    /// House system actually used to place the asteroids, after any polar fallback to Whole Sign.
    AsteroidsResponseHouseSystem {
        Placidus = "placidus",
        WholeSign = "whole-sign",
        Equal = "equal",
        Koch = "koch",
    }
}
/// Echo of the birth moment and place used to compute every asteroid.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AsteroidsResponseBirthDetails {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone offset from UTC in decimal hours, resolved for the birth date. Examples: New York = -5 in winter and -4 in summer, London = 0, India = 5.5, Tokyo = 9.
    pub timezone: f64,
}
/// One entry of `asteroids`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AsteroidsResponseAsteroidsItem {
    /// Degree of the asteroid within its zodiac sign (0 to 29.999).
    pub degree: f64,
    /// Natal house placement (1 to 12) from the selected house system and birth location.
    pub house: i64,
    /// Plain language meaning of this asteroid in its sign, suitable for chart reports and AI agents. Localized to the requested language.
    pub interpretation: String,
    /// Whether the asteroid appears to move backward from Earth, true when the daily speed is negative.
    #[serde(rename = "isRetrograde")]
    pub is_retrograde: bool,
    /// Ecliptic latitude in degrees, the angular distance north or south of the ecliptic plane.
    pub latitude: f64,
    /// Absolute tropical ecliptic longitude of the asteroid in degrees (0 to 360).
    pub longitude: f64,
    /// Name of the asteroid: Ceres, Pallas, Juno, or Vesta. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Asteroid name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tropical zodiac sign the asteroid falls in.
    pub sign: String,
    /// Daily motion in degrees per day. Negative values indicate retrograde motion.
    pub speed: f64,
}
/// Request body of `generateAsteroids`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AsteroidsRequest {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// House system used to assign each asteroid to a natal house. Placidus (default), Whole Sign, Equal, or Koch. Above the polar circle, quadrant systems fall back to Whole Sign and the echoed houseSystem reports the system actually used.
    #[serde(rename = "houseSystem", skip_serializing_if = "Option::is_none")]
    pub house_system: Option<AsteroidsRequestHouseSystem>,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<AsteroidsRequestNodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
    pub timezone: AsteroidsRequestTimezone,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum AsteroidsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    AsteroidsRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// House system used to assign each asteroid to a natal house. Placidus (default), Whole Sign, Equal, or Koch. Above the polar circle, quadrant systems fall back to Whole Sign and the echoed houseSystem reports the system actually used.
    AsteroidsRequestHouseSystem {
        Placidus = "placidus",
        WholeSign = "whole-sign",
        Equal = "equal",
        Koch = "koch",
    }
}
/// Response body of `calculateAspects`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AspectsResponse {
    /// All aspects found between the specified planets, with strength, orb, and interpretation.
    pub aspects: Vec<AspectsResponseAspectsItem>,
    /// Total number of aspects found after any filters applied.
    #[serde(rename = "aspectsFound")]
    pub aspects_found: f64,
    /// Date used for this aspect calculation (YYYY-MM-DD).
    pub date: String,
    /// Detected multi-planet aspect configurations (Grand Trine, Kite, T-Square, Grand Cross, Yod, Mystic Rectangle, Stellium).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub patterns: Option<Vec<AspectsResponsePatternsItem>>,
    /// Aspect summary with counts by nature and type.
    pub summary: AspectsResponseSummary,
    /// Time used for this calculation (HH:MM:SS).
    pub time: String,
    /// Timezone offset from UTC in decimal hours.
    pub timezone: f64,
}
/// Aspect summary with counts by nature and type.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AspectsResponseSummary {
    /// Aspect count grouped by type.
    #[serde(rename = "byType")]
    pub by_type: AspectsResponseSummaryByType,
    /// Count of challenging aspects (square, opposition).
    pub challenging: f64,
    /// Count of harmonious aspects (trine, sextile).
    pub harmonious: f64,
    /// Count of neutral aspects (conjunction).
    pub neutral: f64,
    /// Total aspects found.
    #[serde(rename = "totalAspects")]
    pub total_aspects: f64,
}
/// Aspect count grouped by type.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AspectsResponseSummaryByType {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, f64>,
}
/// One entry of `patterns`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AspectsResponsePatternsItem {
    /// Focal planet for Kite, T-Square, and Yod patterns. Receives the released energy of the configuration and is the recommended integration point.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub apex: Option<String>,
    /// True if the pattern is out-of-sign (one or more planets in a neighboring element or modality). Dissociate patterns are still valid but operate with weakened thematic coherence.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dissociate: Option<bool>,
    /// Dominant element when the pattern is element-coherent (Grand Trine, Kite). Reported lowercase. Absent for patterns whose meaning does not pivot on element.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub element: Option<AspectsResponsePatternsItemElement>,
    /// Concise one-line interpretation naming the participating planets and theme. Localized to the requested language via the lang query parameter (defaults to English).
    pub interpretation: String,
    /// Stable template identifier used to render the interpretation. Useful for clients that wish to swap in a custom narrative template while preserving the structured variables.
    #[serde(rename = "interpretationKey")]
    pub interpretation_key: String,
    /// Variables that were interpolated into the interpretation template. Names already resolved to the requested language where appropriate.
    #[serde(rename = "interpretationVars")]
    pub interpretation_vars: AspectsResponsePatternsItemInterpretationVars,
    /// Pattern kind identifier. GRAND_TRINE (3 trines, harmonious flow), KITE (Grand Trine with a focal outlet planet), T_SQUARE (opposition with squared apex, growth engine), GRAND_CROSS (4 planets in 2 oppositions and 4 squares, peak tension), YOD (Finger of Fate, fated adjustment), MYSTIC_RECTANGLE (oppositions softened by trines and sextiles), STELLIUM (3+ planets clustered in a sign or 10-degree arc).
    pub kind: AspectsResponsePatternsItemKind,
    /// Dominant modality for tension-based patterns (T-Square, Grand Cross). Cardinal initiates, Fixed sustains, Mutable adapts.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub modality: Option<AspectsResponsePatternsItemModality>,
    /// Human-readable name of the configuration as used in astrological literature.
    pub name: String,
    /// Participating bodies in canonical order. For Kite, T-Square, and Yod the apex planet appears first.
    pub planets: Vec<String>,
    /// Tightness score (0-100) derived from the average orb tightness across all defining aspects. Higher means closer to exact and stronger thematic expression.
    pub tightness: f64,
}
string_enum! {
    /// Dominant modality for tension-based patterns (T-Square, Grand Cross). Cardinal initiates, Fixed sustains, Mutable adapts.
    AspectsResponsePatternsItemModality {
        Cardinal = "cardinal",
        Fixed = "fixed",
        Mutable = "mutable",
    }
}
string_enum! {
    /// Pattern kind identifier. GRAND_TRINE (3 trines, harmonious flow), KITE (Grand Trine with a focal outlet planet), T_SQUARE (opposition with squared apex, growth engine), GRAND_CROSS (4 planets in 2 oppositions and 4 squares, peak tension), YOD (Finger of Fate, fated adjustment), MYSTIC_RECTANGLE (oppositions softened by trines and sextiles), STELLIUM (3+ planets clustered in a sign or 10-degree arc).
    AspectsResponsePatternsItemKind {
        GrandTrine = "GRAND_TRINE",
        Kite = "KITE",
        TSquare = "T_SQUARE",
        GrandCross = "GRAND_CROSS",
        Yod = "YOD",
        MysticRectangle = "MYSTIC_RECTANGLE",
        Stellium = "STELLIUM",
    }
}
/// Variables that were interpolated into the interpretation template. Names already resolved to the requested language where appropriate.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AspectsResponsePatternsItemInterpretationVars {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, String>,
}
string_enum! {
    /// Dominant element when the pattern is element-coherent (Grand Trine, Kite). Reported lowercase. Absent for patterns whose meaning does not pivot on element.
    AspectsResponsePatternsItemElement {
        Fire = "fire",
        Earth = "earth",
        Air = "air",
        Water = "water",
    }
}
/// One entry of `aspects`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AspectsResponseAspectsItem {
    /// Exact angle defining this aspect type in degrees.
    pub angle: f64,
    /// Aspect nature for this pair: harmonious, challenging, or neutral. Always English, whatever the lang parameter says, because it is an identifier to compare and style on. This is the field to branch on; meaning.nature is the reference card characterisation of the aspect type and is translated for display.
    pub interpretation: String,
    /// Whether the aspect is applying (growing stronger) or separating (fading).
    #[serde(rename = "isApplying")]
    pub is_applying: bool,
    /// Aspect meaning with keywords, description, and nature classification.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub meaning: Option<AspectsResponseAspectsItemMeaning>,
    /// Distance from exact aspect in degrees. Tighter orb means stronger influence.
    pub orb: f64,
    /// First planet in the aspect pair. Always English, whatever the lang parameter says. Use planet1Localized for anything a reader sees.
    pub planet1: String,
    /// First planet name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "planet1Localized", skip_serializing_if = "Option::is_none")]
    pub planet1_localized: Option<String>,
    /// Second planet in the aspect pair. Always English, whatever the lang parameter says. Use planet2Localized for anything a reader sees.
    pub planet2: String,
    /// Second planet name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "planet2Localized", skip_serializing_if = "Option::is_none")]
    pub planet2_localized: Option<String>,
    /// Aspect strength (0-100) based on orb tightness.
    pub strength: f64,
    /// Aspect type (CONJUNCTION, OPPOSITION, TRINE, SQUARE, SEXTILE, etc.). Always English, whatever the lang parameter says. Use typeLocalized for anything a reader sees.
    pub r#type: String,
    /// Aspect type name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "typeLocalized", skip_serializing_if = "Option::is_none")]
    pub type_localized: Option<String>,
}
/// Aspect meaning with keywords, description, and nature classification.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AspectsResponseAspectsItemMeaning {
    /// Aspect meaning in short and long form.
    pub description: AspectsResponseAspectsItemMeaningDescription,
    /// Keywords associated with this aspect type.
    pub keywords: Vec<String>,
    /// Aspect display name.
    pub name: String,
    /// How this aspect type is characterised in its reference card, in the requested language, exactly like the name, description and keywords beside it. This is a property of the aspect TYPE, so branch on the aspect-level interpretation field instead, which is always English and is the classification applied to this particular pair.
    pub nature: String,
}
/// Aspect meaning in short and long form.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AspectsResponseAspectsItemMeaningDescription {
    /// Detailed aspect description with astrological context.
    pub long: String,
    /// Brief aspect description.
    pub short: String,
}
/// Request body of `calculateAspects`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AspectsRequest {
    /// Optional: specific aspect types to find (defaults to all 9)
    #[serde(rename = "aspectTypes", skip_serializing_if = "Option::is_none")]
    pub aspect_types: Option<Vec<String>>,
    /// Date in YYYY-MM-DD format
    pub date: String,
    /// Optional: specific bodies to calculate aspects for (defaults to all 14: the 10 classical planets, the lunar nodes, Chiron, and Black Moon Lilith)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub planets: Option<Vec<String>>,
    /// Time in HH:MM:SS format (24-hour)
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
    pub timezone: AspectsRequestTimezone,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum AspectsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
/// Response body of `detectAspectPatterns`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AspectPatternsResponse {
    /// Echo of the options used for this detection run. Useful for reproducibility and for downstream UI display.
    pub options: AspectPatternsResponseOptions,
    /// All aspect patterns detected in the chart, in detection order: Grand Cross first, then Kite, Grand Trine, T-Square, Yod, Mystic Rectangle, Stellium. Patterns absorbed by a higher-priority detection (T-Squares inside a Grand Cross, Grand Trines absorbed by a Kite) are not reported separately.
    pub patterns: Vec<AspectPatternsResponsePatternsItem>,
    /// Total number of detected aspect patterns in this chart.
    pub total: f64,
}
/// One entry of `patterns`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AspectPatternsResponsePatternsItem {
    /// Focal planet for Kite, T-Square, and Yod patterns. Receives the released energy of the configuration and is the recommended integration point.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub apex: Option<String>,
    /// True if the pattern is out-of-sign (one or more planets in a neighboring element or modality). Dissociate patterns are still valid but operate with weakened thematic coherence.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dissociate: Option<bool>,
    /// Dominant element when the pattern is element-coherent (Grand Trine, Kite). Reported lowercase. Absent for patterns whose meaning does not pivot on element.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub element: Option<AspectPatternsResponsePatternsItemElement>,
    /// Concise one-line interpretation naming the participating planets and theme. Localized to the requested language via the lang query parameter (defaults to English).
    pub interpretation: String,
    /// Stable template identifier used to render the interpretation. Useful for clients that wish to swap in a custom narrative template while preserving the structured variables.
    #[serde(rename = "interpretationKey")]
    pub interpretation_key: String,
    /// Variables that were interpolated into the interpretation template. Names already resolved to the requested language where appropriate.
    #[serde(rename = "interpretationVars")]
    pub interpretation_vars: AspectPatternsResponsePatternsItemInterpretationVars,
    /// Pattern kind identifier. GRAND_TRINE (3 trines, harmonious flow), KITE (Grand Trine with a focal outlet planet), T_SQUARE (opposition with squared apex, growth engine), GRAND_CROSS (4 planets in 2 oppositions and 4 squares, peak tension), YOD (Finger of Fate, fated adjustment), MYSTIC_RECTANGLE (oppositions softened by trines and sextiles), STELLIUM (3+ planets clustered in a sign or 10-degree arc).
    pub kind: AspectPatternsResponsePatternsItemKind,
    /// Dominant modality for tension-based patterns (T-Square, Grand Cross). Cardinal initiates, Fixed sustains, Mutable adapts.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub modality: Option<AspectPatternsResponsePatternsItemModality>,
    /// Human-readable name of the configuration as used in astrological literature.
    pub name: String,
    /// Participating bodies in canonical order. For Kite, T-Square, and Yod the apex planet appears first.
    pub planets: Vec<String>,
    /// Tightness score (0-100) derived from the average orb tightness across all defining aspects. Higher means closer to exact and stronger thematic expression.
    pub tightness: f64,
}
string_enum! {
    /// Dominant modality for tension-based patterns (T-Square, Grand Cross). Cardinal initiates, Fixed sustains, Mutable adapts.
    AspectPatternsResponsePatternsItemModality {
        Cardinal = "cardinal",
        Fixed = "fixed",
        Mutable = "mutable",
    }
}
string_enum! {
    /// Pattern kind identifier. GRAND_TRINE (3 trines, harmonious flow), KITE (Grand Trine with a focal outlet planet), T_SQUARE (opposition with squared apex, growth engine), GRAND_CROSS (4 planets in 2 oppositions and 4 squares, peak tension), YOD (Finger of Fate, fated adjustment), MYSTIC_RECTANGLE (oppositions softened by trines and sextiles), STELLIUM (3+ planets clustered in a sign or 10-degree arc).
    AspectPatternsResponsePatternsItemKind {
        GrandTrine = "GRAND_TRINE",
        Kite = "KITE",
        TSquare = "T_SQUARE",
        GrandCross = "GRAND_CROSS",
        Yod = "YOD",
        MysticRectangle = "MYSTIC_RECTANGLE",
        Stellium = "STELLIUM",
    }
}
/// Variables that were interpolated into the interpretation template. Names already resolved to the requested language where appropriate.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AspectPatternsResponsePatternsItemInterpretationVars {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, String>,
}
string_enum! {
    /// Dominant element when the pattern is element-coherent (Grand Trine, Kite). Reported lowercase. Absent for patterns whose meaning does not pivot on element.
    AspectPatternsResponsePatternsItemElement {
        Fire = "fire",
        Earth = "earth",
        Air = "air",
        Water = "water",
    }
}
/// Echo of the options used for this detection run. Useful for reproducibility and for downstream UI display.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AspectPatternsResponseOptions {
    /// Optional bodies included beyond the default Sun-Pluto set. Empty means classical 10-planet detection only.
    pub include: Vec<AspectPatternsResponseOptionsIncludeItem>,
    /// Whether the tight orb budget was used. False uses the standard pattern-detection orbs (8 degrees for major aspects, 9 for square, 6 for sextile, 3 for quincunx).
    #[serde(rename = "strictOrbs")]
    pub strict_orbs: bool,
}
string_enum! {
    /// One entry of `include`.
    AspectPatternsResponseOptionsIncludeItem {
        Chiron = "chiron",
        NorthNode = "northNode",
    }
}
/// Request body of `detectAspectPatterns`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AspectPatternsRequest {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<AspectPatternsRequestNodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
    pub timezone: AspectPatternsRequestTimezone,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum AspectPatternsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    AspectPatternsRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
/// Complete Ashtakavarga analysis for a birth chart
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AshtakavargaResponse {
    /// Individual planetary strength grids (Bhinnashtakavarga). Eight entries: one for each of the 7 classical planets plus Lagna. Each entry shows how many of the 8 contributors (7 planets + Lagna) give benefic points to that planet in each of the 12 signs.
    pub bhinnashtakavarga: Vec<AshtakavargaResponseBhinnashtakavargaItem>,
    /// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
    pub frame: AshtakavargaResponseFrame,
    /// Reduced Bhinnashtakavarga after two-step Shodhana (purification) per BPHS Ch. 67-68. Step 1: Trikona Shodhana subtracts minimum bindu among trine groups (1-5-9, 2-6-10, 3-7-11, 4-8-12). Step 2: Ekadipati Shodhana adjusts dual-lordship sign pairs (Mars: Aries/Scorpio, Venus: Taurus/Libra, Mercury: Gemini/Virgo, Jupiter: Sagittarius/Pisces, Saturn: Capricorn/Aquarius). Used as input for Shodhya Pinda planetary strength.
    #[serde(rename = "reducedBhinnashtakavarga")]
    pub reduced_bhinnashtakavarga: Vec<AshtakavargaResponseReducedBhinnashtakavargaItem>,
    /// Reduced Sarvashtakavarga. Sum of the 7 reduced planetary Bhinnashtakavarga values per sign (Lagna excluded). Indicates relative sign strength after Shodhana purification.
    #[serde(rename = "reducedSarvashtakavarga")]
    pub reduced_sarvashtakavarga: AshtakavargaResponseReducedSarvashtakavarga,
    /// Sarvashtakavarga (SAV) combining all 7 planetary Bhinnashtakavarga scores per sign. Total is always 337.
    pub sarvashtakavarga: AshtakavargaResponseSarvashtakavarga,
    /// Shodhya Pinda planetary strength scores per BPHS Ch. 69. Derived from Reduced Ashtakavarga. Each entry contains Rashi Pinda (sign-weighted strength), Graha Pinda (planet-association-weighted strength), and total Shodhya Pinda. Used for comparing planetary strength, predicting dasha results, and transit analysis.
    #[serde(rename = "shodhyaPinda")]
    pub shodhya_pinda: Vec<AshtakavargaResponseShodhyaPindaItem>,
    /// Sign names in order, for mapping bindus array indices to zodiac signs. Index 0 = Aries through index 11 = Pisces.
    pub signs: Vec<AshtakavargaResponseSignsItem>,
}
string_enum! {
    /// One entry of `signs`.
    AshtakavargaResponseSignsItem {
        Aries = "Aries",
        Taurus = "Taurus",
        Gemini = "Gemini",
        Cancer = "Cancer",
        Leo = "Leo",
        Virgo = "Virgo",
        Libra = "Libra",
        Scorpio = "Scorpio",
        Sagittarius = "Sagittarius",
        Capricorn = "Capricorn",
        Aquarius = "Aquarius",
        Pisces = "Pisces",
    }
}
/// Shodhya Pinda strength values for a single planet, derived from Reduced Ashtakavarga per BPHS Ch. 69.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AshtakavargaResponseShodhyaPindaItem {
    /// Graha Pinda component. Weighted sum of reduced Bhinnashtakavarga bindus per sign multiplied by the Graha Gunakar of planets occupying each sign (Sun=5, Moon=5, Mars=8, Mercury=5, Jupiter=10, Venus=7, Saturn=5). Reflects planetary association strength.
    #[serde(rename = "grahaPinda")]
    pub graha_pinda: f64,
    /// Planet or Lagna name. Shodhya Pinda is calculated for all 7 classical planets plus Lagna.
    pub planet: String,
    /// Rashi Pinda component. Weighted sum of reduced Bhinnashtakavarga bindus per sign multiplied by Rashi Gunakar weights per BPHS Ch. 69. Higher values indicate stronger sign-based planetary strength.
    #[serde(rename = "rashiPinda")]
    pub rashi_pinda: f64,
    /// Total Shodhya Pinda (Rashi Pinda + Graha Pinda). Primary planetary strength score derived from Ashtakavarga reduction. Used for comparing relative strength of planets in a birth chart and predicting dasha period results.
    #[serde(rename = "shodhyaPinda")]
    pub shodhya_pinda: f64,
}
/// Sarvashtakavarga (SAV) combining all 7 planetary Bhinnashtakavarga scores per sign. Total is always 337.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AshtakavargaResponseSarvashtakavarga {
    /// Combined benefic points per sign from all 7 planets (Lagna excluded from SAV), ordered Aries through Pisces. Higher values indicate stronger signs for transit predictions and house strength analysis. Average is approximately 28 per sign.
    pub bindus: Vec<f64>,
    /// Sum of all SAV bindus across 12 signs. Always equals 337 for every birth chart. This mathematical constant serves as a validation checksum for the calculation.
    pub total: f64,
}
/// Reduced Sarvashtakavarga. Sum of the 7 reduced planetary Bhinnashtakavarga values per sign (Lagna excluded). Indicates relative sign strength after Shodhana purification.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AshtakavargaResponseReducedSarvashtakavarga {
    /// Combined benefic points per sign from all 7 planets (Lagna excluded from SAV), ordered Aries through Pisces. Higher values indicate stronger signs for transit predictions and house strength analysis. Average is approximately 28 per sign.
    pub bindus: Vec<f64>,
    /// Sum of all SAV bindus across 12 signs. Always equals 337 for every birth chart. This mathematical constant serves as a validation checksum for the calculation.
    pub total: f64,
}
/// Bhinnashtakavarga for a single planet or Lagna
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AshtakavargaResponseReducedBhinnashtakavargaItem {
    /// Benefic points (bindus) for each of the 12 signs, ordered Aries through Pisces (index 0 = Aries, index 11 = Pisces). Each value ranges from 0 to 8, representing how many of the 8 contributors (7 planets + Lagna) provide a benefic point for this planet in that sign. Higher bindus indicate stronger planetary support.
    pub bindus: Vec<f64>,
    /// Planet or Lagna name. Seven classical planets (Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn) plus Lagna (Ascendant). Rahu and Ketu are excluded from Ashtakavarga per BPHS.
    pub planet: String,
    /// Sum of bindus across all 12 signs. This total is constant per planet regardless of birth chart: Sun = 48, Moon = 49, Mars = 39, Mercury = 54, Jupiter = 56, Venus = 52, Saturn = 39, Lagna = 49. Useful as a validation checksum.
    pub total: f64,
}
/// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AshtakavargaResponseFrame {
    /// Sidereal frame this chart was cast in, echoing the ayanamsa request field. "lahiri" when the field was omitted.
    pub ayanamsa: String,
    /// Degrees actually subtracted from every tropical longitude to produce this chart, read at the birth instant. Subtract it back to recover the tropical positions, or compare it against your reference software to confirm you are in the same frame before chasing a placement difference.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
}
/// Bhinnashtakavarga for a single planet or Lagna
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AshtakavargaResponseBhinnashtakavargaItem {
    /// Benefic points (bindus) for each of the 12 signs, ordered Aries through Pisces (index 0 = Aries, index 11 = Pisces). Each value ranges from 0 to 8, representing how many of the 8 contributors (7 planets + Lagna) provide a benefic point for this planet in that sign. Higher bindus indicate stronger planetary support.
    pub bindus: Vec<f64>,
    /// Planet or Lagna name. Seven classical planets (Sun, Moon, Mars, Mercury, Jupiter, Venus, Saturn) plus Lagna (Ascendant). Rahu and Ketu are excluded from Ashtakavarga per BPHS.
    pub planet: String,
    /// Sum of bindus across all 12 signs. This total is constant per planet regardless of birth chart: Sun = 48, Moon = 49, Mars = 39, Mercury = 54, Jupiter = 56, Venus = 52, Saturn = 39, Lagna = 49. Useful as a validation checksum.
    pub total: f64,
}
/// Request body of `calculateAshtakavarga`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AshtakavargaRequest {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<AshtakavargaRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<AshtakavargaRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum AshtakavargaRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    AshtakavargaRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// The twelve Arudha padas of a birth chart, computed per the Jaimini rule with the classical exception applied.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ArudhaResponse {
    /// Zodiac sign of the Arudha Lagna (AL), the pada of the first house and the single most used value in this response. Repeated at the top level so a client rendering only the AL does not have to search the array.
    #[serde(rename = "arudhaLagna")]
    pub arudha_lagna: String,
    /// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
    pub frame: ArudhaResponseFrame,
    /// Zodiac sign of the Ascendant (Lagna), which anchors the twelve bhavas the padas are derived from.
    #[serde(rename = "lagnaRashi")]
    pub lagna_rashi: String,
    /// All twelve Arudha padas in bhava order, a1 through a12. Each carries the lord and the count it came from, so the derivation can be checked by hand.
    pub padas: Vec<ArudhaResponsePadasItem>,
    /// Zodiac sign of the Upapada (UL), the pada of the twelfth house, read for marriage and its durability. The second most used value, so it is also lifted to the top level.
    pub upapada: String,
}
/// One Arudha pada: the bhava it belongs to, the lord and count that produced it, the sign it lands in, and what it is read for.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ArudhaResponsePadasItem {
    /// Practitioner shorthand written on a chart: AL for the Arudha Lagna, A2 through A11, and UL for the Upapada.
    pub abbreviation: String,
    /// Zodiac sign (rashi) occupying that bhava, counted whole-sign from the Lagna. The count to the pada starts here.
    #[serde(rename = "bhavaRashi")]
    pub bhava_rashi: String,
    /// True when the raw pada landed in the same bhava or the seventh from it and was moved to the tenth from there, as the classical rule requires. Surfaced so a reader can see exactly why a pada sits where it does, which is the step implementations most often skip.
    #[serde(rename = "exceptionApplied")]
    pub exception_applied: bool,
    /// Bhava (house) number 1-12 whose pada this is. The pada is the perceived, outward form of that bhava.
    pub house: i64,
    /// Which house from the Lagna the pada sits in, counted inclusively 1-12. Reading a pada against the natal Lagna is how its strength is judged.
    #[serde(rename = "houseFromLagna")]
    pub house_from_lagna: i64,
    /// Pada identifier, a1 through a12, matching the bhava it belongs to. a1 is the Arudha Lagna and a12 the Upapada.
    pub id: String,
    /// Lord of the bhava sign. The pada is found by counting to this graha and then the same distance again.
    pub lord: String,
    /// Zodiac sign the bhava lord occupies, which sets the length of the count.
    #[serde(rename = "lordRashi")]
    pub lord_rashi: String,
    /// Short label for what this pada is read for, sized for a table cell.
    pub meaning: String,
    /// Classical Sanskrit name of the pada, for example Arudha Lagna, Dhana Pada, Dara Pada, Upapada.
    pub name: String,
    /// Zodiac sign the pada falls in, after the classical exception is applied. This is the answer most readings start from.
    pub rashi: String,
    /// What this pada governs. Padas describe how a matter is PERCEIVED, which is what separates them from the bhava significations of the same house.
    pub significations: String,
}
/// The sidereal frame this response was computed in, so a cached or forwarded payload is self describing.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ArudhaResponseFrame {
    /// Sidereal frame this chart was cast in, echoing the ayanamsa request field. "lahiri" when the field was omitted.
    pub ayanamsa: String,
    /// Degrees actually subtracted from every tropical longitude to produce this chart, read at the birth instant. Subtract it back to recover the tropical positions, or compare it against your reference software to confirm you are in the same frame before chasing a placement difference.
    #[serde(rename = "ayanamsaDegrees")]
    pub ayanamsa_degrees: f64,
}
/// Request body of `calculateArudhaPadas`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ArudhaRequest {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ayanamsa: Option<ArudhaRequestAyanamsa>,
    /// Custom ayanamsa value in degrees. When provided, overrides the computed ayanamsa from the selected type. Use for testing with specific ayanamsa values or matching a particular reference source.
    #[serde(rename = "ayanamsaValue", skip_serializing_if = "Option::is_none")]
    pub ayanamsa_value: Option<f64>,
    /// Birth date in YYYY-MM-DD format. Date determines planetary positions and nakshatra calculations for Vedic kundli (janam patri). Accurate birth date is essential for dashas, yoga calculations, and divisional charts (vargas).
    pub date: String,
    /// Birth location latitude in decimal degrees. Location determines local sidereal time for Lagna calculation and affects bhava (house) cusps. Example: Delhi 28.6139, Mumbai 19.0760, Kathmandu 27.7172.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees. Affects local time calculations and ayanamsha adjustments. Example: Delhi 77.2090, Mumbai 72.8777, Kathmandu 85.3240.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Time is CRITICAL for Lagna (Ascendant) calculation and house divisions. It changes every two hours roughly. Even minutes matter for accurate nakshatra pada and divisional chart (D9, D10) calculations. Without exact time, Lagna and house-based predictions will be incorrect.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<ArudhaRequestTimezone>,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time. Defaults to 5.5.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum ArudhaRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Sidereal frame (ayanamsa) the chart is cast in. "lahiri" is Lahiri/Chitrapaksha, the traditional Vedic standard used by most software, and is the default. "raman" is the B.V. Raman ayanamsa from Hindu Predictive Astrology, about 1.45 degrees below Lahiri. "kp-newcomb" and "kp-old" are the two Krishnamurti Paddhati frames. "custom" takes your own value in degrees via ayanamsaValue, for reconciling exactly against a specific reference program. The frame rotates the whole zodiac, so a graha sitting within 1.45 degrees of a boundary can change rashi or nakshatra when you switch: pick the one your reference software uses and keep it.
    ArudhaRequestAyanamsa {
        KpNewcomb = "kp-newcomb",
        KpOld = "kp-old",
        Lahiri = "lahiri",
        Raman = "raman",
        Custom = "custom",
    }
}
/// Response body of `calculateArabicLots`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ArabicLotsResponse {
    /// Echo of the birth moment and place used to compute every lot.
    #[serde(rename = "birthDetails")]
    pub birth_details: ArabicLotsResponseBirthDetails,
    /// The seven Hermetic lots in canonical order: Part of Fortune and Part of Spirit from the luminaries, then Eros, Necessity, Courage, Victory, and Nemesis from a planet paired with Fortune or Spirit.
    pub lots: Vec<ArabicLotsResponseLotsItem>,
    /// Chart sect that selected each formula. Day (diurnal) when the Sun is above the horizon, night (nocturnal) when below. Every lot swaps its two non-Ascendant terms between day and night.
    pub sect: ArabicLotsResponseSect,
    /// Short overview of the lot set for previews and report intros.
    pub summary: String,
}
string_enum! {
    /// Chart sect that selected each formula. Day (diurnal) when the Sun is above the horizon, night (nocturnal) when below. Every lot swaps its two non-Ascendant terms between day and night.
    ArabicLotsResponseSect {
        Day = "day",
        Night = "night",
    }
}
/// One entry of `lots`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ArabicLotsResponseLotsItem {
    /// Degree of the lot within its zodiac sign (0 to 29.999).
    pub degree: f64,
    /// Human readable arc used for this chart, with the day or night term order already applied by sect.
    pub formula: String,
    /// Stable machine identifier for the lot (fortune, spirit, eros, necessity, courage, victory, nemesis). Use this for lookups.
    pub id: String,
    /// Plain language meaning of this lot in its sign, suitable for chart reports and AI agents. Localized to the requested language.
    pub interpretation: String,
    /// Absolute tropical ecliptic longitude of the lot in degrees (0 to 360).
    pub longitude: f64,
    /// Name of the lot. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Lot name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// Tropical zodiac sign the lot falls in.
    pub sign: String,
}
/// Echo of the birth moment and place used to compute every lot.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ArabicLotsResponseBirthDetails {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone offset from UTC in decimal hours, resolved for the birth date. Examples: New York = -5 in winter and -4 in summer, London = 0, India = 5.5, Tokyo = 9.
    pub timezone: f64,
}
/// Request body of `calculateArabicLots`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ArabicLotsRequest {
    /// Birth date in YYYY-MM-DD format. Determines planetary positions for the specific calendar day.
    pub date: String,
    /// House system used to place the Sun, which determines the chart sect (day when the Sun is above the horizon, night when below) and therefore which lot formula applies. Placidus (default), Whole Sign, Equal, or Koch.
    #[serde(rename = "houseSystem", skip_serializing_if = "Option::is_none")]
    pub house_system: Option<ArabicLotsRequestHouseSystem>,
    /// Birth location latitude in decimal degrees (-90 to 90). Positive = North, negative = South.
    pub latitude: f64,
    /// Birth location longitude in decimal degrees (-180 to 180). Positive = East, negative = West.
    pub longitude: f64,
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    #[serde(rename = "nodeType", skip_serializing_if = "Option::is_none")]
    pub node_type: Option<ArabicLotsRequestNodeType>,
    /// Birth time in 24-hour HH:MM:SS format. Determines the Ascendant (rising sign) and house cusps. Use 12:00:00 if unknown.
    pub time: String,
    /// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
    pub timezone: ArabicLotsRequestTimezone,
}
/// Timezone: an IANA name (e.g. "America/New_York", "Europe/London", or `cities[0].timezone` from /location/search) or decimal hours from UTC (e.g. -5 for EST, 5.5 for IST). An IANA name is resolved to the offset in force at the given date and time.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
#[non_exhaustive]
pub enum ArabicLotsRequestTimezone {
    /// A number value.
    Number(f64),
    /// A string value.
    String(String),
}
string_enum! {
    /// Lunar node convention. "mean" is the smoothed average node, which always moves retrograde; "true" is the osculating node, which tracks the real perturbed node, oscillates up to about 1.5 degrees either side of the mean on a 173-day cycle, and can briefly turn direct. Neither is more correct and they almost always fall in the same sign. Applies to the North and South Node. True is the osculating node and the default, because it is what most Western chart software reports; mean is the smoothed node preferred by several evolutionary schools, so pass "mean" to match one. Nothing else in the chart changes, and the two agree on the sign except when the node sits within about 1.8 degrees of a cusp. Defaults to "true".
    ArabicLotsRequestNodeType {
        Mean = "mean",
        TrueValue = "true",
    }
}
string_enum! {
    /// House system used to place the Sun, which determines the chart sect (day when the Sun is above the horizon, night when below) and therefore which lot formula applies. Placidus (default), Whole Sign, Equal, or Koch.
    ArabicLotsRequestHouseSystem {
        Placidus = "placidus",
        WholeSign = "whole-sign",
        Equal = "equal",
        Koch = "koch",
    }
}
/// Response body of `analyzeNumberSequence`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AnalyzeNumberSequenceResponse {
    /// Present only when the context query parameter is supplied. A short reading layered on top of the meaning that accounts for WHERE the number was seen (clock, receipt, license plate, phone, address, price), since the place of a sighting shifts its emphasis.
    #[serde(rename = "contextNote", skip_serializing_if = "Option::is_none")]
    pub context_note: Option<String>,
    /// Numerology digit root from summing and reducing all digits. Links to foundational single-digit meaning. Master numbers 11, 22, 33 are preserved.
    #[serde(rename = "digitRoot")]
    pub digit_root: f64,
    /// The foundational meaning of this number based on its digit root. Every number reduces to a root digit (0-9) or master number (11, 22, 33), which provides the base interpretation even for unknown sequences.
    #[serde(rename = "digitRootMeaning")]
    pub digit_root_meaning: Option<AnalyzeNumberSequenceResponseDigitRootMeaning>,
    /// Total number of digits in the sequence.
    pub digits: f64,
    /// Whether the number reads the same forwards and backwards (e.g., 1221, 1001).
    #[serde(rename = "isPalindrome")]
    pub is_palindrome: bool,
    /// Whether all digits are identical (e.g., 111, 4444, 777).
    #[serde(rename = "isRepeating")]
    pub is_repeating: bool,
    /// Full angel number meaning if this number exists in the curated database (75+ known sequences). Null if the number is not in the database, in which case use the analysis fields (type, digitRoot) and the digitRootMeaning fallback for interpretation.
    #[serde(rename = "knownMeaning")]
    pub known_meaning: Option<AnalyzeNumberSequenceResponseKnownMeaning>,
    /// The number sequence that was analyzed.
    pub number: String,
    /// Pattern classification detected for this number. "repeating" means all same digits. "sequential" means consecutive ascending or descending. "mirror" means palindrome or alternating pattern. "master" means numerology master number. "root" means single digit. "compound" means a multi-digit sequence with no pure pattern (e.g. 911, 1122).
    pub r#type: String,
    /// Count of unique digits. A repeating number like 111 has 1 unique digit; 1234 has 4.
    #[serde(rename = "uniqueDigits")]
    pub unique_digits: f64,
}
/// Full angel number meaning if this number exists in the curated database (75+ known sequences). Null if the number is not in the database, in which case use the analysis fields (type, digitRoot) and the digitRootMeaning fallback for interpretation.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AnalyzeNumberSequenceResponseKnownMeaning {
    /// Actionable steps when you see this number.
    #[serde(rename = "actionSteps")]
    pub action_steps: Vec<String>,
    /// Positive affirmation for this number.
    pub affirmation: String,
    /// Biblical and religious perspective, framed honestly.
    pub biblical: String,
    /// Core message summary.
    #[serde(rename = "coreMessage")]
    pub core_message: String,
    /// Energy classification (positive, neutral, cautionary).
    pub energy: String,
    /// Keywords for this angel number.
    pub keywords: Vec<String>,
    /// Detailed interpretations across life areas.
    pub meaning: AnalyzeNumberSequenceResponseKnownMeaningMeaning,
    /// Shadow or cautionary reading for this number.
    pub shadow: String,
    /// Title of the matched angel number meaning.
    pub title: String,
}
/// Detailed interpretations across life areas.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AnalyzeNumberSequenceResponseKnownMeaningMeaning {
    /// Career and vocation guidance. Money and finances are returned separately in the money field.
    pub career: String,
    /// Love and relationship interpretation for singles, couples, and those healing from past relationships.
    pub love: String,
    /// Money, finances, and material abundance guidance, distinct from career.
    pub money: String,
    /// Spiritual interpretation covering divine guidance, higher purpose, and metaphysical significance.
    pub spiritual: String,
    /// Twin flame connection interpretation covering union, separation, and spiritual growth.
    #[serde(rename = "twinFlame")]
    pub twin_flame: String,
}
/// The foundational meaning of this number based on its digit root. Every number reduces to a root digit (0-9) or master number (11, 22, 33), which provides the base interpretation even for unknown sequences.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AnalyzeNumberSequenceResponseDigitRootMeaning {
    /// Affirmation for the root digit.
    pub affirmation: String,
    /// Core message of the foundational root digit.
    #[serde(rename = "coreMessage")]
    pub core_message: String,
    /// Keywords for the root digit.
    pub keywords: Vec<String>,
    /// Full life-area interpretation of the underlying root digit. For an unknown sequence this is the substantive reading to display, so a synchronicity app never dead-ends on an arbitrary number.
    pub meaning: AnalyzeNumberSequenceResponseDigitRootMeaningMeaning,
    /// Root digit number (0-9) or master number (11, 22, 33).
    pub number: String,
    /// Title of the root digit meaning in numerology.
    pub title: String,
}
/// Full life-area interpretation of the underlying root digit. For an unknown sequence this is the substantive reading to display, so a synchronicity app never dead-ends on an arbitrary number.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AnalyzeNumberSequenceResponseDigitRootMeaningMeaning {
    /// Career and vocation guidance for the root digit. Money and finances are returned separately in the money field.
    pub career: String,
    /// Love and relationship interpretation of the root digit, for singles, couples, and those healing from past relationships.
    pub love: String,
    /// Money, finances, and material abundance guidance for the root digit, kept distinct from career.
    pub money: String,
    /// Spiritual interpretation of the root digit, covering divine guidance, higher purpose, and metaphysical significance.
    pub spiritual: String,
    /// Twin flame interpretation of the root digit, covering union, separation, and spiritual growth.
    #[serde(rename = "twinFlame")]
    pub twin_flame: String,
}
/// Path and query parameters of `analyzeNumberSequence`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AnalyzeNumberSequenceParams {
    /// Where the number was seen. When supplied, the response adds a contextNote tailoring the reading to the sighting: clock (a glanced time), receipt (a purchase), license-plate (in transit), phone (a call or notification), address (a home or place), price (a total or amount).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub context: Option<AnalyzeNumberSequenceParamsContext>,
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<AnalyzeNumberSequenceParamsLang>,
    /// Number sequence to analyze (1-8 digits). Can be any number the user has encountered: clock times (1111), addresses (717), receipts (888), license plates (4444), or any repeating pattern.
    pub number: String,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    AnalyzeNumberSequenceParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
string_enum! {
    /// Where the number was seen. When supplied, the response adds a contextNote tailoring the reading to the sighting: clock (a glanced time), receipt (a purchase), license-plate (in transit), phone (a call or notification), address (a home or place), price (a total or amount).
    AnalyzeNumberSequenceParamsContext {
        Clock = "clock",
        Receipt = "receipt",
        LicensePlate = "license-plate",
        Phone = "phone",
        Address = "address",
        Price = "price",
    }
}
/// Response body of `analyzeKarmicLessons`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AnalyzeKarmicLessonsResponse {
    /// The `lessons` field.
    pub lessons: Vec<AnalyzeKarmicLessonsResponseLessonsItem>,
    /// Numbers missing from name (karmic lessons)
    #[serde(rename = "missingNumbers")]
    pub missing_numbers: Vec<f64>,
    /// Count of each number present in name
    #[serde(rename = "presentNumbers")]
    pub present_numbers: AnalyzeKarmicLessonsResponsePresentNumbers,
}
/// Count of each number present in name
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AnalyzeKarmicLessonsResponsePresentNumbers {
    /// Every other key of the object, by name.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, f64>,
}
/// One entry of `lessons`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AnalyzeKarmicLessonsResponseLessonsItem {
    /// Detailed lesson explanation
    pub description: String,
    /// Practical guidance for developing this quality
    #[serde(rename = "howToOvercome")]
    pub how_to_overcome: String,
    /// Core lesson summary
    pub lesson: String,
    /// Missing number
    pub number: f64,
}
/// Path and query parameters of `analyzeKarmicLessons`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct AnalyzeKarmicLessonsParams {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lang: Option<AnalyzeKarmicLessonsParamsLang>,
}
string_enum! {
    /// Response language (BCP 47). Supported: en, tr, de, es, hi, pt, fr, ru, zh-Hans, zh-Hant. Defaults to en. Coverage varies by domain, and a field with no translation in the requested language returns English.
    AnalyzeKarmicLessonsParamsLang {
        En = "en",
        Tr = "tr",
        De = "de",
        Es = "es",
        Hi = "hi",
        Pt = "pt",
        Fr = "fr",
        Ru = "ru",
        ZhHans = "zh-Hans",
        ZhHant = "zh-Hant",
    }
}
/// Request body of `analyzeKarmicLessons`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct AnalyzeKarmicLessonsRequest {
    /// Full birth name to analyze for missing numbers. A name in any script is converted to Latin letters before it is counted, Cyrillic and Greek as the passport spelling and accents folded to the base letter, and the calculation lists the letters counted. For a script that does not write its vowels, send the Latin spelling the person uses.
    #[serde(rename = "fullName")]
    pub full_name: String,
}
/// Request body of `calculateBirthDay`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBirthDayRequest {
    /// Day of birth (1-31)
    pub day: i64,
}
/// Request body of `calculateBridgeNumbers`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBridgeNumbersRequest {
    /// Birth day (1 to 31)
    pub day: i64,
    /// Full birth name as it appears on the birth certificate, first, middle and last names separated by spaces. Used to calculate the Expression, Soul Urge and Personality numbers. A name in any script is converted to Latin letters before it is counted, Cyrillic and Greek as the passport spelling and accents folded to the base letter, and the calculation lists the letters counted. For a script that does not write its vowels, send the Latin spelling the person uses.
    #[serde(rename = "fullName")]
    pub full_name: String,
    /// Birth month (1 to 12)
    pub month: i64,
    /// Birth year between 100 and 2100. Used to calculate the Life Path number via Pythagorean reduction.
    pub year: i64,
}
/// Request body of `calculateBusinessName`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateBusinessNameRequest {
    /// The business or brand name to evaluate. A name in any script is converted to Latin letters before it is counted, Cyrillic and Greek as the passport spelling and accents folded to the base letter, and the calculation lists the letters counted. For a script that does not write its vowels, send the Latin spelling the person uses.
    pub name: String,
}
/// Request body of `calculateChaldean`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateChaldeanRequest {
    /// The name to analyze. Chaldean tradition uses the name a person is most known by, not necessarily the full legal birth name. It needs at least one vowel (A, E, I, O, U) and one consonant, since the Soul Urge is read from the vowels and the Personality from the consonants; Y counts as a consonant. A name in any script is converted to Latin letters before it is counted, Cyrillic and Greek as the passport spelling and accents folded to the base letter, and the calculation lists the letters counted. For a script that does not write its vowels, send the Latin spelling the person uses.
    pub name: String,
}
/// Request body of `calculateDual`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateDualRequest {
    /// The name to analyze in both systems. A name in any script is converted to Latin letters before it is counted, Cyrillic and Greek as the passport spelling and accents folded to the base letter, and the calculation lists the letters counted. For a script that does not write its vowels, send the Latin spelling the person uses.
    pub name: String,
}
/// Request body of `calculateExpression`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateExpressionRequest {
    /// Full birth name (first, middle, last). A name in any script is converted to Latin letters before it is counted, Cyrillic and Greek as the passport spelling and accents folded to the base letter, and the calculation lists the letters counted. For a script that does not write its vowels, send the Latin spelling the person uses.
    #[serde(rename = "fullName")]
    pub full_name: String,
}
/// Request body of `calculateLifePath`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateLifePathRequest {
    /// Birth day (1-31)
    pub day: i64,
    /// Birth month (1-12)
    pub month: i64,
    /// Birth year between 100 and 2100. Supports historical figures like Einstein (1879) and Shakespeare (1564).
    pub year: i64,
}
/// Send a Gregorian date to convert forward, or a lunar year, month and day to convert back. The two sides are exclusive, which is why the whole body carries one example rather than leaving the per field ones to be read together.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateLunarDateRequest {
    /// Gregorian date to convert to the lunisolar calendar. Send this OR the lunar fields, never both. Converts from the first day of lunar year 1551 to the last day of lunar year 2648, a little inside the supported date span, because numbering a lunar month needs the winter solstice on each side of it and placing a leap month needs the year before; a date outside that answers 400 date_out_of_range.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Set true to address the leap repetition of lunarMonth rather than the first pass. Requesting a leap month a year does not have returns 400.
    #[serde(rename = "isLeapMonth", skip_serializing_if = "Option::is_none")]
    pub is_leap_month: Option<bool>,
    /// Day of the lunar month, 1 to 30. Requires lunarYear and lunarMonth.
    #[serde(rename = "lunarDay", skip_serializing_if = "Option::is_none")]
    pub lunar_day: Option<i64>,
    /// Lunar month, 1 to 12. Requires lunarYear and lunarDay.
    #[serde(rename = "lunarMonth", skip_serializing_if = "Option::is_none")]
    pub lunar_month: Option<i64>,
    /// Lunisolar year to convert back to a Gregorian date. Requires lunarMonth and lunarDay.
    #[serde(rename = "lunarYear", skip_serializing_if = "Option::is_none")]
    pub lunar_year: Option<i64>,
}
/// Request body of `calculateMaturity`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CalculateMaturityRequest {
    /// Birth day (1-31). Required with year and month for automatic Life Path calculation.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub day: Option<i64>,
    /// Your Expression number (1-9, 11, 22, 33). Optional if fullName is provided.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub expression: Option<i64>,
    /// Full birth name to calculate the Expression number automatically. Use instead of passing expression directly. A name in any script is converted to Latin letters before it is counted, Cyrillic and Greek as the passport spelling and accents folded to the base letter, and the calculation lists the letters counted. For a script that does not write its vowels, send the Latin spelling the person uses.
    #[serde(rename = "fullName", skip_serializing_if = "Option::is_none")]
    pub full_name: Option<String>,
    /// Your Life Path number (1-9, 11, 22, 33). Optional if year, month, day are provided.
    #[serde(rename = "lifePath", skip_serializing_if = "Option::is_none")]
    pub life_path: Option<i64>,
    /// Birth month (1-12). Required with year and day for automatic Life Path calculation.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub month: Option<i64>,
    /// Birth year to calculate Life Path automatically. Use with month and day instead of passing lifePath directly.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i64>,
}
/// Request body of `calculatePersonalDay`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePersonalDayRequest {
    /// Birth day (1-31)
    pub day: i64,
    /// Birth month (1-12)
    pub month: i64,
    /// Target date in YYYY-MM-DD format, in the years 100 to 2100. Defaults to today (UTC).
    #[serde(rename = "targetDate", skip_serializing_if = "Option::is_none")]
    pub target_date: Option<String>,
}
/// Response body of `calculatePersonalDay`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePersonalDayResponse {
    /// Actionable daily guidance. Specific advice for how to work with the energy of this Personal Day.
    pub guidance: String,
    /// Personal Day number (1-9). The most granular numerology cycle, revealing the energy and theme for this specific day based on your birth data.
    #[serde(rename = "personalDay")]
    pub personal_day: f64,
    /// The parent Personal Month number this day falls within.
    #[serde(rename = "personalMonth")]
    pub personal_month: f64,
    /// Theme of the parent Personal Month, providing broader context for the daily forecast.
    #[serde(rename = "personalMonthTheme")]
    pub personal_month_theme: String,
    /// The parent Personal Year number this day falls within.
    #[serde(rename = "personalYear")]
    pub personal_year: f64,
    /// Theme of the parent Personal Year, providing the broadest cycle context.
    #[serde(rename = "personalYearTheme")]
    pub personal_year_theme: String,
    /// The calendar date this forecast applies to in YYYY-MM-DD format.
    #[serde(rename = "targetDate")]
    pub target_date: String,
    /// Central theme for this Personal Day. A concise label capturing the dominant energy of the day.
    pub theme: String,
}
/// Request body of `calculatePersonalMonth`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePersonalMonthRequest {
    /// Birth day (1-31)
    pub day: i64,
    /// Birth month (1-12)
    pub month: i64,
    /// Target calendar month to forecast (1 to 12). Defaults to the current UTC month.
    #[serde(rename = "targetMonth", skip_serializing_if = "Option::is_none")]
    pub target_month: Option<i64>,
    /// Target year. Defaults to the current UTC year.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i64>,
}
/// Response body of `calculatePersonalMonth`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePersonalMonthResponse {
    /// The calendar month this forecast applies to (1-12).
    #[serde(rename = "calendarMonth")]
    pub calendar_month: f64,
    /// Practical guidance for this month. Specific actions, areas of focus, and advice for making the most of this monthly energy.
    pub focus: String,
    /// Personal Month number (1-9). Each month in the cycle carries specific energy and themes that guide decisions and focus.
    #[serde(rename = "personalMonth")]
    pub personal_month: f64,
    /// The parent Personal Year number this month falls within.
    #[serde(rename = "personalYear")]
    pub personal_year: f64,
    /// Theme of the parent Personal Year, providing broader context for the monthly forecast.
    #[serde(rename = "personalYearTheme")]
    pub personal_year_theme: String,
    /// Central theme for this Personal Month. A concise label capturing the dominant energy.
    pub theme: String,
}
/// Request body of `calculatePersonalYear`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePersonalYearRequest {
    /// Birth day (1-31)
    pub day: i64,
    /// Birth month (1-12)
    pub month: i64,
    /// Year to forecast. Defaults to the current UTC year; the Personal Year turns over on 1 January.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i64>,
}
/// Response body of `calculatePersonalYear`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePersonalYearResponse {
    /// Practical guidance for navigating the year
    pub advice: String,
    /// Challenges to navigate
    pub challenges: Vec<String>,
    /// Position in the 9-year cycle
    pub cycle: String,
    /// Detailed year forecast (200-300 words)
    pub forecast: String,
    /// Key opportunities in this year
    pub opportunities: Vec<String>,
    /// Personal Year number (1-9)
    #[serde(rename = "personalYear")]
    pub personal_year: f64,
    /// Main theme of the year
    pub theme: String,
}
/// Request body of `calculatePersonality`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculatePersonalityRequest {
    /// Full birth name. Its consonants give the Personality number, so a name with none is refused. A name in any script is converted to Latin letters before it is counted, Cyrillic and Greek as the passport spelling and accents folded to the base letter, and the calculation lists the letters counted. For a script that does not write its vowels, send the Latin spelling the person uses.
    #[serde(rename = "fullName")]
    pub full_name: String,
}
/// Response body of `calculateProfile`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateProfileResponse {
    /// Keynote of the Design line, the unconscious half of the profile.
    #[serde(rename = "designKeynote")]
    pub design_keynote: String,
    /// Line number from 1 to 6 of the unconscious Design Sun.
    #[serde(rename = "designLine")]
    pub design_line: f64,
    /// Keynote of the Personality line, the conscious half of the profile.
    #[serde(rename = "personalityKeynote")]
    pub personality_keynote: String,
    /// Line number from 1 to 6 of the conscious Personality Sun.
    #[serde(rename = "personalityLine")]
    pub personality_line: f64,
    /// Profile in conscious/unconscious form, the Personality Sun line over the Design Sun line.
    pub profile: String,
}
/// Request body of `calculateSoulUrge`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateSoulUrgeRequest {
    /// Full birth name. Its vowels A, E, I, O and U give the Soul Urge, so a name with none is refused. A name in any script is converted to Latin letters before it is counted, Cyrillic and Greek as the passport spelling and accents folded to the base letter, and the calculation lists the letters counted. For a script that does not write its vowels, send the Latin spelling the person uses.
    #[serde(rename = "fullName")]
    pub full_name: String,
}
/// Request body of `calculateTonalpohualli`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTonalpohualliRequest {
    /// Date in YYYY-MM-DD format, in the PROLEPTIC GREGORIAN calendar, extended backwards unchanged through the 1582 reform. Years 1 to 4000 are accepted. A reference converter that switches to the Julian calendar below the reform will disagree with a date before 15 October 1582 by ten or eleven days; that is a difference of input convention rather than of arithmetic, and passing the Julian equivalent to such a tool reproduces these values exactly. A single-digit month or day is accepted and zero padded.
    pub date: String,
}
/// Response body of `calculateType`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct CalculateTypeResponse {
    /// The aura mechanic of the type: how the energy field itself operates, for example open and enveloping, or closed and repelling.
    pub aura: String,
    /// Inner authority for decision making. One of Emotional, Sacral, Splenic, Ego, Self-Projected, Mental, Lunar. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use authorityLocalized for anything a reader sees.
    pub authority: String,
    /// How the decision is made, the timing it requires, and the characteristic trap. Inner authority is the most actionable output of a Human Design chart.
    #[serde(rename = "authorityDescription")]
    pub authority_description: String,
    /// Inner authority name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "authorityLocalized", skip_serializing_if = "Option::is_none")]
    pub authority_localized: Option<String>,
    /// The not-self theme that signals being out of alignment. Always English, whatever the lang parameter says. Use notSelfLocalized for anything a reader sees.
    #[serde(rename = "notSelf")]
    pub not_self: String,
    /// Not-self theme name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "notSelfLocalized", skip_serializing_if = "Option::is_none")]
    pub not_self_localized: Option<String>,
    /// Profile from the Personality Sun line over the Design Sun line.
    pub profile: String,
    /// The signature feeling of living in alignment. Always English, whatever the lang parameter says. Use signatureLocalized for anything a reader sees.
    pub signature: String,
    /// Signature theme name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "signatureLocalized", skip_serializing_if = "Option::is_none")]
    pub signature_localized: Option<String>,
    /// The aura strategy for engaging life correctly for this type. Always English, whatever the lang parameter says. Use strategyLocalized for anything a reader sees.
    pub strategy: String,
    /// How to actually apply the strategy. The strategy field alone is a bare label such as Respond or Inform; this is the operating instruction behind it.
    #[serde(rename = "strategyDescription")]
    pub strategy_description: String,
    /// Strategy name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "strategyLocalized", skip_serializing_if = "Option::is_none")]
    pub strategy_localized: Option<String>,
    /// Human Design energy type. One of Manifestor, Generator, Manifesting Generator, Projector, Reflector. Always English, whatever the lang parameter says, so it stays safe to compare against in code. Use typeLocalized for anything a reader sees.
    pub r#type: String,
    /// What the aura of this type does and how it is designed to engage life. The grounding text for the type label, so a consuming agent does not have to supply the meaning itself.
    #[serde(rename = "typeDescription")]
    pub type_description: String,
    /// Energy type name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "typeLocalized", skip_serializing_if = "Option::is_none")]
    pub type_localized: Option<String>,
}
/// Request body of `castCareerSpread`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CastCareerSpreadRequest {
    /// Optional querent question to focus the career spread. It is echoed back on the reading and gives the seven career positions their context. Omit for general work and vocation guidance.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub question: Option<String>,
    /// Optional seed for reproducible results. The same seed always draws the same seven cards into the same career positions, which is what lets a reading be shared or re-rendered. Omit for a random draw.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
}
/// Request body of `castCelticCross`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CastCelticCrossRequest {
    /// Optional querent question to focus the Celtic Cross. It is echoed back on the reading and gives the ten positions their context. Omit for a general reading of the situation.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub question: Option<String>,
    /// Optional seed for reproducible results. The same seed always draws the same ten cards into the same Celtic Cross positions, which is what lets a reading be shared or re-rendered. Omit for a random draw.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
}
/// Request body of `castDailyReading`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CastDailyReadingRequest {
    /// Date for the reading in YYYY-MM-DD format. Defaults to today (UTC). Useful for viewing past daily readings or pre-generating future ones.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Optional seed for reproducible readings. Same seed + same date = same hexagram every time. Pass any unique identifier (userId, email hash, session token) to give each user their own hexagram for the day. Without a seed every caller receives the same shared hexagram of the day.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
}
/// Request body of `castLoveSpread`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CastLoveSpreadRequest {
    /// Optional querent question to focus the love spread. It is echoed back on the reading and gives the five relationship positions their context. Omit for general relationship guidance.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub question: Option<String>,
    /// Optional seed for reproducible results. The same seed always draws the same five cards into the same love positions, which is what lets a reading be shared or re-rendered. Omit for a random draw.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
}
/// Request body of `castThreeCard`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CastThreeCardRequest {
    /// Optional specific question to focus the reading. Examples: "What should I know about my relationship?", "How can I improve my finances?", "What is blocking my creative growth?" Leave empty for general guidance.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub question: Option<String>,
    /// Optional seed for reproducible results. Same seed = same 3 cards in same positions. Useful for sharing readings, testing, or ensuring users get consistent results. Omit for random draws.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
}
/// Request body of `castYesNo`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CastYesNoRequest {
    /// Your specific yes/no question. Be clear and focused. Good: "Should I move to a new city?" Bad: "What should I do about my life?" The more specific the question, the more useful the tarot guidance.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub question: Option<String>,
    /// Optional seed for reproducible results. Same seed + same question = same answer. Useful for testing, sharing readings, or ensuring consistency. Omit for random draws each time.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
}
/// Request body of `checkKarmicDebt`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct CheckKarmicDebtRequest {
    /// Birth day (checks Birth Day on its own, and Life Path with year and month)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub day: Option<i64>,
    /// Full birth name (checks Expression, Soul Urge, Personality). A name in any script is converted to Latin letters before it is counted, Cyrillic and Greek as the passport spelling and accents folded to the base letter, and the calculation lists the letters counted. For a script that does not write its vowels, send the Latin spelling the person uses.
    #[serde(rename = "fullName", skip_serializing_if = "Option::is_none")]
    pub full_name: Option<String>,
    /// Birth month (checks Life Path)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub month: Option<i64>,
    /// Birth year (checks Life Path)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i64>,
}
/// Request body of `drawCards`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct DrawCardsRequest {
    /// Whether same card can be drawn multiple times. Set false for traditional deck behavior (each card drawn only once). Set true for statistical analysis or oracle-style readings. Default: false.
    #[serde(rename = "allowDuplicates", skip_serializing_if = "Option::is_none")]
    pub allow_duplicates: Option<bool>,
    /// Whether cards can appear reversed (upside down). Reversed cards have different meanings. Set false for upright-only readings. Default: true (50% chance of reversal per card).
    #[serde(rename = "allowReversals", skip_serializing_if = "Option::is_none")]
    pub allow_reversals: Option<bool>,
    /// Number of cards to draw (1-78). Common values: 1 for daily card, 3 for past-present-future, 5 for relationship spread, 10 for Celtic Cross. Drawing 78 returns the entire shuffled deck.
    pub count: i64,
    /// Optional seed for reproducible results. Same seed = same cards in same order. Use format like "userId-date" for daily consistency, or "readingId" for shareable readings. Omit for true randomness.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
}
/// Request body of `generateNumerologyChart`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GenerateNumerologyChartRequest {
    /// Calendar year for the Personal Year, defaults to the current UTC year. It moves the Personal Year only: the nested personalMonth and maturityStatus.currentAge always read the current UTC date.
    #[serde(rename = "currentYear", skip_serializing_if = "Option::is_none")]
    pub current_year: Option<i64>,
    /// Birth day (1-31)
    pub day: i64,
    /// Full birth name as it appears on the birth certificate. Used for every letter-based number in the chart: Expression, Soul Urge, Personality, Karmic Lessons, Hidden Passion, Subconscious Self and the special letters. A name in any script is converted to Latin letters before it is counted, Cyrillic and Greek as the passport spelling and accents folded to the base letter, and the calculation lists the letters counted. For a script that does not write its vowels, send the Latin spelling the person uses.
    #[serde(rename = "fullName")]
    pub full_name: String,
    /// Birth month (1-12)
    pub month: i64,
    /// Birth year between 100 and 2100. Supports historical figures like Einstein (1879) and Shakespeare (1564).
    pub year: i64,
}
/// Response body of `getAztecDaySign`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAztecDaySignResponse {
    /// World direction the sign belongs to: east, north, west or south. The twenty run through the four quarters in strict rotation, so every fourth sign shares a quarter.
    pub direction: String,
    /// What the sign is about, as a clause rather than a sentence, because it is spliced into composed prose elsewhere in the API. Translated in place.
    pub essence: String,
    /// What the sign name means, translated in place because it is a common noun. Where several English renderings are in circulation all of them are given rather than one being picked.
    pub gloss: String,
    /// The one thing worth doing differently under this sign.
    pub guidance: String,
    /// Machine identifier of the day sign, always lowercase ASCII Nahuatl whatever the lang parameter says, so it stays safe to compare against and to use as a path parameter. The twenty ids run cipactli, ehecatl, calli, cuetzpalin, coatl, miquiztli, mazatl, tochtli, atl, itzcuintli, ozomahtli, malinalli, acatl, ocelotl, cuauhtli, cozcacuauhtli, ollin, tecpatl, quiahuitl, xochitl.
    pub id: String,
    /// The sign in one composed sentence, built from the components above.
    pub keynote: String,
    /// Display name in Nahuatl with the vowel length marks the reference tables print. A proper noun carried as data, identical under every lang.
    #[serde(rename = "nameNahuatl")]
    pub name_nahuatl: String,
    /// Place in the twenty sign sequence, 1 to 20, counting Cipactli as 1. The sequence never varies and is what the trecenas are indexed against.
    pub position: f64,
}
/// Response body of `getAztecTrecena`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetAztecTrecenaResponse {
    /// Days in the period. Always 13, which is what the word trecena means.
    pub length: f64,
    /// Which of the twenty thirteen day periods this is, 1 to 20. Trecena 1 opens on 1 Cipactli and the openers step thirteen signs at a time from there.
    pub number: f64,
    /// The composed reading of the period, built from the sign it opens on rather than stored, so the two can never drift apart. No patron deity is named, because two of the twenty published patrons are disputed and none ships rather than eighteen shipping beside two guesses.
    pub reading: String,
    /// Machine identifier of the day sign the period opens on.
    #[serde(rename = "startSign")]
    pub start_sign: String,
    /// Display name of the sign the period opens on. A proper noun carried as data.
    #[serde(rename = "startSignName")]
    pub start_sign_name: String,
}
/// Response body of `getCenter`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCenterResponse {
    /// Whether this is an awareness center.
    pub awareness: bool,
    /// What this center means when defined: a consistent, reliable energy or awareness.
    #[serde(rename = "definedMeaning")]
    pub defined_meaning: String,
    /// Center identifier.
    pub id: String,
    /// Whether this is a motor center.
    pub motor: bool,
    /// Display name of the center. Always English, whatever the lang parameter says. Use nameLocalized for anything a reader sees.
    pub name: String,
    /// Center name in the requested language, for display only. Present only when lang is set to a language other than English, since in English it would repeat its canonical partner field exactly. Never compare against this value, compare against the canonical field beside it.
    #[serde(rename = "nameLocalized", skip_serializing_if = "Option::is_none")]
    pub name_localized: Option<String>,
    /// What this center means when undefined and open: a place of conditioning and learning.
    #[serde(rename = "undefinedMeaning")]
    pub undefined_meaning: String,
}
/// Path and query parameters of `getCitiesByCountry`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCitiesByCountryParams {
    /// ISO 3166-1 alpha-2 country code, case-insensitive. Common codes: DE (Germany), FR (France), GB (United Kingdom), US (United States), ES (Spain), IT (Italy), NL (Netherlands), IN (India), BR (Brazil), JP (Japan).
    pub iso2: String,
    /// Maximum items to return per page. Range: 1-100, default 20.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
}
/// Request body of `getCriticalDays`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetCriticalDaysRequest {
    /// Birth date of the person in YYYY-MM-DD format.
    #[serde(rename = "birthDate")]
    pub birth_date: String,
    /// End date of the search range in YYYY-MM-DD format. Defaults to startDate + 90 days. Maximum range: 180 days.
    #[serde(rename = "endDate", skip_serializing_if = "Option::is_none")]
    pub end_date: Option<String>,
    /// Start date of the search range in YYYY-MM-DD format. Defaults to today (UTC).
    #[serde(rename = "startDate", skip_serializing_if = "Option::is_none")]
    pub start_date: Option<String>,
}
/// Request body of `getDailyAngelNumber`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetDailyAngelNumberRequest {
    /// Date for the reading in YYYY-MM-DD format. Defaults to today (UTC). Useful for viewing past daily readings or pre-generating future ones.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Optional seed for reproducible readings. Same seed + same date = same angel number every time. Pass any unique identifier (userId, email hash, session token) to give each user their own angel number for the day. Without a seed every caller receives the same shared angel number of the day.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
}
/// Request body of `getDailyBiorhythm`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetDailyBiorhythmRequest {
    /// Date for the reading in YYYY-MM-DD format. Defaults to today (UTC). Useful for viewing past daily readings or pre-generating future ones.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Optional seed for reproducible readings. Same seed + same date = same reading every time. Pass any unique identifier (userId, email hash, session token) to give each user their own reading for the day. Without a seed every caller receives the same shared reading of the day.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
}
/// Request body of `getDailyCard`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetDailyCardRequest {
    /// Date for the reading in YYYY-MM-DD format. Defaults to today (UTC). Useful for viewing past daily readings or pre-generating future ones.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Optional seed for reproducible readings. Same seed + same date = same card every time. Pass any unique identifier (userId, email hash, session token) to give each user their own card for the day. Without a seed every caller receives the same shared card of the day.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
}
/// Request body of `getDailyCrystal`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetDailyCrystalRequest {
    /// Date for the reading in YYYY-MM-DD format. Defaults to today (UTC). Useful for viewing past daily readings or pre-generating future ones.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Optional seed for reproducible readings. Same seed + same date = same crystal every time. Pass any unique identifier (userId, email hash, session token) to give each user their own crystal for the day. Without a seed every caller receives the same shared crystal of the day.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
}
/// Response body of `getDailyCrystal`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDailyCrystalResponse {
    /// Positive affirmation aligned with the selected crystal. Use for daily affirmation features and meditation guidance.
    pub affirmation: String,
    /// Chakra energy centers this crystal resonates with for energy healing practice.
    pub chakras: Vec<String>,
    /// The date used for crystal selection (UTC).
    pub date: String,
    /// Overview of the crystal covering primary healing purpose and benefits.
    pub description: String,
    /// URL-safe identifier. Call /crystals/{id} for full healing properties.
    pub id: String,
    /// URL to crystal photograph. Use for daily crystal card display and visual features.
    #[serde(rename = "imageUrl")]
    pub image_url: Option<String>,
    /// Display name of the crystal selected for this date.
    pub name: String,
    /// Computed seed used for this reading. Same seed always produces the same crystal.
    pub seed: String,
    /// Zodiac signs this crystal is traditionally associated with. Null when zodiac data is unavailable.
    #[serde(rename = "zodiacSigns")]
    pub zodiac_signs: Option<Vec<String>>,
}
/// Request body of `getDailyDreamSymbol`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetDailyDreamSymbolRequest {
    /// Date for the reading in YYYY-MM-DD format. Defaults to today (UTC). Useful for viewing past daily readings or pre-generating future ones.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Optional seed for reproducible readings. Same seed + same date = same symbol every time. Pass any unique identifier (userId, email hash, session token) to give each user their own symbol for the day. Without a seed every caller receives the same shared symbol of the day.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
}
/// Request body of `getDailyHexagram`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetDailyHexagramRequest {
    /// Date for the reading in YYYY-MM-DD format. Defaults to today (UTC). Useful for viewing past daily readings or pre-generating future ones.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Optional seed for reproducible readings. Same seed + same date = same hexagram every time. Pass any unique identifier (userId, email hash, session token) to give each user their own hexagram for the day. Without a seed every caller receives the same shared hexagram of the day.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
}
/// Request body of `getDailyNumber`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetDailyNumberRequest {
    /// Date for the reading in YYYY-MM-DD format. Defaults to today (UTC). Useful for viewing past daily readings or pre-generating future ones.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Optional seed for reproducible readings. Same seed + same date = same number every time. Pass any unique identifier (userId, email hash, session token) to give each user their own number for the day. Without a seed every caller receives the same shared number of the day.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub seed: Option<String>,
}
/// Path and query parameters of `getDreamSymbol`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetDreamSymbolParams {
    /// Unique symbol identifier in kebab-case (e.g., "snake", "chase-dreams", "losing-teeth").
    pub id: String,
}
/// Request body of `getForecast`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetForecastRequest {
    /// Birth date of the person in YYYY-MM-DD format.
    #[serde(rename = "birthDate")]
    pub birth_date: String,
    /// End date of the forecast range in YYYY-MM-DD format. Defaults to startDate + 30 days. Maximum range: 90 days.
    #[serde(rename = "endDate", skip_serializing_if = "Option::is_none")]
    pub end_date: Option<String>,
    /// Start date of the forecast range in YYYY-MM-DD format. Defaults to today (UTC).
    #[serde(rename = "startDate", skip_serializing_if = "Option::is_none")]
    pub start_date: Option<String>,
}
/// Response body of `getHaabMonth`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetHaabMonthResponse {
    /// What the period name means, translated in place because it is a common noun rather than a name.
    pub gloss: String,
    /// Machine identifier of the Haab period, always lowercase ASCII, so it stays safe to compare against and to use as a path parameter. The nineteen ids run pop, wo, sip, sotz, sek, xul, yaxkin, mol, chen, yax, sak, keh, mak, kankin, muwan, pax, kayab, kumku, wayeb.
    pub id: String,
    /// Days in the period. Twenty for the eighteen months and five for Wayebʼ, which is never twenty. Days inside a period are numbered from 0, so a twenty day period runs 0 to 19.
    pub length: f64,
    /// The sixteenth century Yucatec spelling, which is the form most printed tables use.
    #[serde(rename = "nameClassic")]
    pub name_classic: String,
    /// Display name in the standard orthography. A proper noun carried as data, identical under every lang.
    #[serde(rename = "nameYucatec")]
    pub name_yucatec: String,
    /// Place in the Haab year, 1 to 19. Pop is 1 and Wayebʼ is 19, so a position of 19 always means the five short days.
    pub position: f64,
    /// The composed reading of the period, built from its position, its length and its gloss.
    pub reading: String,
}
/// Path and query parameters of `getKpAyanamsa`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetKpAyanamsaParams {
    /// Date for ayanamsa calculation in YYYY-MM-DD format. Defaults to today if not provided. Ayanamsa changes by ~0.01 degrees per month due to the precession of Earth.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<String>,
    /// Time of day in 24-hour HH:MM:SS format, interpreted in the timezone below. Omit for midnight UTC. The ayanamsa moves about 0.14 arcseconds across a day, so supplying the time matters only when reconciling a chart against reference software to the arcsecond.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub time: Option<String>,
    /// IANA name (e.g. "Asia/Kolkata", "America/New_York"), decimal hours (e.g. 5.5 for IST, -5 for EST), or a fixed UTC offset (e.g. "+05:30"). IANA resolved to the offset in force at the given date and the time field above. Defaults to 0 (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
}
/// Request body of `getMonthlyTropicalEphemeris`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetMonthlyTropicalEphemerisRequest {
    /// Month number (1-12) for the ephemeris. Defaults to the current month (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub month: Option<i64>,
    /// Year for the monthly ephemeris (1551 to 2649). Defaults to the current year (UTC).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub year: Option<i64>,
}
/// Request body of `getPhases`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetPhasesRequest {
    /// Birth date of the person in YYYY-MM-DD format.
    #[serde(rename = "birthDate")]
    pub birth_date: String,
    /// Date to get phase information for in YYYY-MM-DD format. Defaults to today (UTC).
    #[serde(rename = "targetDate", skip_serializing_if = "Option::is_none")]
    pub target_date: Option<String>,
}
/// Response body of `getRandomCrystal`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetRandomCrystalResponse {
    /// Positive affirmation aligned with the selected crystal energy.
    pub affirmation: String,
    /// Chakra energy centers this crystal resonates with.
    pub chakras: Vec<String>,
    /// Overview of the crystal covering primary healing purpose and benefits.
    pub description: String,
    /// URL-safe identifier. Call /crystals/{id} for full healing properties.
    pub id: String,
    /// URL to crystal photograph for visual display.
    #[serde(rename = "imageUrl")]
    pub image_url: Option<String>,
    /// Display name of the randomly selected crystal.
    pub name: String,
    /// Zodiac signs this crystal is traditionally associated with. Null when zodiac data is unavailable.
    #[serde(rename = "zodiacSigns")]
    pub zodiac_signs: Option<Vec<String>>,
}
/// Path and query parameters of `getRandomSymbols`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct GetRandomSymbolsParams {
    /// Number of random symbols to return (1-10). Default: 1.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub count: Option<i64>,
}
/// Request body of `getReading`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetReadingRequest {
    /// Birth date of the person in YYYY-MM-DD format. This is the anchor for all biorhythm cycle calculations.
    #[serde(rename = "birthDate")]
    pub birth_date: String,
    /// Date to calculate the reading for in YYYY-MM-DD format. Defaults to today (UTC) if omitted.
    #[serde(rename = "targetDate", skip_serializing_if = "Option::is_none")]
    pub target_date: Option<String>,
}
/// Response body of `getTrecena`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetTrecenaResponse {
    /// Days in the period. Always 13, which is what the word trecena means.
    pub length: f64,
    /// Which of the twenty thirteen day periods this is, 1 to 20. Trecena 1 opens on 1 Imix and the openers step thirteen signs at a time from there.
    pub number: f64,
    /// The composed reading of the period, built from the sign it opens on. Composed rather than stored, so it can never drift away from the day sign it is drawn from.
    pub reading: String,
    /// Machine identifier of the day sign the period opens on, which the tradition reads as colouring all thirteen of its days.
    #[serde(rename = "rulingSign")]
    pub ruling_sign: String,
    /// Kʼicheʼ name of the same sign, the vocabulary a highland reading uses.
    #[serde(rename = "rulingSignKiche")]
    pub ruling_sign_kiche: String,
    /// Display name of the sign the period opens on. A proper noun carried as data.
    #[serde(rename = "rulingSignName")]
    pub ruling_sign_name: String,
}
/// Response body of `getUsageStats`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct GetUsageStatsResponse {
    /// Billing email the subscription is registered under.
    pub email: String,
    /// ISO 8601 timestamp when the current billing period ends. A renewal extends this date in place. API access survives a cancelled or suspended status until this moment passes. This is a BILLING date, not a quota date: the monthly allowance resets on the 1st of each month independently of it.
    #[serde(rename = "endDate")]
    pub end_date: String,
    /// Name of the subscription plan the API key belongs to. One flat plan covers every domain and the Remote MCP servers, so this is a quota tier, never a per product entitlement.
    pub plan: String,
    /// Requests left before the monthly allowance is exhausted, floored at zero. Equal to requestsPerMonth minus usedThisMonth. Refills at the calendar month rollover, whose exact instant every API response carries as a Unix timestamp in the X-RateLimit-Reset header.
    #[serde(rename = "remainingThisMonth")]
    pub remaining_this_month: f64,
    /// Monthly request allowance for the plan. One request, API or MCP, equals one unit: there is no credit weighting and no per domain fee.
    #[serde(rename = "requestsPerMonth")]
    pub requests_per_month: f64,
    /// Subscription lifecycle state. Values: active, cancelled (no longer renewing but usable until endDate), suspended (payment failed, usable until endDate), expired (past endDate), pending (checkout started, payment not captured).
    pub status: String,
    /// Billable requests counted against the current calendar month. The quota window is the UTC calendar month and resets on the 1st at 12:00 AM UTC, never on your renewal date, so an annual plan refills every month and a plan bought mid month still refills on the 1st. Read from the durable request ledger, which can trail the live limiter by up to 5 minutes; for the exact live position read the X-RateLimit-Used header on any response, including this one. Cached responses still count; a request that failed on our side with a 5xx never does.
    #[serde(rename = "usedThisMonth")]
    pub used_this_month: f64,
}
/// Response body of `getKpAyanamsa`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct KPAyanamsaResponse {
    /// KP-Newcomb ayanamsa value in degrees
    pub ayanamsa: f64,
    /// UTC timestamp when calculation was performed
    pub calculated: String,
    /// Date for which ayanamsa was calculated
    pub date: String,
    /// Mathematical basis for ayanamsa calculation
    pub formula: String,
    /// The exact UTC instant the value was computed for, after applying the time and timezone. Echoed so a client reconciling to the arcsecond can confirm the moment rather than infer it from the date alone. Equals midnight UTC of the date when no time was supplied.
    pub instant: String,
    /// Ayanamsa type identifier
    pub r#type: String,
}
/// Path and query parameters of `listCountries`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct ListCountriesParams {
    /// Maximum items to return per page. Range: 1-250, default 50.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
}
/// Response body of `listCrystalColors`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListCrystalColorsResponse {
    /// Alphabetically sorted list of all unique crystal colors. Pass any value to the color filter on GET /crystals.
    pub colors: Vec<String>,
    /// Total number of unique color values in the database.
    pub count: f64,
}
/// Response body of `listCrystalPlanets`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct ListCrystalPlanetsResponse {
    /// Total number of unique planetary values in the database.
    pub count: f64,
    /// Alphabetically sorted list of all unique planetary associations. Pass any value to the planet filter on GET /crystals.
    pub planets: Vec<String>,
}
/// Response body of `getRashi`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct RashiResponse {
    /// Key personality traits and behavioral tendencies of natives born under this rashi.
    pub characteristics: String,
    /// Approximate sidereal date range when the Sun transits this rashi.
    #[serde(rename = "dateRange")]
    pub date_range: String,
    /// Aditya (solar deity) governing this rashi in Vedic tradition.
    pub energy: String,
    /// Unique slug identifier for the rashi. Used in URL paths and cross-references.
    pub id: String,
    /// Western zodiac sign name corresponding to this Vedic rashi.
    pub name: String,
    /// Traditional symbol associated with this zodiac sign.
    pub symbol: String,
    /// Sanskrit name of the rashi as used in Vedic astrology (Jyotish).
    #[serde(rename = "vedicName")]
    pub vedic_name: String,
}
/// Path and query parameters of `searchCities`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct SearchCitiesParams {
    /// Maximum items to return per page. Range: 1-50, default 10.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
    /// Place to search for, written the way a person would. Accepts a bare city (berlin), a city plus country (berlin germany), a comma-qualified place (richfield, utah), a fully qualified place (richfield, utah, united states), or a historic name (bombay, peking, constantinople). Commas are optional, and a qualifier the dataset spells differently, such as USA for United States, still resolves. Matched against city name, alternate names, state or province, and country. Add the state or country whenever the name is common, since that is what separates the six Springfields, and Richfield, Utah from Richfield, Minnesota.
    pub q: String,
}
/// Path and query parameters of `searchDreamSymbols`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[non_exhaustive]
pub struct SearchDreamSymbolsParams {
    /// Filter symbols by starting letter (a-z). Case-insensitive.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub letter: Option<String>,
    /// Maximum items to return per page. Range: 1-50, default 20.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<i64>,
    /// Number of items to skip for pagination. Default 0.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<i64>,
    /// Search query to match against symbol names and meanings. Case-insensitive.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub q: Option<String>,
}
/// Response body of `getTrigram`.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[non_exhaustive]
pub struct Trigram {
    /// Animal symbol associated with this trigram in classical I-Ching imagery and divination.
    pub animal: String,
    /// Core attribute or quality this trigram represents in I-Ching philosophy (e.g., Creative, Receptive, Arousing).
    pub attribute: String,
    /// Three-digit binary representation of the trigram lines (bottom to top). 1 = yang (solid), 0 = yin (broken).
    pub binary: String,
    /// Body part associated with this trigram in traditional Chinese medicine and I-Ching body mapping.
    #[serde(rename = "bodyPart")]
    pub body_part: String,
    /// Original Chinese character name of the trigram in traditional script.
    pub chinese: String,
    /// Compass direction in the King Wen (Later Heaven) Bagua arrangement. Used in feng shui spatial analysis.
    pub direction: String,
    /// Five element (Wu Xing) correspondence: Metal, Wood, Water, Fire, or Earth. Used in Chinese metaphysics and feng shui analysis.
    pub element: String,
    /// English name representing the natural force or element this trigram embodies.
    pub english: String,
    /// Family archetype in the Bagua system. Each trigram corresponds to a family role (Father, Mother, First Son, First Daughter, etc.).
    #[serde(rename = "familyMember")]
    pub family_member: String,
    /// Concise interpretation of the trigram covering its symbolic meaning, key associations, and guidance for understanding hexagrams containing this trigram.
    pub meaning: String,
    /// Stable identifier for the trigram, 1 to 8. This is our lookup key, not a canonical sequence: the tradition has several orderings (King Wen, Fu Xi, Earlier and Later Heaven) and they disagree, so do not read ranking or precedence into it.
    pub number: f64,
    /// Pinyin romanization of the Chinese name with tone marks for correct pronunciation.
    pub pinyin: String,
    /// Energetic quality describing the dynamic nature of this trigram (e.g., Strong, Devoted, Joyous, Gentle).
    pub quality: String,
    /// Season or time period associated with this trigram in the annual cycle of Chinese cosmology.
    pub season: String,
    /// Unicode trigram symbol (three lines) for visual display in I-Ching interfaces and Bagua diagrams.
    pub symbol: String,
}
impl YogaDetectRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: YogaDetectRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: YogaDetectRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl UpagrahaRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: UpagrahaRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: UpagrahaRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl TransitsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            date: Default::default(),
            natal_chart: Default::default(),
            node_type: Default::default(),
            time: Default::default(),
            timezone: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `natalChart`.
    #[must_use]
    pub fn with_natal_chart(mut self, value: TransitsRequestNatalChart) -> Self {
        self.natal_chart = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: TransitsRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
    /// Sets `time`.
    #[must_use]
    pub fn with_time(mut self, value: String) -> Self {
        self.time = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: TransitsRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl TransitsRequestNatalChart {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        timezone: TransitsRequestNatalChartTimezone,
    ) -> Self {
        Self {
            date,
            latitude,
            longitude,
            time,
            timezone,
        }
    }
}
impl SolarArcRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        timezone: SolarArcRequestTimezone,
        target_date: String,
    ) -> Self {
        Self {
            date,
            latitude,
            longitude,
            node_type: Default::default(),
            target_date,
            time,
            timezone,
        }
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: SolarArcRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl ShadbalaRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: ShadbalaRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: ShadbalaRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl SearchCrystalsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(q: String) -> Self {
        Self {
            lang: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
            q,
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: SearchCrystalsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl SadhesatiRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: SadhesatiRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: SadhesatiRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl RelocationChartRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: RelocationChartRequestTimezone,
        birth_latitude: f64,
        birth_longitude: f64,
        relocation_latitude: f64,
        relocation_longitude: f64,
    ) -> Self {
        Self {
            birth_latitude,
            birth_longitude,
            date,
            house_system: Default::default(),
            relocation_latitude,
            relocation_longitude,
            time,
            timezone,
        }
    }
    /// Sets `houseSystem`.
    #[must_use]
    pub fn with_house_system(
        mut self,
        value: RelocationChartRequestHouseSystem,
    ) -> Self {
        self.house_system = Some(value);
        self
    }
}
impl ProgressionsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        timezone: ProgressionsRequestTimezone,
        target_date: String,
    ) -> Self {
        Self {
            date,
            latitude,
            longitude,
            node_type: Default::default(),
            target_date,
            time,
            timezone,
        }
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: ProgressionsRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl ProfectionsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        timezone: ProfectionsRequestTimezone,
        target_date: String,
    ) -> Self {
        Self {
            date,
            house_system: Default::default(),
            latitude,
            longitude,
            node_type: Default::default(),
            target_date,
            time,
            timezone,
        }
    }
    /// Sets `houseSystem`.
    #[must_use]
    pub fn with_house_system(mut self, value: ProfectionsRequestHouseSystem) -> Self {
        self.house_system = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: ProfectionsRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl PlanetaryPositionsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: PlanetaryPositionsRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: PlanetaryPositionsRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl PapasamyamRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        person1: PapasamyamRequestPerson1,
        person2: PapasamyamRequestPerson2,
    ) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            person1,
            person2,
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: PapasamyamRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
}
impl PapasamyamRequestPerson2 {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            date,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: PapasamyamRequestPerson2Timezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl PapasamyamRequestPerson1 {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            date,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: PapasamyamRequestPerson1Timezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl NavamsaRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: NavamsaRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: NavamsaRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl NatalChartRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        timezone: NatalChartRequestTimezone,
    ) -> Self {
        Self {
            date,
            house_system: Default::default(),
            latitude,
            longitude,
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `houseSystem`.
    #[must_use]
    pub fn with_house_system(mut self, value: NatalChartRequestHouseSystem) -> Self {
        self.house_system = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: NatalChartRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl ManglikRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: ManglikRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: ManglikRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl LookupHexagramParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(lines: String) -> Self {
        Self {
            lang: Default::default(),
            lines,
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: LookupHexagramParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl LookupAuspiciousDaysRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        activity: LookupAuspiciousDaysRequestActivity,
        start_date: String,
        end_date: String,
    ) -> Self {
        Self {
            activity,
            avoid_animal: Default::default(),
            end_date,
            start_date,
        }
    }
    /// Sets `avoidAnimal`.
    #[must_use]
    pub fn with_avoid_animal(
        mut self,
        value: LookupAuspiciousDaysRequestAvoidAnimal,
    ) -> Self {
        self.avoid_animal = Some(value);
        self
    }
}
impl LookupAuspiciousDaysParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: LookupAuspiciousDaysParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl ListZodiacSignsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListZodiacSignsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl ListZodiacAnimalsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListZodiacAnimalsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl ListYogasParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            family: Default::default(),
            lang: Default::default(),
        }
    }
    /// Sets `family`.
    #[must_use]
    pub fn with_family(mut self, value: ListYogasParamsFamily) -> Self {
        self.family = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListYogasParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl ListTrigramsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListTrigramsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl ListTrecenasParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListTrecenasParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl ListSolarTermsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(year: i64) -> Self {
        Self {
            lang: Default::default(),
            year,
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListSolarTermsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl ListShemNamesParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            limit: Default::default(),
            longitude: Default::default(),
            offset: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListShemNamesParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl ListRashisParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListRashisParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl ListRasasParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListRasasParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl ListPlanetMeaningsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListPlanetMeaningsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl ListNinePeriodsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            date: Default::default(),
            lang: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListNinePeriodsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl ListNakshatrasParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListNakshatrasParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl ListMayanDaySignsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            direction_scheme: Default::default(),
            lang: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
        }
    }
    /// Sets `directionScheme`.
    #[must_use]
    pub fn with_direction_scheme(
        mut self,
        value: ListMayanDaySignsParamsDirectionScheme,
    ) -> Self {
        self.direction_scheme = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListMayanDaySignsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl ListHexagramsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListHexagramsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl ListHebrewLettersParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            letter_attribution: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListHebrewLettersParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `letterAttribution`.
    #[must_use]
    pub fn with_letter_attribution(
        mut self,
        value: ListHebrewLettersParamsLetterAttribution,
    ) -> Self {
        self.letter_attribution = Some(value);
        self
    }
}
impl ListHaabMonthsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListHaabMonthsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl ListGunasParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListGunasParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl ListGematriaCiphersParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListGematriaCiphersParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl ListFlyingStarsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListFlyingStarsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl ListFiveElementsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListFiveElementsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl ListDoshasParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListDoshasParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl ListDikpalaDirectionsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListDikpalaDirectionsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl ListDevatasParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListDevatasParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl ListCrystalsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            chakra: Default::default(),
            color: Default::default(),
            element: Default::default(),
            lang: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
            planet: Default::default(),
            zodiac: Default::default(),
        }
    }
    /// Sets `chakra`.
    #[must_use]
    pub fn with_chakra(mut self, value: ListCrystalsParamsChakra) -> Self {
        self.chakra = Some(value);
        self
    }
    /// Sets `color`.
    #[must_use]
    pub fn with_color(mut self, value: String) -> Self {
        self.color = Some(value);
        self
    }
    /// Sets `element`.
    #[must_use]
    pub fn with_element(mut self, value: ListCrystalsParamsElement) -> Self {
        self.element = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListCrystalsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
    /// Sets `planet`.
    #[must_use]
    pub fn with_planet(mut self, value: String) -> Self {
        self.planet = Some(value);
        self
    }
    /// Sets `zodiac`.
    #[must_use]
    pub fn with_zodiac(mut self, value: ListCrystalsParamsZodiac) -> Self {
        self.zodiac = Some(value);
        self
    }
}
impl ListCrystalPlanetsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListCrystalPlanetsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl ListCrystalColorsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListCrystalColorsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl ListCardsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            arcana: Default::default(),
            lang: Default::default(),
            limit: Default::default(),
            number: Default::default(),
            offset: Default::default(),
            suit: Default::default(),
        }
    }
    /// Sets `arcana`.
    #[must_use]
    pub fn with_arcana(mut self, value: ListCardsParamsArcana) -> Self {
        self.arcana = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListCardsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `number`.
    #[must_use]
    pub fn with_number(mut self, value: i64) -> Self {
        self.number = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
    /// Sets `suit`.
    #[must_use]
    pub fn with_suit(mut self, value: ListCardsParamsSuit) -> Self {
        self.suit = Some(value);
        self
    }
}
impl ListBaguaSectorsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListBaguaSectorsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl ListAztecTrecenasParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListAztecTrecenasParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl ListAztecDaySignsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListAztecDaySignsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl ListAvasthasParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            system: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListAvasthasParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `system`.
    #[must_use]
    pub fn with_system(mut self, value: ListAvasthasParamsSystem) -> Self {
        self.system = Some(value);
        self
    }
}
impl ListAngelNumbersParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
            r#type: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ListAngelNumbersParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
    /// Sets `type`.
    #[must_use]
    pub fn with_type(mut self, value: ListAngelNumbersParamsType) -> Self {
        self.r#type = Some(value);
        self
    }
}
impl LilithRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        timezone: LilithRequestTimezone,
    ) -> Self {
        Self {
            date,
            house_system: Default::default(),
            latitude,
            longitude,
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `houseSystem`.
    #[must_use]
    pub fn with_house_system(mut self, value: LilithRequestHouseSystem) -> Self {
        self.house_system = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: LilithRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl KalsarpaRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: KalsarpaRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: KalsarpaRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl KPSublordChangesRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        planet: KPSublordChangesRequestPlanet,
        start_date: String,
        end_date: String,
    ) -> Self {
        Self {
            ayanamsa: Default::default(),
            end_date,
            node_type: Default::default(),
            planet,
            start_date,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: KPSublordChangesRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: KPSublordChangesRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: KPSublordChangesRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl KPRasiChangesRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        planet: KPRasiChangesRequestPlanet,
        start_date: String,
        end_date: String,
    ) -> Self {
        Self {
            ayanamsa: Default::default(),
            end_date,
            node_type: Default::default(),
            planet,
            start_date,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: KPRasiChangesRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: KPRasiChangesRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: KPRasiChangesRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl KPPlanetsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            node_type: Default::default(),
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: KPPlanetsRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: KPPlanetsRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: KPPlanetsRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl KPPlanetsIntervalRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        start_datetime: String,
        end_datetime: String,
        interval_minutes: f64,
        latitude: f64,
        longitude: f64,
    ) -> Self {
        Self {
            ayanamsa: Default::default(),
            end_datetime,
            interval_minutes,
            latitude,
            longitude,
            node_type: Default::default(),
            start_datetime,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: KPPlanetsIntervalRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: KPPlanetsIntervalRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: KPPlanetsIntervalRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl KPHoraryRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        horary_number: i64,
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
    ) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            horary_number,
            latitude,
            longitude,
            node_type: Default::default(),
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: KPHoraryRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: KPHoraryRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: KPHoraryRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl KPDailyFinanceRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        birth_date: String,
        birth_time: String,
        latitude: f64,
        longitude: f64,
    ) -> Self {
        Self {
            ayanamsa: Default::default(),
            birth_date,
            birth_time,
            date: Default::default(),
            gain_houses: Default::default(),
            latitude,
            longitude,
            loss_houses: Default::default(),
            node_type: Default::default(),
            time: Default::default(),
            timezone: Default::default(),
            weights: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: KPDailyFinanceRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `gainHouses`.
    #[must_use]
    pub fn with_gain_houses(mut self, value: Vec<i64>) -> Self {
        self.gain_houses = Some(value);
        self
    }
    /// Sets `lossHouses`.
    #[must_use]
    pub fn with_loss_houses(mut self, value: Vec<i64>) -> Self {
        self.loss_houses = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: KPDailyFinanceRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
    /// Sets `time`.
    #[must_use]
    pub fn with_time(mut self, value: String) -> Self {
        self.time = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: KPDailyFinanceRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
    /// Sets `weights`.
    #[must_use]
    pub fn with_weights(mut self, value: KPDailyFinanceRequestWeights) -> Self {
        self.weights = Some(value);
        self
    }
}
impl KPDailyFinanceRequestWeights {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(cusps: f64, dasha: f64, ruling_planets: f64, moon_windows: f64) -> Self {
        Self {
            cusps,
            dasha,
            moon_windows,
            ruling_planets,
        }
    }
}
impl KPCuspsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: KPCuspsRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: KPCuspsRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl KPChartRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            node_type: Default::default(),
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: KPChartRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: KPChartRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: KPChartRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl HeliacalRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, latitude: f64, longitude: f64) -> Self {
        Self {
            date,
            latitude,
            longitude,
            timezone: Default::default(),
        }
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: HeliacalRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetZodiacSignParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: String) -> Self {
        Self {
            id,
            lang: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetZodiacSignParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetZodiacCompatibilityParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        sign1: GetZodiacCompatibilityParamsSign1,
        sign2: GetZodiacCompatibilityParamsSign2,
    ) -> Self {
        Self {
            lang: Default::default(),
            sign1,
            sign2,
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetZodiacCompatibilityParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetZodiacAnimalParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: GetZodiacAnimalParamsId) -> Self {
        Self {
            id,
            lang: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetZodiacAnimalParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetYogaParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: GetYogaParamsId) -> Self {
        Self {
            id,
            lang: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetYogaParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetYearlyHoroscopeParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(sign: GetYearlyHoroscopeParamsSign) -> Self {
        Self {
            lang: Default::default(),
            sign,
            timezone: Default::default(),
            year: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetYearlyHoroscopeParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: String) -> Self {
        self.timezone = Some(value);
        self
    }
    /// Sets `year`.
    #[must_use]
    pub fn with_year(mut self, value: i64) -> Self {
        self.year = Some(value);
        self
    }
}
impl GetWeeklyHoroscopeParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(sign: GetWeeklyHoroscopeParamsSign) -> Self {
        Self {
            date: Default::default(),
            lang: Default::default(),
            sign,
            timezone: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetWeeklyHoroscopeParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: String) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetVedicDailyReadingRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        birth_date: String,
        birth_time: String,
        latitude: f64,
        longitude: f64,
    ) -> Self {
        Self {
            birth_date,
            birth_time,
            date: Default::default(),
            latitude,
            longitude,
            node_type: Default::default(),
            timezone: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: GetVedicDailyReadingRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: GetVedicDailyReadingRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetVedicDailyReadingParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            focus: Default::default(),
            lang: Default::default(),
        }
    }
    /// Sets `focus`.
    #[must_use]
    pub fn with_focus(mut self, value: GetVedicDailyReadingParamsFocus) -> Self {
        self.focus = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetVedicDailyReadingParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetUpcomingMoonPhasesParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            count: Default::default(),
            lang: Default::default(),
            start_date: Default::default(),
        }
    }
    /// Sets `count`.
    #[must_use]
    pub fn with_count(mut self, value: i64) -> Self {
        self.count = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetUpcomingMoonPhasesParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `startDate`.
    #[must_use]
    pub fn with_start_date(mut self, value: String) -> Self {
        self.start_date = Some(value);
        self
    }
}
impl GetTrigramParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: String) -> Self {
        Self {
            id,
            lang: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetTrigramParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetTreeOfLifeParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            letter_attribution: Default::default(),
            sephirot_system: Default::default(),
            tree_variant: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetTreeOfLifeParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `letterAttribution`.
    #[must_use]
    pub fn with_letter_attribution(
        mut self,
        value: GetTreeOfLifeParamsLetterAttribution,
    ) -> Self {
        self.letter_attribution = Some(value);
        self
    }
    /// Sets `sephirotSystem`.
    #[must_use]
    pub fn with_sephirot_system(
        mut self,
        value: GetTreeOfLifeParamsSephirotSystem,
    ) -> Self {
        self.sephirot_system = Some(value);
        self
    }
    /// Sets `treeVariant`.
    #[must_use]
    pub fn with_tree_variant(mut self, value: GetTreeOfLifeParamsTreeVariant) -> Self {
        self.tree_variant = Some(value);
        self
    }
}
impl GetTrecenaParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(number: i64) -> Self {
        Self {
            lang: Default::default(),
            number,
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetTrecenaParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetSubDashasRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            node_type: Default::default(),
            significators: Default::default(),
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: GetSubDashasRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: GetSubDashasRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
    /// Sets `significators`.
    #[must_use]
    pub fn with_significators(mut self, value: bool) -> Self {
        self.significators = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: GetSubDashasRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetSubDashasParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(mahadasha: GetSubDashasParamsMahadasha) -> Self {
        Self {
            focus: Default::default(),
            lang: Default::default(),
            mahadasha,
        }
    }
    /// Sets `focus`.
    #[must_use]
    pub fn with_focus(mut self, value: GetSubDashasParamsFocus) -> Self {
        self.focus = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetSubDashasParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetSookshmaDashasRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            node_type: Default::default(),
            significators: Default::default(),
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: GetSookshmaDashasRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: GetSookshmaDashasRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
    /// Sets `significators`.
    #[must_use]
    pub fn with_significators(mut self, value: bool) -> Self {
        self.significators = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: GetSookshmaDashasRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetSookshmaDashasParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        mahadasha: GetSookshmaDashasParamsMahadasha,
        antardasha: GetSookshmaDashasParamsAntardasha,
        pratyantardasha: GetSookshmaDashasParamsPratyantardasha,
    ) -> Self {
        Self {
            antardasha,
            focus: Default::default(),
            lang: Default::default(),
            mahadasha,
            pratyantardasha,
        }
    }
    /// Sets `focus`.
    #[must_use]
    pub fn with_focus(mut self, value: GetSookshmaDashasParamsFocus) -> Self {
        self.focus = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetSookshmaDashasParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetShemNameParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(number: i64) -> Self {
        Self {
            lang: Default::default(),
            number,
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetShemNameParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetSephirahParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: GetSephirahParamsId) -> Self {
        Self {
            id,
            lang: Default::default(),
            letter_attribution: Default::default(),
            sephirot_system: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetSephirahParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `letterAttribution`.
    #[must_use]
    pub fn with_letter_attribution(
        mut self,
        value: GetSephirahParamsLetterAttribution,
    ) -> Self {
        self.letter_attribution = Some(value);
        self
    }
    /// Sets `sephirotSystem`.
    #[must_use]
    pub fn with_sephirot_system(
        mut self,
        value: GetSephirahParamsSephirotSystem,
    ) -> Self {
        self.sephirot_system = Some(value);
        self
    }
}
impl GetRitucharyaParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetRitucharyaParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetReadingParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetReadingParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetRashiParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: GetRashiParamsId) -> Self {
        Self {
            id,
            lang: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetRashiParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetRandomHexagramParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetRandomHexagramParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetRandomCrystalParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetRandomCrystalParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetPratyantardashasRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            node_type: Default::default(),
            significators: Default::default(),
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: GetPratyantardashasRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: GetPratyantardashasRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
    /// Sets `significators`.
    #[must_use]
    pub fn with_significators(mut self, value: bool) -> Self {
        self.significators = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: GetPratyantardashasRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetPratyantardashasParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        mahadasha: GetPratyantardashasParamsMahadasha,
        antardasha: GetPratyantardashasParamsAntardasha,
    ) -> Self {
        Self {
            antardasha,
            focus: Default::default(),
            lang: Default::default(),
            mahadasha,
        }
    }
    /// Sets `focus`.
    #[must_use]
    pub fn with_focus(mut self, value: GetPratyantardashasParamsFocus) -> Self {
        self.focus = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetPratyantardashasParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetPranaDashasRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            node_type: Default::default(),
            significators: Default::default(),
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: GetPranaDashasRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: GetPranaDashasRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
    /// Sets `significators`.
    #[must_use]
    pub fn with_significators(mut self, value: bool) -> Self {
        self.significators = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: GetPranaDashasRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetPranaDashasParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        mahadasha: GetPranaDashasParamsMahadasha,
        antardasha: GetPranaDashasParamsAntardasha,
        pratyantardasha: GetPranaDashasParamsPratyantardasha,
        sookshma: GetPranaDashasParamsSookshma,
    ) -> Self {
        Self {
            antardasha,
            focus: Default::default(),
            lang: Default::default(),
            mahadasha,
            pratyantardasha,
            sookshma,
        }
    }
    /// Sets `focus`.
    #[must_use]
    pub fn with_focus(mut self, value: GetPranaDashasParamsFocus) -> Self {
        self.focus = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetPranaDashasParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetPlanetaryPositionsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        timezone: GetPlanetaryPositionsRequestTimezone,
    ) -> Self {
        Self {
            date,
            latitude,
            longitude,
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(
        mut self,
        value: GetPlanetaryPositionsRequestNodeType,
    ) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl GetPlanetaryPositionsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetPlanetaryPositionsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetPlanetaryNodePassagesRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(year: i64) -> Self {
        Self {
            timezone: Default::default(),
            year,
        }
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(
        mut self,
        value: GetPlanetaryNodePassagesRequestTimezone,
    ) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetPlanetaryNodePassagesParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetPlanetaryNodePassagesParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetPlanetPositionsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetPlanetPositionsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetPlanetMeaningParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: String) -> Self {
        Self {
            id,
            lang: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetPlanetMeaningParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetPhasesParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetPhasesParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetNumberMeaningParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(number: String) -> Self {
        Self {
            lang: Default::default(),
            number,
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetNumberMeaningParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetNakshatraParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: GetNakshatraParamsId) -> Self {
        Self {
            id,
            lang: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetNakshatraParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetMoonCalendarParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(year: i64, month: i64) -> Self {
        Self {
            lang: Default::default(),
            month,
            year,
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetMoonCalendarParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetMonthlyTzolkinCalendarParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            correlation: Default::default(),
            lang: Default::default(),
            month: Default::default(),
            year: Default::default(),
        }
    }
    /// Sets `correlation`.
    #[must_use]
    pub fn with_correlation(
        mut self,
        value: GetMonthlyTzolkinCalendarParamsCorrelation,
    ) -> Self {
        self.correlation = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetMonthlyTzolkinCalendarParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `month`.
    #[must_use]
    pub fn with_month(mut self, value: i64) -> Self {
        self.month = Some(value);
        self
    }
    /// Sets `year`.
    #[must_use]
    pub fn with_year(mut self, value: i64) -> Self {
        self.year = Some(value);
        self
    }
}
impl GetMonthlyTropicalTransitsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            month: Default::default(),
            node_type: Default::default(),
            timezone: Default::default(),
            year: Default::default(),
        }
    }
    /// Sets `month`.
    #[must_use]
    pub fn with_month(mut self, value: i64) -> Self {
        self.month = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(
        mut self,
        value: GetMonthlyTropicalTransitsRequestNodeType,
    ) -> Self {
        self.node_type = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(
        mut self,
        value: GetMonthlyTropicalTransitsRequestTimezone,
    ) -> Self {
        self.timezone = Some(value);
        self
    }
    /// Sets `year`.
    #[must_use]
    pub fn with_year(mut self, value: i64) -> Self {
        self.year = Some(value);
        self
    }
}
impl GetMonthlyTropicalTransitsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetMonthlyTropicalTransitsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetMonthlyTropicalEphemerisParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetMonthlyTropicalEphemerisParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetMonthlyTropicalAspectsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            month: Default::default(),
            node_type: Default::default(),
            timezone: Default::default(),
            year: Default::default(),
        }
    }
    /// Sets `month`.
    #[must_use]
    pub fn with_month(mut self, value: i64) -> Self {
        self.month = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(
        mut self,
        value: GetMonthlyTropicalAspectsRequestNodeType,
    ) -> Self {
        self.node_type = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(
        mut self,
        value: GetMonthlyTropicalAspectsRequestTimezone,
    ) -> Self {
        self.timezone = Some(value);
        self
    }
    /// Sets `year`.
    #[must_use]
    pub fn with_year(mut self, value: i64) -> Self {
        self.year = Some(value);
        self
    }
}
impl GetMonthlyTropicalAspectsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetMonthlyTropicalAspectsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetMonthlyTransitsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            coordinate_system: Default::default(),
            month: Default::default(),
            timezone: Default::default(),
            year: Default::default(),
        }
    }
    /// Sets `coordinateSystem`.
    #[must_use]
    pub fn with_coordinate_system(
        mut self,
        value: GetMonthlyTransitsRequestCoordinateSystem,
    ) -> Self {
        self.coordinate_system = Some(value);
        self
    }
    /// Sets `month`.
    #[must_use]
    pub fn with_month(mut self, value: i64) -> Self {
        self.month = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: GetMonthlyTransitsRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
    /// Sets `year`.
    #[must_use]
    pub fn with_year(mut self, value: i64) -> Self {
        self.year = Some(value);
        self
    }
}
impl GetMonthlyTransitsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetMonthlyTransitsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetMonthlyParallelsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            month: Default::default(),
            timezone: Default::default(),
            year: Default::default(),
        }
    }
    /// Sets `month`.
    #[must_use]
    pub fn with_month(mut self, value: i64) -> Self {
        self.month = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: GetMonthlyParallelsRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
    /// Sets `year`.
    #[must_use]
    pub fn with_year(mut self, value: i64) -> Self {
        self.year = Some(value);
        self
    }
}
impl GetMonthlyParallelsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetMonthlyParallelsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetMonthlyHoroscopeParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(sign: GetMonthlyHoroscopeParamsSign) -> Self {
        Self {
            date: Default::default(),
            lang: Default::default(),
            sign,
            timezone: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetMonthlyHoroscopeParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: String) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetMonthlyFlyingStarsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            month: Default::default(),
            year: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetMonthlyFlyingStarsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `month`.
    #[must_use]
    pub fn with_month(mut self, value: i64) -> Self {
        self.month = Some(value);
        self
    }
    /// Sets `year`.
    #[must_use]
    pub fn with_year(mut self, value: i64) -> Self {
        self.year = Some(value);
        self
    }
}
impl GetMonthlyEphemerisRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            coordinate_system: Default::default(),
            month: Default::default(),
            year: Default::default(),
        }
    }
    /// Sets `coordinateSystem`.
    #[must_use]
    pub fn with_coordinate_system(
        mut self,
        value: GetMonthlyEphemerisRequestCoordinateSystem,
    ) -> Self {
        self.coordinate_system = Some(value);
        self
    }
    /// Sets `month`.
    #[must_use]
    pub fn with_month(mut self, value: i64) -> Self {
        self.month = Some(value);
        self
    }
    /// Sets `year`.
    #[must_use]
    pub fn with_year(mut self, value: i64) -> Self {
        self.year = Some(value);
        self
    }
}
impl GetMonthlyEphemerisParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetMonthlyEphemerisParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetMonthlyDeclinationParallelsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            month: Default::default(),
            node_type: Default::default(),
            orb: Default::default(),
            timezone: Default::default(),
            year: Default::default(),
        }
    }
    /// Sets `month`.
    #[must_use]
    pub fn with_month(mut self, value: i64) -> Self {
        self.month = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(
        mut self,
        value: GetMonthlyDeclinationParallelsRequestNodeType,
    ) -> Self {
        self.node_type = Some(value);
        self
    }
    /// Sets `orb`.
    #[must_use]
    pub fn with_orb(mut self, value: f64) -> Self {
        self.orb = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(
        mut self,
        value: GetMonthlyDeclinationParallelsRequestTimezone,
    ) -> Self {
        self.timezone = Some(value);
        self
    }
    /// Sets `year`.
    #[must_use]
    pub fn with_year(mut self, value: i64) -> Self {
        self.year = Some(value);
        self
    }
}
impl GetMonthlyDeclinationParallelsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetMonthlyDeclinationParallelsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetMonthlyAspectsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            coordinate_system: Default::default(),
            month: Default::default(),
            timezone: Default::default(),
            year: Default::default(),
        }
    }
    /// Sets `coordinateSystem`.
    #[must_use]
    pub fn with_coordinate_system(
        mut self,
        value: GetMonthlyAspectsRequestCoordinateSystem,
    ) -> Self {
        self.coordinate_system = Some(value);
        self
    }
    /// Sets `month`.
    #[must_use]
    pub fn with_month(mut self, value: i64) -> Self {
        self.month = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: GetMonthlyAspectsRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
    /// Sets `year`.
    #[must_use]
    pub fn with_year(mut self, value: i64) -> Self {
        self.year = Some(value);
        self
    }
}
impl GetMonthlyAspectsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetMonthlyAspectsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetMonthlyAlmanacParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            month: Default::default(),
            year: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetMonthlyAlmanacParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `month`.
    #[must_use]
    pub fn with_month(mut self, value: i64) -> Self {
        self.month = Some(value);
        self
    }
    /// Sets `year`.
    #[must_use]
    pub fn with_year(mut self, value: i64) -> Self {
        self.year = Some(value);
        self
    }
}
impl GetMayanDaySignParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: GetMayanDaySignParamsId) -> Self {
        Self {
            direction_scheme: Default::default(),
            id,
            lang: Default::default(),
        }
    }
    /// Sets `directionScheme`.
    #[must_use]
    pub fn with_direction_scheme(
        mut self,
        value: GetMayanDaySignParamsDirectionScheme,
    ) -> Self {
        self.direction_scheme = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetMayanDaySignParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetMajorDashasRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            node_type: Default::default(),
            significators: Default::default(),
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: GetMajorDashasRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: GetMajorDashasRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
    /// Sets `significators`.
    #[must_use]
    pub fn with_significators(mut self, value: bool) -> Self {
        self.significators = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: GetMajorDashasRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetMajorDashasParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            focus: Default::default(),
            lang: Default::default(),
        }
    }
    /// Sets `focus`.
    #[must_use]
    pub fn with_focus(mut self, value: GetMajorDashasParamsFocus) -> Self {
        self.focus = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetMajorDashasParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetLunarAspectsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            coordinate_system: Default::default(),
            month: Default::default(),
            timezone: Default::default(),
            year: Default::default(),
        }
    }
    /// Sets `coordinateSystem`.
    #[must_use]
    pub fn with_coordinate_system(
        mut self,
        value: GetLunarAspectsRequestCoordinateSystem,
    ) -> Self {
        self.coordinate_system = Some(value);
        self
    }
    /// Sets `month`.
    #[must_use]
    pub fn with_month(mut self, value: i64) -> Self {
        self.month = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: GetLunarAspectsRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
    /// Sets `year`.
    #[must_use]
    pub fn with_year(mut self, value: i64) -> Self {
        self.year = Some(value);
        self
    }
}
impl GetLunarAspectsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetLunarAspectsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetKuaNumberParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(number: i64) -> Self {
        Self {
            lang: Default::default(),
            number,
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetKuaNumberParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetKpRulingPlanetsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(latitude: f64, longitude: f64) -> Self {
        Self {
            birth_date: Default::default(),
            birth_time: Default::default(),
            datetime: Default::default(),
            latitude,
            longitude,
            node_type: Default::default(),
            timezone: Default::default(),
        }
    }
    /// Sets `birthDate`.
    #[must_use]
    pub fn with_birth_date(mut self, value: String) -> Self {
        self.birth_date = Some(value);
        self
    }
    /// Sets `birthTime`.
    #[must_use]
    pub fn with_birth_time(mut self, value: String) -> Self {
        self.birth_time = Some(value);
        self
    }
    /// Sets `datetime`.
    #[must_use]
    pub fn with_datetime(mut self, value: String) -> Self {
        self.datetime = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: GetKpRulingPlanetsRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: GetKpRulingPlanetsRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetKpRulingPlanetsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            focus: Default::default(),
            lang: Default::default(),
        }
    }
    /// Sets `focus`.
    #[must_use]
    pub fn with_focus(mut self, value: GetKpRulingPlanetsParamsFocus) -> Self {
        self.focus = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetKpRulingPlanetsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetKpRulingIntervalRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        start_datetime: String,
        end_datetime: String,
        interval_minutes: i64,
        latitude: f64,
        longitude: f64,
    ) -> Self {
        Self {
            ayanamsa: Default::default(),
            end_datetime,
            interval_minutes,
            latitude,
            longitude,
            node_type: Default::default(),
            start_datetime,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: GetKpRulingIntervalRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: GetKpRulingIntervalRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: GetKpRulingIntervalRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetKpRulingIntervalParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            focus: Default::default(),
            lang: Default::default(),
        }
    }
    /// Sets `focus`.
    #[must_use]
    pub fn with_focus(mut self, value: GetKpRulingIntervalParamsFocus) -> Self {
        self.focus = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetKpRulingIntervalParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetKpCuspsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            focus: Default::default(),
            lang: Default::default(),
        }
    }
    /// Sets `focus`.
    #[must_use]
    pub fn with_focus(mut self, value: GetKpCuspsParamsFocus) -> Self {
        self.focus = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetKpCuspsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetHoraRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, latitude: f64, longitude: f64) -> Self {
        Self {
            date,
            latitude,
            longitude,
            timezone: Default::default(),
        }
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: GetHoraRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetHexagramParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(number: i64) -> Self {
        Self {
            lang: Default::default(),
            number,
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetHexagramParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetHebrewLetterParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: GetHebrewLetterParamsId) -> Self {
        Self {
            id,
            lang: Default::default(),
            letter_attribution: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetHebrewLetterParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `letterAttribution`.
    #[must_use]
    pub fn with_letter_attribution(
        mut self,
        value: GetHebrewLetterParamsLetterAttribution,
    ) -> Self {
        self.letter_attribution = Some(value);
        self
    }
}
impl GetHaabMonthParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: GetHaabMonthParamsId) -> Self {
        Self {
            id,
            lang: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetHaabMonthParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetGateParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(number: i64) -> Self {
        Self {
            lang: Default::default(),
            number,
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetGateParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetForecastParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetForecastParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetFieldLabelsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetFieldLabelsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetEclipticCrossingsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(year: i64) -> Self {
        Self {
            coordinate_system: Default::default(),
            timezone: Default::default(),
            year,
        }
    }
    /// Sets `coordinateSystem`.
    #[must_use]
    pub fn with_coordinate_system(
        mut self,
        value: GetEclipticCrossingsRequestCoordinateSystem,
    ) -> Self {
        self.coordinate_system = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: GetEclipticCrossingsRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetEclipticCrossingsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetEclipticCrossingsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetDoshaParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: GetDoshaParamsId) -> Self {
        Self {
            id,
            lang: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetDoshaParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetDinacharyaScheduleParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetDinacharyaScheduleParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetDikpalaDirectionParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: GetDikpalaDirectionParamsId) -> Self {
        Self {
            id,
            lang: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetDikpalaDirectionParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetDevataParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: GetDevataParamsId) -> Self {
        Self {
            id,
            lang: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetDevataParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetDetailedPanchangRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, latitude: f64, longitude: f64) -> Self {
        Self {
            date,
            latitude,
            longitude,
            timezone: Default::default(),
        }
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: GetDetailedPanchangRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetDetailedPanchangParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetDetailedPanchangParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetDailyZodiacReadingParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: GetDailyZodiacReadingParamsId) -> Self {
        Self {
            date: Default::default(),
            id,
            lang: Default::default(),
            timezone: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetDailyZodiacReadingParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: String) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetDailySephirahParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            after_sunset: Default::default(),
            date: Default::default(),
            lang: Default::default(),
            timezone: Default::default(),
        }
    }
    /// Sets `afterSunset`.
    #[must_use]
    pub fn with_after_sunset(mut self, value: String) -> Self {
        self.after_sunset = Some(value);
        self
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetDailySephirahParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: String) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetDailyNumberParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetDailyNumberParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetDailyMayanReadingParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            correlation: Default::default(),
            date: Default::default(),
            lang: Default::default(),
        }
    }
    /// Sets `correlation`.
    #[must_use]
    pub fn with_correlation(
        mut self,
        value: GetDailyMayanReadingParamsCorrelation,
    ) -> Self {
        self.correlation = Some(value);
        self
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetDailyMayanReadingParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetDailyHoroscopeParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(sign: GetDailyHoroscopeParamsSign) -> Self {
        Self {
            date: Default::default(),
            lang: Default::default(),
            sign,
            timezone: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetDailyHoroscopeParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: String) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetDailyHexagramParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetDailyHexagramParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetDailyCrystalParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetDailyCrystalParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetDailyCardParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetDailyCardParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetDailyBiorhythmParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetDailyBiorhythmParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetDailyAztecReadingParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            date: Default::default(),
            lang: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetDailyAztecReadingParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetDailyAyurvedaReadingParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(latitude: f64, longitude: f64) -> Self {
        Self {
            date: Default::default(),
            lang: Default::default(),
            latitude,
            longitude,
            timezone: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetDailyAyurvedaReadingParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: String) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetDailyAngelNumberParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetDailyAngelNumberParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetCurrentMoonPhaseParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            date: Default::default(),
            lang: Default::default(),
            time: Default::default(),
            timezone: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetCurrentMoonPhaseParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `time`.
    #[must_use]
    pub fn with_time(mut self, value: String) -> Self {
        self.time = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: String) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetCurrentDashaRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            datetime: Default::default(),
            latitude,
            longitude,
            node_type: Default::default(),
            significators: Default::default(),
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: GetCurrentDashaRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `datetime`.
    #[must_use]
    pub fn with_datetime(mut self, value: String) -> Self {
        self.datetime = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: GetCurrentDashaRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
    /// Sets `significators`.
    #[must_use]
    pub fn with_significators(mut self, value: bool) -> Self {
        self.significators = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: GetCurrentDashaRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetCurrentDashaParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            focus: Default::default(),
            lang: Default::default(),
        }
    }
    /// Sets `focus`.
    #[must_use]
    pub fn with_focus(mut self, value: GetCurrentDashaParamsFocus) -> Self {
        self.focus = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetCurrentDashaParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetCrystalsByZodiacParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(sign: GetCrystalsByZodiacParamsSign) -> Self {
        Self {
            lang: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
            sign,
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetCrystalsByZodiacParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl GetCrystalsByElementParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(element: GetCrystalsByElementParamsElement) -> Self {
        Self {
            element,
            lang: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetCrystalsByElementParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl GetCrystalsByChakraParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(chakra: GetCrystalsByChakraParamsChakra) -> Self {
        Self {
            chakra,
            lang: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetCrystalsByChakraParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl GetCrystalParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: String) -> Self {
        Self {
            id,
            lang: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetCrystalParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetCrystalPairingsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: String) -> Self {
        Self {
            id,
            lang: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetCrystalPairingsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetCriticalDaysParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetCriticalDaysParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetCompoundNumberParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(number: String) -> Self {
        Self {
            lang: Default::default(),
            number,
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetCompoundNumberParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetChoghadiyaRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, latitude: f64, longitude: f64) -> Self {
        Self {
            date,
            latitude,
            longitude,
            timezone: Default::default(),
        }
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: GetChoghadiyaRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetCenterParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: GetCenterParamsId) -> Self {
        Self {
            id,
            lang: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetCenterParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetCardParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: String) -> Self {
        Self {
            id,
            lang: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetCardParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetBirthstonesParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(month: i64) -> Self {
        Self {
            lang: Default::default(),
            month,
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetBirthstonesParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetBasicPanchangRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            date,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: GetBasicPanchangRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetBasicPanchangParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetBasicPanchangParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetBaguaSectorParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: GetBaguaSectorParamsId) -> Self {
        Self {
            id,
            lang: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetBaguaSectorParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetAztecTrecenaParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(number: i64) -> Self {
        Self {
            lang: Default::default(),
            number,
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetAztecTrecenaParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetAztecDaySignParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: GetAztecDaySignParamsId) -> Self {
        Self {
            id,
            lang: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetAztecDaySignParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetAvasthaParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: GetAvasthaParamsId) -> Self {
        Self {
            id,
            lang: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetAvasthaParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetAnnualFlyingStarsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(year: i64) -> Self {
        Self {
            lang: Default::default(),
            year,
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetAnnualFlyingStarsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetAnnualAfflictionsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(year: i64) -> Self {
        Self {
            lang: Default::default(),
            year,
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetAnnualAfflictionsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetAngelNumberParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(number: String) -> Self {
        Self {
            lang: Default::default(),
            number,
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetAngelNumberParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GetAlmanacDayParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String) -> Self {
        Self {
            date,
            lang: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GetAlmanacDayParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateTransitRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(birth_data: GenerateTransitRequestBirthData) -> Self {
        Self {
            birth_data,
            date: Default::default(),
            time: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `time`.
    #[must_use]
    pub fn with_time(mut self, value: String) -> Self {
        self.time = Some(value);
        self
    }
}
impl GenerateTransitRequestBirthData {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: GenerateTransitRequestBirthDataTimezone,
    ) -> Self {
        Self {
            date,
            latitude: Default::default(),
            longitude: Default::default(),
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `latitude`.
    #[must_use]
    pub fn with_latitude(mut self, value: f64) -> Self {
        self.latitude = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(
        mut self,
        value: GenerateTransitRequestBirthDataNodeType,
    ) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl GenerateTransitParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateTransitParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateTimelineRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(birth_data: GenerateTimelineRequestBirthData) -> Self {
        Self {
            birth_data,
            domain_weights: Default::default(),
            domains: Default::default(),
            end_date: Default::default(),
            min_significance: Default::default(),
            start_date: Default::default(),
        }
    }
    /// Sets `domainWeights`.
    #[must_use]
    pub fn with_domain_weights(
        mut self,
        value: GenerateTimelineRequestDomainWeights,
    ) -> Self {
        self.domain_weights = Some(value);
        self
    }
    /// Sets `domains`.
    #[must_use]
    pub fn with_domains(
        mut self,
        value: Vec<GenerateTimelineRequestDomainsItem>,
    ) -> Self {
        self.domains = Some(value);
        self
    }
    /// Sets `endDate`.
    #[must_use]
    pub fn with_end_date(mut self, value: String) -> Self {
        self.end_date = Some(value);
        self
    }
    /// Sets `minSignificance`.
    #[must_use]
    pub fn with_min_significance(mut self, value: f64) -> Self {
        self.min_significance = Some(value);
        self
    }
    /// Sets `startDate`.
    #[must_use]
    pub fn with_start_date(mut self, value: String) -> Self {
        self.start_date = Some(value);
        self
    }
}
impl GenerateTimelineRequestDomainWeights {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            biorhythm: Default::default(),
            vedic: Default::default(),
            western: Default::default(),
        }
    }
    /// Sets `biorhythm`.
    #[must_use]
    pub fn with_biorhythm(mut self, value: f64) -> Self {
        self.biorhythm = Some(value);
        self
    }
    /// Sets `vedic`.
    #[must_use]
    pub fn with_vedic(mut self, value: f64) -> Self {
        self.vedic = Some(value);
        self
    }
    /// Sets `western`.
    #[must_use]
    pub fn with_western(mut self, value: f64) -> Self {
        self.western = Some(value);
        self
    }
}
impl GenerateTimelineRequestBirthData {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: GenerateTimelineRequestBirthDataTimezone,
    ) -> Self {
        Self {
            date,
            latitude: Default::default(),
            longitude: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `latitude`.
    #[must_use]
    pub fn with_latitude(mut self, value: f64) -> Self {
        self.latitude = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
}
impl GenerateTimelineParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateTimelineParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateSolarReturnRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        birth_date: String,
        birth_time: String,
        return_year: i64,
        latitude: f64,
        longitude: f64,
        timezone: GenerateSolarReturnRequestTimezone,
    ) -> Self {
        Self {
            birth_date,
            birth_time,
            house_system: Default::default(),
            latitude,
            longitude,
            return_year,
            timezone,
        }
    }
    /// Sets `houseSystem`.
    #[must_use]
    pub fn with_house_system(
        mut self,
        value: GenerateSolarReturnRequestHouseSystem,
    ) -> Self {
        self.house_system = Some(value);
        self
    }
}
impl GenerateSolarReturnParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateSolarReturnParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateSolarArcParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateSolarArcParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateRelocationChartParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateRelocationChartParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateProgressionsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateProgressionsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateProfectionsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateProfectionsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GeneratePlanetaryReturnRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        birth_date: String,
        birth_time: String,
        planet: GeneratePlanetaryReturnRequestPlanet,
        approximate_date: String,
        latitude: f64,
        longitude: f64,
        timezone: GeneratePlanetaryReturnRequestTimezone,
    ) -> Self {
        Self {
            approximate_date,
            birth_date,
            birth_time,
            house_system: Default::default(),
            latitude,
            longitude,
            planet,
            timezone,
        }
    }
    /// Sets `houseSystem`.
    #[must_use]
    pub fn with_house_system(
        mut self,
        value: GeneratePlanetaryReturnRequestHouseSystem,
    ) -> Self {
        self.house_system = Some(value);
        self
    }
}
impl GeneratePlanetaryReturnParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GeneratePlanetaryReturnParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateNumerologyChartParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateNumerologyChartParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateNavamsaParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateNavamsaParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateNatalChartParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateNatalChartParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateNameProfileRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            mispar_gadol: Default::default(),
            name: Default::default(),
            name_hebrew: Default::default(),
            transliteration: Default::default(),
        }
    }
    /// Sets `misparGadol`.
    #[must_use]
    pub fn with_mispar_gadol(
        mut self,
        value: GenerateNameProfileRequestMisparGadol,
    ) -> Self {
        self.mispar_gadol = Some(value);
        self
    }
    /// Sets `name`.
    #[must_use]
    pub fn with_name(mut self, value: String) -> Self {
        self.name = Some(value);
        self
    }
    /// Sets `nameHebrew`.
    #[must_use]
    pub fn with_name_hebrew(mut self, value: String) -> Self {
        self.name_hebrew = Some(value);
        self
    }
    /// Sets `transliteration`.
    #[must_use]
    pub fn with_transliteration(
        mut self,
        value: GenerateNameProfileRequestTransliteration,
    ) -> Self {
        self.transliteration = Some(value);
        self
    }
}
impl GenerateNameProfileParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateNameProfileParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateMayanChartRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String) -> Self {
        Self {
            correlation: Default::default(),
            date,
            year_bearer_system: Default::default(),
        }
    }
    /// Sets `correlation`.
    #[must_use]
    pub fn with_correlation(
        mut self,
        value: GenerateMayanChartRequestCorrelation,
    ) -> Self {
        self.correlation = Some(value);
        self
    }
    /// Sets `yearBearerSystem`.
    #[must_use]
    pub fn with_year_bearer_system(
        mut self,
        value: GenerateMayanChartRequestYearBearerSystem,
    ) -> Self {
        self.year_bearer_system = Some(value);
        self
    }
}
impl GenerateMayanChartParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateMayanChartParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateMandalaRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(plot: GenerateMandalaRequestPlot) -> Self {
        Self {
            grid: Default::default(),
            plot,
        }
    }
    /// Sets `grid`.
    #[must_use]
    pub fn with_grid(mut self, value: GenerateMandalaRequestGrid) -> Self {
        self.grid = Some(value);
        self
    }
}
impl GenerateMandalaRequestPlot {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            depth: Default::default(),
            polygon: Default::default(),
            unit: Default::default(),
            width: Default::default(),
        }
    }
    /// Sets `depth`.
    #[must_use]
    pub fn with_depth(mut self, value: f64) -> Self {
        self.depth = Some(value);
        self
    }
    /// Sets `polygon`.
    #[must_use]
    pub fn with_polygon(
        mut self,
        value: Vec<GenerateMandalaRequestPlotPolygonItem>,
    ) -> Self {
        self.polygon = Some(value);
        self
    }
    /// Sets `unit`.
    #[must_use]
    pub fn with_unit(mut self, value: GenerateMandalaRequestPlotUnit) -> Self {
        self.unit = Some(value);
        self
    }
    /// Sets `width`.
    #[must_use]
    pub fn with_width(mut self, value: f64) -> Self {
        self.width = Some(value);
        self
    }
}
impl GenerateMandalaRequestPlotPolygonItem {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(x: f64, y: f64) -> Self {
        Self { x, y }
    }
}
impl GenerateMandalaParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateMandalaParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateLunarReturnRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        birth_date: String,
        birth_time: String,
        return_date: String,
        latitude: f64,
        longitude: f64,
        timezone: GenerateLunarReturnRequestTimezone,
    ) -> Self {
        Self {
            birth_date,
            birth_time,
            house_system: Default::default(),
            latitude,
            longitude,
            return_date,
            timezone,
        }
    }
    /// Sets `houseSystem`.
    #[must_use]
    pub fn with_house_system(
        mut self,
        value: GenerateLunarReturnRequestHouseSystem,
    ) -> Self {
        self.house_system = Some(value);
        self
    }
}
impl GenerateLunarReturnParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateLunarReturnParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateLocalSpaceRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        timezone: GenerateLocalSpaceRequestTimezone,
    ) -> Self {
        Self {
            date,
            latitude,
            longitude,
            time,
            timezone,
        }
    }
}
impl GenerateLocalSpaceParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            include: Default::default(),
            lang: Default::default(),
        }
    }
    /// Sets `include`.
    #[must_use]
    pub fn with_include(mut self, value: String) -> Self {
        self.include = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateLocalSpaceParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateLilithParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateLilithParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateKpChartParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            focus: Default::default(),
            lang: Default::default(),
        }
    }
    /// Sets `focus`.
    #[must_use]
    pub fn with_focus(mut self, value: GenerateKpChartParamsFocus) -> Self {
        self.focus = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateKpChartParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateFlyingStarChartRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            facing: Default::default(),
            facing_degrees: Default::default(),
            period: Default::default(),
        }
    }
    /// Sets `facing`.
    #[must_use]
    pub fn with_facing(mut self, value: GenerateFlyingStarChartRequestFacing) -> Self {
        self.facing = Some(value);
        self
    }
    /// Sets `facingDegrees`. `None` sends an explicit null.
    #[must_use]
    pub fn with_facing_degrees(mut self, value: Option<f64>) -> Self {
        self.facing_degrees = Some(value);
        self
    }
    /// Sets `period`.
    #[must_use]
    pub fn with_period(mut self, value: i64) -> Self {
        self.period = Some(value);
        self
    }
}
impl GenerateFlyingStarChartParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateFlyingStarChartParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateFixedStarsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        timezone: GenerateFixedStarsRequestTimezone,
    ) -> Self {
        Self {
            date,
            latitude,
            longitude,
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: GenerateFixedStarsRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl GenerateFixedStarsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            orb: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateFixedStarsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `orb`.
    #[must_use]
    pub fn with_orb(mut self, value: f64) -> Self {
        self.orb = Some(value);
        self
    }
}
impl GenerateEightMansionsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            date: Default::default(),
            facing: Default::default(),
            gender: Default::default(),
            kua: Default::default(),
            year_boundary: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `facing`.
    #[must_use]
    pub fn with_facing(mut self, value: GenerateEightMansionsRequestFacing) -> Self {
        self.facing = Some(value);
        self
    }
    /// Sets `gender`.
    #[must_use]
    pub fn with_gender(mut self, value: GenerateEightMansionsRequestGender) -> Self {
        self.gender = Some(value);
        self
    }
    /// Sets `kua`.
    #[must_use]
    pub fn with_kua(mut self, value: f64) -> Self {
        self.kua = Some(value);
        self
    }
    /// Sets `yearBoundary`.
    #[must_use]
    pub fn with_year_boundary(
        mut self,
        value: GenerateEightMansionsRequestYearBoundary,
    ) -> Self {
        self.year_boundary = Some(value);
        self
    }
}
impl GenerateEightMansionsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateEightMansionsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateDivisionalChartParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateDivisionalChartParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateDigestRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(birth_data: GenerateDigestRequestBirthData) -> Self {
        Self {
            birth_data,
            domain_weights: Default::default(),
            domains: Default::default(),
            min_significance: Default::default(),
            start_date: Default::default(),
            top: Default::default(),
        }
    }
    /// Sets `domainWeights`.
    #[must_use]
    pub fn with_domain_weights(
        mut self,
        value: GenerateDigestRequestDomainWeights,
    ) -> Self {
        self.domain_weights = Some(value);
        self
    }
    /// Sets `domains`.
    #[must_use]
    pub fn with_domains(mut self, value: Vec<GenerateDigestRequestDomainsItem>) -> Self {
        self.domains = Some(value);
        self
    }
    /// Sets `minSignificance`.
    #[must_use]
    pub fn with_min_significance(mut self, value: f64) -> Self {
        self.min_significance = Some(value);
        self
    }
    /// Sets `startDate`.
    #[must_use]
    pub fn with_start_date(mut self, value: String) -> Self {
        self.start_date = Some(value);
        self
    }
    /// Sets `top`.
    #[must_use]
    pub fn with_top(mut self, value: i64) -> Self {
        self.top = Some(value);
        self
    }
}
impl GenerateDigestRequestDomainWeights {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            biorhythm: Default::default(),
            vedic: Default::default(),
            western: Default::default(),
        }
    }
    /// Sets `biorhythm`.
    #[must_use]
    pub fn with_biorhythm(mut self, value: f64) -> Self {
        self.biorhythm = Some(value);
        self
    }
    /// Sets `vedic`.
    #[must_use]
    pub fn with_vedic(mut self, value: f64) -> Self {
        self.vedic = Some(value);
        self
    }
    /// Sets `western`.
    #[must_use]
    pub fn with_western(mut self, value: f64) -> Self {
        self.western = Some(value);
        self
    }
}
impl GenerateDigestRequestBirthData {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: GenerateDigestRequestBirthDataTimezone,
    ) -> Self {
        Self {
            date,
            latitude: Default::default(),
            longitude: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `latitude`.
    #[must_use]
    pub fn with_latitude(mut self, value: f64) -> Self {
        self.latitude = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
}
impl GenerateDigestParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateDigestParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateCompositeChartRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        person1: GenerateCompositeChartRequestPerson1,
        person2: GenerateCompositeChartRequestPerson2,
    ) -> Self {
        Self {
            house_system: Default::default(),
            person1,
            person2,
        }
    }
    /// Sets `houseSystem`.
    #[must_use]
    pub fn with_house_system(
        mut self,
        value: GenerateCompositeChartRequestHouseSystem,
    ) -> Self {
        self.house_system = Some(value);
        self
    }
}
impl GenerateCompositeChartRequestPerson2 {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        timezone: GenerateCompositeChartRequestPerson2Timezone,
    ) -> Self {
        Self {
            date,
            latitude,
            longitude,
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(
        mut self,
        value: GenerateCompositeChartRequestPerson2NodeType,
    ) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl GenerateCompositeChartRequestPerson1 {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        timezone: GenerateCompositeChartRequestPerson1Timezone,
    ) -> Self {
        Self {
            date,
            latitude,
            longitude,
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(
        mut self,
        value: GenerateCompositeChartRequestPerson1NodeType,
    ) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl GenerateCompositeChartParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateCompositeChartParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateBodygraphRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: GenerateBodygraphRequestTimezone,
    ) -> Self {
        Self {
            date,
            latitude: Default::default(),
            longitude: Default::default(),
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `latitude`.
    #[must_use]
    pub fn with_latitude(mut self, value: f64) -> Self {
        self.latitude = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: GenerateBodygraphRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl GenerateBodygraphParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateBodygraphParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateBirthProfileRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, timezone: GenerateBirthProfileRequestTimezone) -> Self {
        Self {
            after_sunset: Default::default(),
            angel_dating: Default::default(),
            date,
            leap_day_policy: Default::default(),
            time: Default::default(),
            timezone,
            year_start: Default::default(),
        }
    }
    /// Sets `afterSunset`.
    #[must_use]
    pub fn with_after_sunset(mut self, value: bool) -> Self {
        self.after_sunset = Some(value);
        self
    }
    /// Sets `angelDating`.
    #[must_use]
    pub fn with_angel_dating(
        mut self,
        value: GenerateBirthProfileRequestAngelDating,
    ) -> Self {
        self.angel_dating = Some(value);
        self
    }
    /// Sets `leapDayPolicy`.
    #[must_use]
    pub fn with_leap_day_policy(
        mut self,
        value: GenerateBirthProfileRequestLeapDayPolicy,
    ) -> Self {
        self.leap_day_policy = Some(value);
        self
    }
    /// Sets `time`.
    #[must_use]
    pub fn with_time(mut self, value: String) -> Self {
        self.time = Some(value);
        self
    }
    /// Sets `yearStart`.
    #[must_use]
    pub fn with_year_start(
        mut self,
        value: GenerateBirthProfileRequestYearStart,
    ) -> Self {
        self.year_start = Some(value);
        self
    }
}
impl GenerateBirthProfileParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateBirthProfileParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateBirthChartParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            focus: Default::default(),
            lang: Default::default(),
        }
    }
    /// Sets `focus`.
    #[must_use]
    pub fn with_focus(mut self, value: GenerateBirthChartParamsFocus) -> Self {
        self.focus = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateBirthChartParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateBaziChartRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: GenerateBaziChartRequestTimezone,
    ) -> Self {
        Self {
            date,
            day_boundary: Default::default(),
            hour_clock: Default::default(),
            latitude: Default::default(),
            longitude: Default::default(),
            time,
            timezone,
            year_boundary: Default::default(),
        }
    }
    /// Sets `dayBoundary`.
    #[must_use]
    pub fn with_day_boundary(
        mut self,
        value: GenerateBaziChartRequestDayBoundary,
    ) -> Self {
        self.day_boundary = Some(value);
        self
    }
    /// Sets `hourClock`.
    #[must_use]
    pub fn with_hour_clock(mut self, value: GenerateBaziChartRequestHourClock) -> Self {
        self.hour_clock = Some(value);
        self
    }
    /// Sets `latitude`.
    #[must_use]
    pub fn with_latitude(mut self, value: f64) -> Self {
        self.latitude = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
    /// Sets `yearBoundary`.
    #[must_use]
    pub fn with_year_boundary(
        mut self,
        value: GenerateBaziChartRequestYearBoundary,
    ) -> Self {
        self.year_boundary = Some(value);
        self
    }
}
impl GenerateBaziChartParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateBaziChartParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateAstrocartographyRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        timezone: GenerateAstrocartographyRequestTimezone,
    ) -> Self {
        Self {
            date,
            latitude,
            longitude,
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(
        mut self,
        value: GenerateAstrocartographyRequestNodeType,
    ) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl GenerateAstrocartographyParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            include: Default::default(),
            lang: Default::default(),
        }
    }
    /// Sets `include`.
    #[must_use]
    pub fn with_include(mut self, value: String) -> Self {
        self.include = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateAstrocartographyParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl GenerateAsteroidsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: GenerateAsteroidsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl ForecastTransitsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(birth_data: ForecastTransitsRequestBirthData) -> Self {
        Self {
            birth_data,
            end_date: Default::default(),
            min_significance: Default::default(),
            start_date: Default::default(),
        }
    }
    /// Sets `endDate`.
    #[must_use]
    pub fn with_end_date(mut self, value: String) -> Self {
        self.end_date = Some(value);
        self
    }
    /// Sets `minSignificance`.
    #[must_use]
    pub fn with_min_significance(mut self, value: f64) -> Self {
        self.min_significance = Some(value);
        self
    }
    /// Sets `startDate`.
    #[must_use]
    pub fn with_start_date(mut self, value: String) -> Self {
        self.start_date = Some(value);
        self
    }
}
impl ForecastTransitsRequestBirthData {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: ForecastTransitsRequestBirthDataTimezone,
    ) -> Self {
        Self {
            date,
            latitude: Default::default(),
            longitude: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `latitude`.
    #[must_use]
    pub fn with_latitude(mut self, value: f64) -> Self {
        self.latitude = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
}
impl ForecastTransitsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ForecastTransitsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl ForecastSolarReturnRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        year: i64,
        latitude: f64,
        longitude: f64,
        timezone: ForecastSolarReturnRequestTimezone,
    ) -> Self {
        Self {
            date,
            house_system: Default::default(),
            latitude,
            longitude,
            time,
            timezone,
            year,
        }
    }
    /// Sets `houseSystem`.
    #[must_use]
    pub fn with_house_system(
        mut self,
        value: ForecastSolarReturnRequestHouseSystem,
    ) -> Self {
        self.house_system = Some(value);
        self
    }
}
impl ForecastSolarReturnParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ForecastSolarReturnParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl FindSignificantDatesRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(birth_data: FindSignificantDatesRequestBirthData) -> Self {
        Self {
            birth_data,
            domain_weights: Default::default(),
            domains: Default::default(),
            end_date: Default::default(),
            min_significance: Default::default(),
            start_date: Default::default(),
        }
    }
    /// Sets `domainWeights`.
    #[must_use]
    pub fn with_domain_weights(
        mut self,
        value: FindSignificantDatesRequestDomainWeights,
    ) -> Self {
        self.domain_weights = Some(value);
        self
    }
    /// Sets `domains`.
    #[must_use]
    pub fn with_domains(
        mut self,
        value: Vec<FindSignificantDatesRequestDomainsItem>,
    ) -> Self {
        self.domains = Some(value);
        self
    }
    /// Sets `endDate`.
    #[must_use]
    pub fn with_end_date(mut self, value: String) -> Self {
        self.end_date = Some(value);
        self
    }
    /// Sets `minSignificance`.
    #[must_use]
    pub fn with_min_significance(mut self, value: f64) -> Self {
        self.min_significance = Some(value);
        self
    }
    /// Sets `startDate`.
    #[must_use]
    pub fn with_start_date(mut self, value: String) -> Self {
        self.start_date = Some(value);
        self
    }
}
impl FindSignificantDatesRequestDomainWeights {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            biorhythm: Default::default(),
            vedic: Default::default(),
            western: Default::default(),
        }
    }
    /// Sets `biorhythm`.
    #[must_use]
    pub fn with_biorhythm(mut self, value: f64) -> Self {
        self.biorhythm = Some(value);
        self
    }
    /// Sets `vedic`.
    #[must_use]
    pub fn with_vedic(mut self, value: f64) -> Self {
        self.vedic = Some(value);
        self
    }
    /// Sets `western`.
    #[must_use]
    pub fn with_western(mut self, value: f64) -> Self {
        self.western = Some(value);
        self
    }
}
impl FindSignificantDatesRequestBirthData {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: FindSignificantDatesRequestBirthDataTimezone,
    ) -> Self {
        Self {
            date,
            latitude: Default::default(),
            longitude: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `latitude`.
    #[must_use]
    pub fn with_latitude(mut self, value: f64) -> Self {
        self.latitude = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
}
impl FindSignificantDatesParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: FindSignificantDatesParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl FindGrihaPraveshDatesRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        start_date: String,
        end_date: String,
        latitude: f64,
        longitude: f64,
        timezone: FindGrihaPraveshDatesRequestTimezone,
    ) -> Self {
        Self {
            end_date,
            latitude,
            longitude,
            muhurta_text: Default::default(),
            start_date,
            timezone,
        }
    }
    /// Sets `muhurtaText`.
    #[must_use]
    pub fn with_muhurta_text(
        mut self,
        value: FindGrihaPraveshDatesRequestMuhurtaText,
    ) -> Self {
        self.muhurta_text = Some(value);
        self
    }
}
impl FindGrihaPraveshDatesParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: FindGrihaPraveshDatesParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl DrawCardsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: DrawCardsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl DivisionalChartRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        division: i64,
    ) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            division,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: DivisionalChartRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: DivisionalChartRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl DetectYogasParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: DetectYogasParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl DetectAspectPatternsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            include: Default::default(),
            lang: Default::default(),
            strict_orbs: Default::default(),
        }
    }
    /// Sets `include`.
    #[must_use]
    pub fn with_include(mut self, value: String) -> Self {
        self.include = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: DetectAspectPatternsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `strictOrbs`.
    #[must_use]
    pub fn with_strict_orbs(mut self, value: String) -> Self {
        self.strict_orbs = Some(value);
        self
    }
}
impl DashakootRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        person1: DashakootRequestPerson1,
        person2: DashakootRequestPerson2,
    ) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            person1,
            person2,
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: DashakootRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
}
impl DashakootRequestPerson2 {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            date,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: DashakootRequestPerson2Timezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl DashakootRequestPerson1 {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            date,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: DashakootRequestPerson1Timezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl ConvertLongCountRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            correlation: Default::default(),
            date: Default::default(),
            long_count: Default::default(),
        }
    }
    /// Sets `correlation`.
    #[must_use]
    pub fn with_correlation(
        mut self,
        value: ConvertLongCountRequestCorrelation,
    ) -> Self {
        self.correlation = Some(value);
        self
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `longCount`.
    #[must_use]
    pub fn with_long_count(mut self, value: String) -> Self {
        self.long_count = Some(value);
        self
    }
}
impl ConvertLongCountParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: ConvertLongCountParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CompatibilityRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        person1: CompatibilityRequestPerson1,
        person2: CompatibilityRequestPerson2,
    ) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            person1,
            person2,
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: CompatibilityRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
}
impl CompatibilityRequestPerson2 {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            date,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: CompatibilityRequestPerson2Timezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl CompatibilityRequestPerson1 {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            date,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: CompatibilityRequestPerson1Timezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl CheckSadhesatiParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CheckSadhesatiParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CheckManglikDoshaParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CheckManglikDoshaParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CheckKarmicDebtParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CheckKarmicDebtParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CheckKalsarpaDoshaParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CheckKalsarpaDoshaParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CharaKarakaRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            scheme: Default::default(),
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: CharaKarakaRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `scheme`.
    #[must_use]
    pub fn with_scheme(mut self, value: CharaKarakaRequestScheme) -> Self {
        self.scheme = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: CharaKarakaRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl CastYesNoParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CastYesNoParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CastThreeCardParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CastThreeCardParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CastReadingParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            lang: Default::default(),
            seed: Default::default(),
        }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CastReadingParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
    /// Sets `seed`.
    #[must_use]
    pub fn with_seed(mut self, value: String) -> Self {
        self.seed = Some(value);
        self
    }
}
impl CastLoveSpreadParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CastLoveSpreadParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CastKpHoraryChartParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            focus: Default::default(),
            lang: Default::default(),
        }
    }
    /// Sets `focus`.
    #[must_use]
    pub fn with_focus(mut self, value: CastKpHoraryChartParamsFocus) -> Self {
        self.focus = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CastKpHoraryChartParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CastDailyReadingParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CastDailyReadingParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CastCustomSpreadRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(positions: Vec<CastCustomSpreadRequestPositionsItem>) -> Self {
        Self {
            positions,
            question: Default::default(),
            seed: Default::default(),
            spread_name: Default::default(),
        }
    }
    /// Sets `question`.
    #[must_use]
    pub fn with_question(mut self, value: String) -> Self {
        self.question = Some(value);
        self
    }
    /// Sets `seed`.
    #[must_use]
    pub fn with_seed(mut self, value: String) -> Self {
        self.seed = Some(value);
        self
    }
    /// Sets `spreadName`.
    #[must_use]
    pub fn with_spread_name(mut self, value: String) -> Self {
        self.spread_name = Some(value);
        self
    }
}
impl CastCustomSpreadRequestPositionsItem {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(name: String, interpretation: String) -> Self {
        Self { interpretation, name }
    }
}
impl CastCustomSpreadParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CastCustomSpreadParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CastCelticCrossParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CastCelticCrossParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CastCareerSpreadParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CastCareerSpreadParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateZodiacAnimalRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String) -> Self {
        Self {
            date,
            year_boundary: Default::default(),
        }
    }
    /// Sets `yearBoundary`.
    #[must_use]
    pub fn with_year_boundary(
        mut self,
        value: CalculateZodiacAnimalRequestYearBoundary,
    ) -> Self {
        self.year_boundary = Some(value);
        self
    }
}
impl CalculateZodiacAnimalParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateZodiacAnimalParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateVariablesRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: CalculateVariablesRequestTimezone,
    ) -> Self {
        Self {
            date,
            latitude: Default::default(),
            longitude: Default::default(),
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `latitude`.
    #[must_use]
    pub fn with_latitude(mut self, value: f64) -> Self {
        self.latitude = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: CalculateVariablesRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl CalculateVariablesParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateVariablesParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateTzolkinRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String) -> Self {
        Self {
            correlation: Default::default(),
            date,
        }
    }
    /// Sets `correlation`.
    #[must_use]
    pub fn with_correlation(
        mut self,
        value: CalculateTzolkinRequestCorrelation,
    ) -> Self {
        self.correlation = Some(value);
        self
    }
}
impl CalculateTzolkinParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateTzolkinParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateTypeRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: CalculateTypeRequestTimezone,
    ) -> Self {
        Self {
            date,
            latitude: Default::default(),
            longitude: Default::default(),
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `latitude`.
    #[must_use]
    pub fn with_latitude(mut self, value: f64) -> Self {
        self.latitude = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: CalculateTypeRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl CalculateTypeParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateTypeParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateTransitsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateTransitsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateTransitRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        birth_date: String,
        birth_time: String,
        transit_date: String,
        latitude: f64,
        longitude: f64,
    ) -> Self {
        Self {
            birth_date,
            birth_time,
            coordinate_system: Default::default(),
            latitude,
            longitude,
            timezone: Default::default(),
            transit_date,
            transit_time: Default::default(),
        }
    }
    /// Sets `coordinateSystem`.
    #[must_use]
    pub fn with_coordinate_system(
        mut self,
        value: CalculateTransitRequestCoordinateSystem,
    ) -> Self {
        self.coordinate_system = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: CalculateTransitRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
    /// Sets `transitTime`.
    #[must_use]
    pub fn with_transit_time(mut self, value: String) -> Self {
        self.transit_time = Some(value);
        self
    }
}
impl CalculateTransitAspectsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(natal_chart: CalculateTransitAspectsRequestNatalChart) -> Self {
        Self {
            aspect_types: Default::default(),
            house_system: Default::default(),
            min_strength: Default::default(),
            natal_chart,
            planets: Default::default(),
            transit_date: Default::default(),
            transit_time: Default::default(),
        }
    }
    /// Sets `aspectTypes`.
    #[must_use]
    pub fn with_aspect_types(
        mut self,
        value: Vec<CalculateTransitAspectsRequestAspectTypesItem>,
    ) -> Self {
        self.aspect_types = Some(value);
        self
    }
    /// Sets `houseSystem`.
    #[must_use]
    pub fn with_house_system(
        mut self,
        value: CalculateTransitAspectsRequestHouseSystem,
    ) -> Self {
        self.house_system = Some(value);
        self
    }
    /// Sets `minStrength`.
    #[must_use]
    pub fn with_min_strength(mut self, value: f64) -> Self {
        self.min_strength = Some(value);
        self
    }
    /// Sets `planets`.
    #[must_use]
    pub fn with_planets(
        mut self,
        value: Vec<CalculateTransitAspectsRequestPlanetsItem>,
    ) -> Self {
        self.planets = Some(value);
        self
    }
    /// Sets `transitDate`.
    #[must_use]
    pub fn with_transit_date(mut self, value: String) -> Self {
        self.transit_date = Some(value);
        self
    }
    /// Sets `transitTime`.
    #[must_use]
    pub fn with_transit_time(mut self, value: String) -> Self {
        self.transit_time = Some(value);
        self
    }
}
impl CalculateTransitAspectsRequestNatalChart {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        timezone: CalculateTransitAspectsRequestNatalChartTimezone,
    ) -> Self {
        Self {
            date,
            latitude,
            longitude,
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(
        mut self,
        value: CalculateTransitAspectsRequestNatalChartNodeType,
    ) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl CalculateTransitAspectsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateTransitAspectsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateTonalpohualliParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateTonalpohualliParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateSynastryRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        person1: CalculateSynastryRequestPerson1,
        person2: CalculateSynastryRequestPerson2,
    ) -> Self {
        Self {
            house_system: Default::default(),
            person1,
            person2,
        }
    }
    /// Sets `houseSystem`.
    #[must_use]
    pub fn with_house_system(
        mut self,
        value: CalculateSynastryRequestHouseSystem,
    ) -> Self {
        self.house_system = Some(value);
        self
    }
}
impl CalculateSynastryRequestPerson2 {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        timezone: CalculateSynastryRequestPerson2Timezone,
    ) -> Self {
        Self {
            date,
            latitude,
            longitude,
            name: Default::default(),
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `name`.
    #[must_use]
    pub fn with_name(mut self, value: String) -> Self {
        self.name = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(
        mut self,
        value: CalculateSynastryRequestPerson2NodeType,
    ) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl CalculateSynastryRequestPerson1 {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        timezone: CalculateSynastryRequestPerson1Timezone,
    ) -> Self {
        Self {
            date,
            latitude,
            longitude,
            name: Default::default(),
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `name`.
    #[must_use]
    pub fn with_name(mut self, value: String) -> Self {
        self.name = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(
        mut self,
        value: CalculateSynastryRequestPerson1NodeType,
    ) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl CalculateSynastryParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateSynastryParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateSoulUrgeParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateSoulUrgeParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateShadbalaParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateShadbalaParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateRoomComplianceRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        plot: CalculateRoomComplianceRequestPlot,
        rooms: Vec<CalculateRoomComplianceRequestRoomsItem>,
    ) -> Self {
        Self {
            facing: Default::default(),
            facing_degrees: Default::default(),
            plot,
            rooms,
        }
    }
    /// Sets `facing`.
    #[must_use]
    pub fn with_facing(mut self, value: CalculateRoomComplianceRequestFacing) -> Self {
        self.facing = Some(value);
        self
    }
    /// Sets `facingDegrees`.
    #[must_use]
    pub fn with_facing_degrees(mut self, value: f64) -> Self {
        self.facing_degrees = Some(value);
        self
    }
}
impl CalculateRoomComplianceRequestRoomsItem {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(r#type: CalculateRoomComplianceRequestRoomsItemType) -> Self {
        Self {
            direction: Default::default(),
            polygon: Default::default(),
            r#type,
        }
    }
    /// Sets `direction`.
    #[must_use]
    pub fn with_direction(
        mut self,
        value: CalculateRoomComplianceRequestRoomsItemDirection,
    ) -> Self {
        self.direction = Some(value);
        self
    }
    /// Sets `polygon`.
    #[must_use]
    pub fn with_polygon(
        mut self,
        value: Vec<CalculateRoomComplianceRequestRoomsItemPolygonItem>,
    ) -> Self {
        self.polygon = Some(value);
        self
    }
}
impl CalculateRoomComplianceRequestRoomsItemPolygonItem {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(x: f64, y: f64) -> Self {
        Self { x, y }
    }
}
impl CalculateRoomComplianceRequestPlot {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            depth: Default::default(),
            polygon: Default::default(),
            unit: Default::default(),
            width: Default::default(),
        }
    }
    /// Sets `depth`.
    #[must_use]
    pub fn with_depth(mut self, value: f64) -> Self {
        self.depth = Some(value);
        self
    }
    /// Sets `polygon`.
    #[must_use]
    pub fn with_polygon(
        mut self,
        value: Vec<CalculateRoomComplianceRequestPlotPolygonItem>,
    ) -> Self {
        self.polygon = Some(value);
        self
    }
    /// Sets `unit`.
    #[must_use]
    pub fn with_unit(mut self, value: CalculateRoomComplianceRequestPlotUnit) -> Self {
        self.unit = Some(value);
        self
    }
    /// Sets `width`.
    #[must_use]
    pub fn with_width(mut self, value: f64) -> Self {
        self.width = Some(value);
        self
    }
}
impl CalculateRoomComplianceRequestPlotPolygonItem {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(x: f64, y: f64) -> Self {
        Self { x, y }
    }
}
impl CalculateRoomComplianceParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateRoomComplianceParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateProfileRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: CalculateProfileRequestTimezone,
    ) -> Self {
        Self {
            date,
            latitude: Default::default(),
            longitude: Default::default(),
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `latitude`.
    #[must_use]
    pub fn with_latitude(mut self, value: f64) -> Self {
        self.latitude = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: CalculateProfileRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl CalculateProfileParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateProfileParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculatePlotAnalysisRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(plot: CalculatePlotAnalysisRequestPlot) -> Self {
        Self {
            cuts: Default::default(),
            extensions: Default::default(),
            facing: Default::default(),
            facing_degrees: Default::default(),
            plot,
            road: Default::default(),
            slope_low_direction: Default::default(),
            slope_school: Default::default(),
            water: Default::default(),
        }
    }
    /// Sets `cuts`.
    #[must_use]
    pub fn with_cuts(
        mut self,
        value: Vec<CalculatePlotAnalysisRequestCutsItem>,
    ) -> Self {
        self.cuts = Some(value);
        self
    }
    /// Sets `extensions`.
    #[must_use]
    pub fn with_extensions(
        mut self,
        value: Vec<CalculatePlotAnalysisRequestExtensionsItem>,
    ) -> Self {
        self.extensions = Some(value);
        self
    }
    /// Sets `facing`.
    #[must_use]
    pub fn with_facing(mut self, value: CalculatePlotAnalysisRequestFacing) -> Self {
        self.facing = Some(value);
        self
    }
    /// Sets `facingDegrees`.
    #[must_use]
    pub fn with_facing_degrees(mut self, value: f64) -> Self {
        self.facing_degrees = Some(value);
        self
    }
    /// Sets `road`.
    #[must_use]
    pub fn with_road(mut self, value: CalculatePlotAnalysisRequestRoad) -> Self {
        self.road = Some(value);
        self
    }
    /// Sets `slopeLowDirection`.
    #[must_use]
    pub fn with_slope_low_direction(
        mut self,
        value: CalculatePlotAnalysisRequestSlopeLowDirection,
    ) -> Self {
        self.slope_low_direction = Some(value);
        self
    }
    /// Sets `slopeSchool`.
    #[must_use]
    pub fn with_slope_school(
        mut self,
        value: CalculatePlotAnalysisRequestSlopeSchool,
    ) -> Self {
        self.slope_school = Some(value);
        self
    }
    /// Sets `water`.
    #[must_use]
    pub fn with_water(mut self, value: CalculatePlotAnalysisRequestWater) -> Self {
        self.water = Some(value);
        self
    }
}
impl CalculatePlotAnalysisRequestPlot {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            depth: Default::default(),
            polygon: Default::default(),
            unit: Default::default(),
            width: Default::default(),
        }
    }
    /// Sets `depth`.
    #[must_use]
    pub fn with_depth(mut self, value: f64) -> Self {
        self.depth = Some(value);
        self
    }
    /// Sets `polygon`.
    #[must_use]
    pub fn with_polygon(
        mut self,
        value: Vec<CalculatePlotAnalysisRequestPlotPolygonItem>,
    ) -> Self {
        self.polygon = Some(value);
        self
    }
    /// Sets `unit`.
    #[must_use]
    pub fn with_unit(mut self, value: CalculatePlotAnalysisRequestPlotUnit) -> Self {
        self.unit = Some(value);
        self
    }
    /// Sets `width`.
    #[must_use]
    pub fn with_width(mut self, value: f64) -> Self {
        self.width = Some(value);
        self
    }
}
impl CalculatePlotAnalysisRequestPlotPolygonItem {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(x: f64, y: f64) -> Self {
        Self { x, y }
    }
}
impl CalculatePlotAnalysisParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculatePlotAnalysisParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculatePersonalityParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculatePersonalityParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculatePersonalYearParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculatePersonalYearParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculatePersonalMonthParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculatePersonalMonthParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculatePersonalDayParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculatePersonalDayParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculatePentaRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(members: Vec<CalculatePentaRequestMembersItem>) -> Self {
        Self { members }
    }
}
impl CalculatePentaRequestMembersItem {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: CalculatePentaRequestMembersItemTimezone,
    ) -> Self {
        Self {
            date,
            latitude: Default::default(),
            longitude: Default::default(),
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `latitude`.
    #[must_use]
    pub fn with_latitude(mut self, value: f64) -> Self {
        self.latitude = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(
        mut self,
        value: CalculatePentaRequestMembersItemNodeType,
    ) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl CalculatePentaParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculatePentaParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateParallelsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            date,
            latitude,
            longitude,
            orb: Default::default(),
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `orb`.
    #[must_use]
    pub fn with_orb(mut self, value: f64) -> Self {
        self.orb = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: CalculateParallelsRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl CalculatePapasamyamParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculatePapasamyamParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateNumCompatibilityRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        person1: CalculateNumCompatibilityRequestPerson1,
        person2: CalculateNumCompatibilityRequestPerson2,
    ) -> Self {
        Self { person1, person2 }
    }
}
impl CalculateNumCompatibilityRequestPerson2 {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            day: Default::default(),
            expression: Default::default(),
            full_name: Default::default(),
            life_path: Default::default(),
            month: Default::default(),
            soul_urge: Default::default(),
            year: Default::default(),
        }
    }
    /// Sets `day`.
    #[must_use]
    pub fn with_day(mut self, value: i64) -> Self {
        self.day = Some(value);
        self
    }
    /// Sets `expression`.
    #[must_use]
    pub fn with_expression(mut self, value: i64) -> Self {
        self.expression = Some(value);
        self
    }
    /// Sets `fullName`.
    #[must_use]
    pub fn with_full_name(mut self, value: String) -> Self {
        self.full_name = Some(value);
        self
    }
    /// Sets `lifePath`.
    #[must_use]
    pub fn with_life_path(mut self, value: i64) -> Self {
        self.life_path = Some(value);
        self
    }
    /// Sets `month`.
    #[must_use]
    pub fn with_month(mut self, value: i64) -> Self {
        self.month = Some(value);
        self
    }
    /// Sets `soulUrge`.
    #[must_use]
    pub fn with_soul_urge(mut self, value: i64) -> Self {
        self.soul_urge = Some(value);
        self
    }
    /// Sets `year`.
    #[must_use]
    pub fn with_year(mut self, value: i64) -> Self {
        self.year = Some(value);
        self
    }
}
impl CalculateNumCompatibilityRequestPerson1 {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            day: Default::default(),
            expression: Default::default(),
            full_name: Default::default(),
            life_path: Default::default(),
            month: Default::default(),
            soul_urge: Default::default(),
            year: Default::default(),
        }
    }
    /// Sets `day`.
    #[must_use]
    pub fn with_day(mut self, value: i64) -> Self {
        self.day = Some(value);
        self
    }
    /// Sets `expression`.
    #[must_use]
    pub fn with_expression(mut self, value: i64) -> Self {
        self.expression = Some(value);
        self
    }
    /// Sets `fullName`.
    #[must_use]
    pub fn with_full_name(mut self, value: String) -> Self {
        self.full_name = Some(value);
        self
    }
    /// Sets `lifePath`.
    #[must_use]
    pub fn with_life_path(mut self, value: i64) -> Self {
        self.life_path = Some(value);
        self
    }
    /// Sets `month`.
    #[must_use]
    pub fn with_month(mut self, value: i64) -> Self {
        self.month = Some(value);
        self
    }
    /// Sets `soulUrge`.
    #[must_use]
    pub fn with_soul_urge(mut self, value: i64) -> Self {
        self.soul_urge = Some(value);
        self
    }
    /// Sets `year`.
    #[must_use]
    pub fn with_year(mut self, value: i64) -> Self {
        self.year = Some(value);
        self
    }
}
impl CalculateNumCompatibilityParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateNumCompatibilityParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateNameCompatibilityRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            first_name: Default::default(),
            first_name_hebrew: Default::default(),
            mispar_gadol: Default::default(),
            second_name: Default::default(),
            second_name_hebrew: Default::default(),
            transliteration: Default::default(),
        }
    }
    /// Sets `firstName`.
    #[must_use]
    pub fn with_first_name(mut self, value: String) -> Self {
        self.first_name = Some(value);
        self
    }
    /// Sets `firstNameHebrew`.
    #[must_use]
    pub fn with_first_name_hebrew(mut self, value: String) -> Self {
        self.first_name_hebrew = Some(value);
        self
    }
    /// Sets `misparGadol`.
    #[must_use]
    pub fn with_mispar_gadol(
        mut self,
        value: CalculateNameCompatibilityRequestMisparGadol,
    ) -> Self {
        self.mispar_gadol = Some(value);
        self
    }
    /// Sets `secondName`.
    #[must_use]
    pub fn with_second_name(mut self, value: String) -> Self {
        self.second_name = Some(value);
        self
    }
    /// Sets `secondNameHebrew`.
    #[must_use]
    pub fn with_second_name_hebrew(mut self, value: String) -> Self {
        self.second_name_hebrew = Some(value);
        self
    }
    /// Sets `transliteration`.
    #[must_use]
    pub fn with_transliteration(
        mut self,
        value: CalculateNameCompatibilityRequestTransliteration,
    ) -> Self {
        self.transliteration = Some(value);
        self
    }
}
impl CalculateNameCompatibilityParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateNameCompatibilityParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateMayanCompatibilityRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        person_a: CalculateMayanCompatibilityRequestPersonA,
        person_b: CalculateMayanCompatibilityRequestPersonB,
    ) -> Self {
        Self {
            correlation: Default::default(),
            direction_scheme: Default::default(),
            person_a,
            person_b,
        }
    }
    /// Sets `correlation`.
    #[must_use]
    pub fn with_correlation(
        mut self,
        value: CalculateMayanCompatibilityRequestCorrelation,
    ) -> Self {
        self.correlation = Some(value);
        self
    }
    /// Sets `directionScheme`.
    #[must_use]
    pub fn with_direction_scheme(
        mut self,
        value: CalculateMayanCompatibilityRequestDirectionScheme,
    ) -> Self {
        self.direction_scheme = Some(value);
        self
    }
}
impl CalculateMayanCompatibilityRequestPersonB {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String) -> Self {
        Self { date }
    }
}
impl CalculateMayanCompatibilityRequestPersonA {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String) -> Self {
        Self { date }
    }
}
impl CalculateMayanCompatibilityParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateMayanCompatibilityParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateMaturityParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateMaturityParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateLunarDateParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateLunarDateParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateLuckPillarsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: CalculateLuckPillarsRequestTimezone,
        gender: CalculateLuckPillarsRequestGender,
    ) -> Self {
        Self {
            annual_from_year: Default::default(),
            annual_years: Default::default(),
            count: Default::default(),
            date,
            day_boundary: Default::default(),
            gender,
            hour_clock: Default::default(),
            latitude: Default::default(),
            longitude: Default::default(),
            time,
            timezone,
            year_boundary: Default::default(),
        }
    }
    /// Sets `annualFromYear`.
    #[must_use]
    pub fn with_annual_from_year(mut self, value: i64) -> Self {
        self.annual_from_year = Some(value);
        self
    }
    /// Sets `annualYears`.
    #[must_use]
    pub fn with_annual_years(mut self, value: i64) -> Self {
        self.annual_years = Some(value);
        self
    }
    /// Sets `count`.
    #[must_use]
    pub fn with_count(mut self, value: i64) -> Self {
        self.count = Some(value);
        self
    }
    /// Sets `dayBoundary`.
    #[must_use]
    pub fn with_day_boundary(
        mut self,
        value: CalculateLuckPillarsRequestDayBoundary,
    ) -> Self {
        self.day_boundary = Some(value);
        self
    }
    /// Sets `hourClock`.
    #[must_use]
    pub fn with_hour_clock(
        mut self,
        value: CalculateLuckPillarsRequestHourClock,
    ) -> Self {
        self.hour_clock = Some(value);
        self
    }
    /// Sets `latitude`.
    #[must_use]
    pub fn with_latitude(mut self, value: f64) -> Self {
        self.latitude = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
    /// Sets `yearBoundary`.
    #[must_use]
    pub fn with_year_boundary(
        mut self,
        value: CalculateLuckPillarsRequestYearBoundary,
    ) -> Self {
        self.year_boundary = Some(value);
        self
    }
}
impl CalculateLuckPillarsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateLuckPillarsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateLifePathParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateLifePathParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateKuaNumberRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, gender: CalculateKuaNumberRequestGender) -> Self {
        Self {
            date,
            gender,
            year_boundary: Default::default(),
        }
    }
    /// Sets `yearBoundary`.
    #[must_use]
    pub fn with_year_boundary(
        mut self,
        value: CalculateKuaNumberRequestYearBoundary,
    ) -> Self {
        self.year_boundary = Some(value);
        self
    }
}
impl CalculateKuaNumberParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateKuaNumberParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateHousesRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        timezone: CalculateHousesRequestTimezone,
    ) -> Self {
        Self {
            date,
            house_system: Default::default(),
            latitude,
            longitude,
            time,
            timezone,
        }
    }
    /// Sets `houseSystem`.
    #[must_use]
    pub fn with_house_system(
        mut self,
        value: CalculateHousesRequestHouseSystem,
    ) -> Self {
        self.house_system = Some(value);
        self
    }
}
impl CalculateHousesParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateHousesParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateGunMilanParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateGunMilanParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateGematriaRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            atbash_output: Default::default(),
            ciphers: Default::default(),
            include_matches: Default::default(),
            latin_ciphers: Default::default(),
            mispar_gadol: Default::default(),
            text: Default::default(),
            text_hebrew: Default::default(),
            transliteration: Default::default(),
        }
    }
    /// Sets `atbashOutput`.
    #[must_use]
    pub fn with_atbash_output(
        mut self,
        value: CalculateGematriaRequestAtbashOutput,
    ) -> Self {
        self.atbash_output = Some(value);
        self
    }
    /// Sets `ciphers`.
    #[must_use]
    pub fn with_ciphers(
        mut self,
        value: Vec<CalculateGematriaRequestCiphersItem>,
    ) -> Self {
        self.ciphers = Some(value);
        self
    }
    /// Sets `includeMatches`.
    #[must_use]
    pub fn with_include_matches(mut self, value: bool) -> Self {
        self.include_matches = Some(value);
        self
    }
    /// Sets `latinCiphers`.
    #[must_use]
    pub fn with_latin_ciphers(mut self, value: bool) -> Self {
        self.latin_ciphers = Some(value);
        self
    }
    /// Sets `misparGadol`.
    #[must_use]
    pub fn with_mispar_gadol(
        mut self,
        value: CalculateGematriaRequestMisparGadol,
    ) -> Self {
        self.mispar_gadol = Some(value);
        self
    }
    /// Sets `text`.
    #[must_use]
    pub fn with_text(mut self, value: String) -> Self {
        self.text = Some(value);
        self
    }
    /// Sets `textHebrew`.
    #[must_use]
    pub fn with_text_hebrew(mut self, value: String) -> Self {
        self.text_hebrew = Some(value);
        self
    }
    /// Sets `transliteration`.
    #[must_use]
    pub fn with_transliteration(
        mut self,
        value: CalculateGematriaRequestTransliteration,
    ) -> Self {
        self.transliteration = Some(value);
        self
    }
}
impl CalculateGematriaParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateGematriaParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateGatesRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: CalculateGatesRequestTimezone,
    ) -> Self {
        Self {
            date,
            latitude: Default::default(),
            longitude: Default::default(),
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `latitude`.
    #[must_use]
    pub fn with_latitude(mut self, value: f64) -> Self {
        self.latitude = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: CalculateGatesRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl CalculateGatesParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateGatesParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateExpressionParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateExpressionParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateEntrancePadaRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(plot: CalculateEntrancePadaRequestPlot) -> Self {
        Self {
            door: Default::default(),
            door_position: Default::default(),
            facing: Default::default(),
            facing_degrees: Default::default(),
            grid: Default::default(),
            plot,
        }
    }
    /// Sets `door`.
    #[must_use]
    pub fn with_door(mut self, value: CalculateEntrancePadaRequestDoor) -> Self {
        self.door = Some(value);
        self
    }
    /// Sets `doorPosition`.
    #[must_use]
    pub fn with_door_position(mut self, value: f64) -> Self {
        self.door_position = Some(value);
        self
    }
    /// Sets `facing`.
    #[must_use]
    pub fn with_facing(mut self, value: CalculateEntrancePadaRequestFacing) -> Self {
        self.facing = Some(value);
        self
    }
    /// Sets `facingDegrees`.
    #[must_use]
    pub fn with_facing_degrees(mut self, value: f64) -> Self {
        self.facing_degrees = Some(value);
        self
    }
    /// Sets `grid`.
    #[must_use]
    pub fn with_grid(mut self, value: CalculateEntrancePadaRequestGrid) -> Self {
        self.grid = Some(value);
        self
    }
}
impl CalculateEntrancePadaRequestPlot {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            depth: Default::default(),
            polygon: Default::default(),
            unit: Default::default(),
            width: Default::default(),
        }
    }
    /// Sets `depth`.
    #[must_use]
    pub fn with_depth(mut self, value: f64) -> Self {
        self.depth = Some(value);
        self
    }
    /// Sets `polygon`.
    #[must_use]
    pub fn with_polygon(
        mut self,
        value: Vec<CalculateEntrancePadaRequestPlotPolygonItem>,
    ) -> Self {
        self.polygon = Some(value);
        self
    }
    /// Sets `unit`.
    #[must_use]
    pub fn with_unit(mut self, value: CalculateEntrancePadaRequestPlotUnit) -> Self {
        self.unit = Some(value);
        self
    }
    /// Sets `width`.
    #[must_use]
    pub fn with_width(mut self, value: f64) -> Self {
        self.width = Some(value);
        self
    }
}
impl CalculateEntrancePadaRequestPlotPolygonItem {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(x: f64, y: f64) -> Self {
        Self { x, y }
    }
}
impl CalculateEntrancePadaRequestDoor {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(x: f64, y: f64) -> Self {
        Self { x, y }
    }
}
impl CalculateEntrancePadaParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateEntrancePadaParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateDualParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateDualParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateDrishtiRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            coordinate_system: Default::default(),
            date,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `coordinateSystem`.
    #[must_use]
    pub fn with_coordinate_system(
        mut self,
        value: CalculateDrishtiRequestCoordinateSystem,
    ) -> Self {
        self.coordinate_system = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: CalculateDrishtiRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl CalculateDayMasterStrengthRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: CalculateDayMasterStrengthRequestTimezone,
    ) -> Self {
        Self {
            date,
            day_boundary: Default::default(),
            hour_clock: Default::default(),
            latitude: Default::default(),
            longitude: Default::default(),
            time,
            timezone,
            year_boundary: Default::default(),
        }
    }
    /// Sets `dayBoundary`.
    #[must_use]
    pub fn with_day_boundary(
        mut self,
        value: CalculateDayMasterStrengthRequestDayBoundary,
    ) -> Self {
        self.day_boundary = Some(value);
        self
    }
    /// Sets `hourClock`.
    #[must_use]
    pub fn with_hour_clock(
        mut self,
        value: CalculateDayMasterStrengthRequestHourClock,
    ) -> Self {
        self.hour_clock = Some(value);
        self
    }
    /// Sets `latitude`.
    #[must_use]
    pub fn with_latitude(mut self, value: f64) -> Self {
        self.latitude = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
    /// Sets `yearBoundary`.
    #[must_use]
    pub fn with_year_boundary(
        mut self,
        value: CalculateDayMasterStrengthRequestYearBoundary,
    ) -> Self {
        self.year_boundary = Some(value);
        self
    }
}
impl CalculateDayMasterStrengthParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateDayMasterStrengthParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateDashakootParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateDashakootParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateConnectionRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        person_a: CalculateConnectionRequestPersonA,
        person_b: CalculateConnectionRequestPersonB,
    ) -> Self {
        Self { person_a, person_b }
    }
}
impl CalculateConnectionRequestPersonB {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: CalculateConnectionRequestPersonBTimezone,
    ) -> Self {
        Self {
            date,
            latitude: Default::default(),
            longitude: Default::default(),
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `latitude`.
    #[must_use]
    pub fn with_latitude(mut self, value: f64) -> Self {
        self.latitude = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(
        mut self,
        value: CalculateConnectionRequestPersonBNodeType,
    ) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl CalculateConnectionRequestPersonA {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: CalculateConnectionRequestPersonATimezone,
    ) -> Self {
        Self {
            date,
            latitude: Default::default(),
            longitude: Default::default(),
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `latitude`.
    #[must_use]
    pub fn with_latitude(mut self, value: f64) -> Self {
        self.latitude = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(
        mut self,
        value: CalculateConnectionRequestPersonANodeType,
    ) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl CalculateConnectionParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateConnectionParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateCompatibilityRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        person1: CalculateCompatibilityRequestPerson1,
        person2: CalculateCompatibilityRequestPerson2,
    ) -> Self {
        Self { person1, person2 }
    }
}
impl CalculateCompatibilityRequestPerson2 {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        timezone: CalculateCompatibilityRequestPerson2Timezone,
    ) -> Self {
        Self {
            date,
            latitude,
            longitude,
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(
        mut self,
        value: CalculateCompatibilityRequestPerson2NodeType,
    ) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl CalculateCompatibilityRequestPerson1 {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        timezone: CalculateCompatibilityRequestPerson1Timezone,
    ) -> Self {
        Self {
            date,
            latitude,
            longitude,
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(
        mut self,
        value: CalculateCompatibilityRequestPerson1NodeType,
    ) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl CalculateCompatibilityParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateCompatibilityParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateCharaKarakasParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateCharaKarakasParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateChannelsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: CalculateChannelsRequestTimezone,
    ) -> Self {
        Self {
            date,
            latitude: Default::default(),
            longitude: Default::default(),
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `latitude`.
    #[must_use]
    pub fn with_latitude(mut self, value: f64) -> Self {
        self.latitude = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: CalculateChannelsRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl CalculateChannelsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateChannelsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateChaldeanParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateChaldeanParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateCentersRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: CalculateCentersRequestTimezone,
    ) -> Self {
        Self {
            date,
            latitude: Default::default(),
            longitude: Default::default(),
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `latitude`.
    #[must_use]
    pub fn with_latitude(mut self, value: f64) -> Self {
        self.latitude = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: CalculateCentersRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl CalculateCentersParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateCentersParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateBusinessNameParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateBusinessNameParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateBridgeNumbersParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateBridgeNumbersParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateBirthDayParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateBirthDayParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateBioCompatibilityRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        person1: CalculateBioCompatibilityRequestPerson1,
        person2: CalculateBioCompatibilityRequestPerson2,
    ) -> Self {
        Self {
            person1,
            person2,
            target_date: Default::default(),
        }
    }
    /// Sets `targetDate`.
    #[must_use]
    pub fn with_target_date(mut self, value: String) -> Self {
        self.target_date = Some(value);
        self
    }
}
impl CalculateBioCompatibilityRequestPerson2 {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(birth_date: String) -> Self {
        Self { birth_date }
    }
}
impl CalculateBioCompatibilityRequestPerson1 {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(birth_date: String) -> Self {
        Self { birth_date }
    }
}
impl CalculateBioCompatibilityParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateBioCompatibilityParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateBhavaBalaParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            focus: Default::default(),
            lang: Default::default(),
        }
    }
    /// Sets `focus`.
    #[must_use]
    pub fn with_focus(mut self, value: CalculateBhavaBalaParamsFocus) -> Self {
        self.focus = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateBhavaBalaParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateBhavChalitParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            focus: Default::default(),
            lang: Default::default(),
        }
    }
    /// Sets `focus`.
    #[must_use]
    pub fn with_focus(mut self, value: CalculateBhavChalitParamsFocus) -> Self {
        self.focus = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateBhavChalitParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateBaziCompatibilityRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        person_a: CalculateBaziCompatibilityRequestPersonA,
        person_b: CalculateBaziCompatibilityRequestPersonB,
    ) -> Self {
        Self { person_a, person_b }
    }
}
impl CalculateBaziCompatibilityRequestPersonB {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: CalculateBaziCompatibilityRequestPersonBTimezone,
    ) -> Self {
        Self {
            date,
            day_boundary: Default::default(),
            hour_clock: Default::default(),
            latitude: Default::default(),
            longitude: Default::default(),
            time,
            timezone,
            year_boundary: Default::default(),
        }
    }
    /// Sets `dayBoundary`.
    #[must_use]
    pub fn with_day_boundary(
        mut self,
        value: CalculateBaziCompatibilityRequestPersonBDayBoundary,
    ) -> Self {
        self.day_boundary = Some(value);
        self
    }
    /// Sets `hourClock`.
    #[must_use]
    pub fn with_hour_clock(
        mut self,
        value: CalculateBaziCompatibilityRequestPersonBHourClock,
    ) -> Self {
        self.hour_clock = Some(value);
        self
    }
    /// Sets `latitude`.
    #[must_use]
    pub fn with_latitude(mut self, value: f64) -> Self {
        self.latitude = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
    /// Sets `yearBoundary`.
    #[must_use]
    pub fn with_year_boundary(
        mut self,
        value: CalculateBaziCompatibilityRequestPersonBYearBoundary,
    ) -> Self {
        self.year_boundary = Some(value);
        self
    }
}
impl CalculateBaziCompatibilityRequestPersonA {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: CalculateBaziCompatibilityRequestPersonATimezone,
    ) -> Self {
        Self {
            date,
            day_boundary: Default::default(),
            hour_clock: Default::default(),
            latitude: Default::default(),
            longitude: Default::default(),
            time,
            timezone,
            year_boundary: Default::default(),
        }
    }
    /// Sets `dayBoundary`.
    #[must_use]
    pub fn with_day_boundary(
        mut self,
        value: CalculateBaziCompatibilityRequestPersonADayBoundary,
    ) -> Self {
        self.day_boundary = Some(value);
        self
    }
    /// Sets `hourClock`.
    #[must_use]
    pub fn with_hour_clock(
        mut self,
        value: CalculateBaziCompatibilityRequestPersonAHourClock,
    ) -> Self {
        self.hour_clock = Some(value);
        self
    }
    /// Sets `latitude`.
    #[must_use]
    pub fn with_latitude(mut self, value: f64) -> Self {
        self.latitude = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
    /// Sets `yearBoundary`.
    #[must_use]
    pub fn with_year_boundary(
        mut self,
        value: CalculateBaziCompatibilityRequestPersonAYearBoundary,
    ) -> Self {
        self.year_boundary = Some(value);
        self
    }
}
impl CalculateBaziCompatibilityParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateBaziCompatibilityParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateAyurvedicConstitutionParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateAyurvedicConstitutionParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateAyadiRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(length: f64, breadth: f64) -> Self {
        Self {
            ayadi_text: Default::default(),
            breadth,
            circumference: Default::default(),
            hasta_inches: Default::default(),
            length,
            perimeter: Default::default(),
            unit: Default::default(),
            vyaya_formula: Default::default(),
        }
    }
    /// Sets `ayadiText`.
    #[must_use]
    pub fn with_ayadi_text(mut self, value: CalculateAyadiRequestAyadiText) -> Self {
        self.ayadi_text = Some(value);
        self
    }
    /// Sets `circumference`.
    #[must_use]
    pub fn with_circumference(mut self, value: f64) -> Self {
        self.circumference = Some(value);
        self
    }
    /// Sets `hastaInches`.
    #[must_use]
    pub fn with_hasta_inches(mut self, value: f64) -> Self {
        self.hasta_inches = Some(value);
        self
    }
    /// Sets `perimeter`.
    #[must_use]
    pub fn with_perimeter(mut self, value: f64) -> Self {
        self.perimeter = Some(value);
        self
    }
    /// Sets `unit`.
    #[must_use]
    pub fn with_unit(mut self, value: CalculateAyadiRequestUnit) -> Self {
        self.unit = Some(value);
        self
    }
    /// Sets `vyayaFormula`.
    #[must_use]
    pub fn with_vyaya_formula(
        mut self,
        value: CalculateAyadiRequestVyayaFormula,
    ) -> Self {
        self.vyaya_formula = Some(value);
        self
    }
}
impl CalculateAyadiParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateAyadiParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateAspectsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateAspectsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateArudhaPadasParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateArudhaPadasParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateArabicLotsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateArabicLotsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl CalculateAnnualForecastRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        timezone: CalculateAnnualForecastRequestTimezone,
        year: i64,
    ) -> Self {
        Self {
            date,
            day_boundary: Default::default(),
            hour_clock: Default::default(),
            latitude: Default::default(),
            longitude: Default::default(),
            time,
            timezone,
            year,
            year_boundary: Default::default(),
        }
    }
    /// Sets `dayBoundary`.
    #[must_use]
    pub fn with_day_boundary(
        mut self,
        value: CalculateAnnualForecastRequestDayBoundary,
    ) -> Self {
        self.day_boundary = Some(value);
        self
    }
    /// Sets `hourClock`.
    #[must_use]
    pub fn with_hour_clock(
        mut self,
        value: CalculateAnnualForecastRequestHourClock,
    ) -> Self {
        self.hour_clock = Some(value);
        self
    }
    /// Sets `latitude`.
    #[must_use]
    pub fn with_latitude(mut self, value: f64) -> Self {
        self.latitude = Some(value);
        self
    }
    /// Sets `longitude`.
    #[must_use]
    pub fn with_longitude(mut self, value: f64) -> Self {
        self.longitude = Some(value);
        self
    }
    /// Sets `yearBoundary`.
    #[must_use]
    pub fn with_year_boundary(
        mut self,
        value: CalculateAnnualForecastRequestYearBoundary,
    ) -> Self {
        self.year_boundary = Some(value);
        self
    }
}
impl CalculateAnnualForecastParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: CalculateAnnualForecastParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl BirthChartRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            avastha_info: Default::default(),
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            modern_planets: Default::default(),
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `avasthaInfo`.
    #[must_use]
    pub fn with_avastha_info(mut self, value: bool) -> Self {
        self.avastha_info = Some(value);
        self
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: BirthChartRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `modernPlanets`.
    #[must_use]
    pub fn with_modern_planets(mut self, value: bool) -> Self {
        self.modern_planets = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: BirthChartRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl BhavaBalaRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: BhavaBalaRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: BhavaBalaRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl BhavChalitRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: BhavChalitRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: BhavChalitRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl AyurvedaRitucharyaRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String) -> Self {
        Self {
            date,
            hemisphere: Default::default(),
            ritu_zodiac: Default::default(),
            ritucharya_scheme: Default::default(),
        }
    }
    /// Sets `hemisphere`.
    #[must_use]
    pub fn with_hemisphere(
        mut self,
        value: AyurvedaRitucharyaRequestHemisphere,
    ) -> Self {
        self.hemisphere = Some(value);
        self
    }
    /// Sets `rituZodiac`.
    #[must_use]
    pub fn with_ritu_zodiac(
        mut self,
        value: AyurvedaRitucharyaRequestRituZodiac,
    ) -> Self {
        self.ritu_zodiac = Some(value);
        self
    }
    /// Sets `ritucharyaScheme`.
    #[must_use]
    pub fn with_ritucharya_scheme(
        mut self,
        value: AyurvedaRitucharyaRequestRitucharyaScheme,
    ) -> Self {
        self.ritucharya_scheme = Some(value);
        self
    }
}
impl AyurvedaDinacharyaRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, latitude: f64, longitude: f64) -> Self {
        Self {
            date,
            dosha_clock: Default::default(),
            latitude,
            longitude,
            timezone: Default::default(),
        }
    }
    /// Sets `doshaClock`.
    #[must_use]
    pub fn with_dosha_clock(
        mut self,
        value: AyurvedaDinacharyaRequestDoshaClock,
    ) -> Self {
        self.dosha_clock = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: AyurvedaDinacharyaRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl AyurvedaConstitutionRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            sign_dosha_scheme: Default::default(),
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: AyurvedaConstitutionRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `signDoshaScheme`.
    #[must_use]
    pub fn with_sign_dosha_scheme(
        mut self,
        value: AyurvedaConstitutionRequestSignDoshaScheme,
    ) -> Self {
        self.sign_dosha_scheme = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: AyurvedaConstitutionRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl AsteroidsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        timezone: AsteroidsRequestTimezone,
    ) -> Self {
        Self {
            date,
            house_system: Default::default(),
            latitude,
            longitude,
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `houseSystem`.
    #[must_use]
    pub fn with_house_system(mut self, value: AsteroidsRequestHouseSystem) -> Self {
        self.house_system = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: AsteroidsRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl AspectsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, timezone: AspectsRequestTimezone) -> Self {
        Self {
            aspect_types: Default::default(),
            date,
            planets: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `aspectTypes`.
    #[must_use]
    pub fn with_aspect_types(mut self, value: Vec<String>) -> Self {
        self.aspect_types = Some(value);
        self
    }
    /// Sets `planets`.
    #[must_use]
    pub fn with_planets(mut self, value: Vec<String>) -> Self {
        self.planets = Some(value);
        self
    }
}
impl AspectPatternsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        timezone: AspectPatternsRequestTimezone,
    ) -> Self {
        Self {
            date,
            latitude,
            longitude,
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: AspectPatternsRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl AshtakavargaRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: AshtakavargaRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: AshtakavargaRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl ArudhaRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String, time: String, latitude: f64, longitude: f64) -> Self {
        Self {
            ayanamsa: Default::default(),
            ayanamsa_value: Default::default(),
            date,
            latitude,
            longitude,
            time,
            timezone: Default::default(),
        }
    }
    /// Sets `ayanamsa`.
    #[must_use]
    pub fn with_ayanamsa(mut self, value: ArudhaRequestAyanamsa) -> Self {
        self.ayanamsa = Some(value);
        self
    }
    /// Sets `ayanamsaValue`.
    #[must_use]
    pub fn with_ayanamsa_value(mut self, value: f64) -> Self {
        self.ayanamsa_value = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: ArudhaRequestTimezone) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl ArabicLotsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(
        date: String,
        time: String,
        latitude: f64,
        longitude: f64,
        timezone: ArabicLotsRequestTimezone,
    ) -> Self {
        Self {
            date,
            house_system: Default::default(),
            latitude,
            longitude,
            node_type: Default::default(),
            time,
            timezone,
        }
    }
    /// Sets `houseSystem`.
    #[must_use]
    pub fn with_house_system(mut self, value: ArabicLotsRequestHouseSystem) -> Self {
        self.house_system = Some(value);
        self
    }
    /// Sets `nodeType`.
    #[must_use]
    pub fn with_node_type(mut self, value: ArabicLotsRequestNodeType) -> Self {
        self.node_type = Some(value);
        self
    }
}
impl AnalyzeNumberSequenceParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(number: String) -> Self {
        Self {
            context: Default::default(),
            lang: Default::default(),
            number,
        }
    }
    /// Sets `context`.
    #[must_use]
    pub fn with_context(mut self, value: AnalyzeNumberSequenceParamsContext) -> Self {
        self.context = Some(value);
        self
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: AnalyzeNumberSequenceParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl AnalyzeKarmicLessonsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { lang: Default::default() }
    }
    /// Sets `lang`.
    #[must_use]
    pub fn with_lang(mut self, value: AnalyzeKarmicLessonsParamsLang) -> Self {
        self.lang = Some(value);
        self
    }
}
impl AnalyzeKarmicLessonsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(full_name: String) -> Self {
        Self { full_name }
    }
}
impl CalculateBirthDayRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(day: i64) -> Self {
        Self { day }
    }
}
impl CalculateBridgeNumbersRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(full_name: String, year: i64, month: i64, day: i64) -> Self {
        Self {
            day,
            full_name,
            month,
            year,
        }
    }
}
impl CalculateBusinessNameRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(name: String) -> Self {
        Self { name }
    }
}
impl CalculateChaldeanRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(name: String) -> Self {
        Self { name }
    }
}
impl CalculateDualRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(name: String) -> Self {
        Self { name }
    }
}
impl CalculateExpressionRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(full_name: String) -> Self {
        Self { full_name }
    }
}
impl CalculateLifePathRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(year: i64, month: i64, day: i64) -> Self {
        Self { day, month, year }
    }
}
impl CalculateLunarDateRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            date: Default::default(),
            is_leap_month: Default::default(),
            lunar_day: Default::default(),
            lunar_month: Default::default(),
            lunar_year: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `isLeapMonth`.
    #[must_use]
    pub fn with_is_leap_month(mut self, value: bool) -> Self {
        self.is_leap_month = Some(value);
        self
    }
    /// Sets `lunarDay`.
    #[must_use]
    pub fn with_lunar_day(mut self, value: i64) -> Self {
        self.lunar_day = Some(value);
        self
    }
    /// Sets `lunarMonth`.
    #[must_use]
    pub fn with_lunar_month(mut self, value: i64) -> Self {
        self.lunar_month = Some(value);
        self
    }
    /// Sets `lunarYear`.
    #[must_use]
    pub fn with_lunar_year(mut self, value: i64) -> Self {
        self.lunar_year = Some(value);
        self
    }
}
impl CalculateMaturityRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            day: Default::default(),
            expression: Default::default(),
            full_name: Default::default(),
            life_path: Default::default(),
            month: Default::default(),
            year: Default::default(),
        }
    }
    /// Sets `day`.
    #[must_use]
    pub fn with_day(mut self, value: i64) -> Self {
        self.day = Some(value);
        self
    }
    /// Sets `expression`.
    #[must_use]
    pub fn with_expression(mut self, value: i64) -> Self {
        self.expression = Some(value);
        self
    }
    /// Sets `fullName`.
    #[must_use]
    pub fn with_full_name(mut self, value: String) -> Self {
        self.full_name = Some(value);
        self
    }
    /// Sets `lifePath`.
    #[must_use]
    pub fn with_life_path(mut self, value: i64) -> Self {
        self.life_path = Some(value);
        self
    }
    /// Sets `month`.
    #[must_use]
    pub fn with_month(mut self, value: i64) -> Self {
        self.month = Some(value);
        self
    }
    /// Sets `year`.
    #[must_use]
    pub fn with_year(mut self, value: i64) -> Self {
        self.year = Some(value);
        self
    }
}
impl CalculatePersonalDayRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(month: i64, day: i64) -> Self {
        Self {
            day,
            month,
            target_date: Default::default(),
        }
    }
    /// Sets `targetDate`.
    #[must_use]
    pub fn with_target_date(mut self, value: String) -> Self {
        self.target_date = Some(value);
        self
    }
}
impl CalculatePersonalMonthRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(month: i64, day: i64) -> Self {
        Self {
            day,
            month,
            target_month: Default::default(),
            year: Default::default(),
        }
    }
    /// Sets `targetMonth`.
    #[must_use]
    pub fn with_target_month(mut self, value: i64) -> Self {
        self.target_month = Some(value);
        self
    }
    /// Sets `year`.
    #[must_use]
    pub fn with_year(mut self, value: i64) -> Self {
        self.year = Some(value);
        self
    }
}
impl CalculatePersonalYearRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(month: i64, day: i64) -> Self {
        Self {
            day,
            month,
            year: Default::default(),
        }
    }
    /// Sets `year`.
    #[must_use]
    pub fn with_year(mut self, value: i64) -> Self {
        self.year = Some(value);
        self
    }
}
impl CalculatePersonalityRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(full_name: String) -> Self {
        Self { full_name }
    }
}
impl CalculateSoulUrgeRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(full_name: String) -> Self {
        Self { full_name }
    }
}
impl CalculateTonalpohualliRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(date: String) -> Self {
        Self { date }
    }
}
impl CastCareerSpreadRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            question: Default::default(),
            seed: Default::default(),
        }
    }
    /// Sets `question`.
    #[must_use]
    pub fn with_question(mut self, value: String) -> Self {
        self.question = Some(value);
        self
    }
    /// Sets `seed`.
    #[must_use]
    pub fn with_seed(mut self, value: String) -> Self {
        self.seed = Some(value);
        self
    }
}
impl CastCelticCrossRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            question: Default::default(),
            seed: Default::default(),
        }
    }
    /// Sets `question`.
    #[must_use]
    pub fn with_question(mut self, value: String) -> Self {
        self.question = Some(value);
        self
    }
    /// Sets `seed`.
    #[must_use]
    pub fn with_seed(mut self, value: String) -> Self {
        self.seed = Some(value);
        self
    }
}
impl CastDailyReadingRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            date: Default::default(),
            seed: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `seed`.
    #[must_use]
    pub fn with_seed(mut self, value: String) -> Self {
        self.seed = Some(value);
        self
    }
}
impl CastLoveSpreadRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            question: Default::default(),
            seed: Default::default(),
        }
    }
    /// Sets `question`.
    #[must_use]
    pub fn with_question(mut self, value: String) -> Self {
        self.question = Some(value);
        self
    }
    /// Sets `seed`.
    #[must_use]
    pub fn with_seed(mut self, value: String) -> Self {
        self.seed = Some(value);
        self
    }
}
impl CastThreeCardRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            question: Default::default(),
            seed: Default::default(),
        }
    }
    /// Sets `question`.
    #[must_use]
    pub fn with_question(mut self, value: String) -> Self {
        self.question = Some(value);
        self
    }
    /// Sets `seed`.
    #[must_use]
    pub fn with_seed(mut self, value: String) -> Self {
        self.seed = Some(value);
        self
    }
}
impl CastYesNoRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            question: Default::default(),
            seed: Default::default(),
        }
    }
    /// Sets `question`.
    #[must_use]
    pub fn with_question(mut self, value: String) -> Self {
        self.question = Some(value);
        self
    }
    /// Sets `seed`.
    #[must_use]
    pub fn with_seed(mut self, value: String) -> Self {
        self.seed = Some(value);
        self
    }
}
impl CheckKarmicDebtRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            day: Default::default(),
            full_name: Default::default(),
            month: Default::default(),
            year: Default::default(),
        }
    }
    /// Sets `day`.
    #[must_use]
    pub fn with_day(mut self, value: i64) -> Self {
        self.day = Some(value);
        self
    }
    /// Sets `fullName`.
    #[must_use]
    pub fn with_full_name(mut self, value: String) -> Self {
        self.full_name = Some(value);
        self
    }
    /// Sets `month`.
    #[must_use]
    pub fn with_month(mut self, value: i64) -> Self {
        self.month = Some(value);
        self
    }
    /// Sets `year`.
    #[must_use]
    pub fn with_year(mut self, value: i64) -> Self {
        self.year = Some(value);
        self
    }
}
impl DrawCardsRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(count: i64) -> Self {
        Self {
            allow_duplicates: Default::default(),
            allow_reversals: Default::default(),
            count,
            seed: Default::default(),
        }
    }
    /// Sets `allowDuplicates`.
    #[must_use]
    pub fn with_allow_duplicates(mut self, value: bool) -> Self {
        self.allow_duplicates = Some(value);
        self
    }
    /// Sets `allowReversals`.
    #[must_use]
    pub fn with_allow_reversals(mut self, value: bool) -> Self {
        self.allow_reversals = Some(value);
        self
    }
    /// Sets `seed`.
    #[must_use]
    pub fn with_seed(mut self, value: String) -> Self {
        self.seed = Some(value);
        self
    }
}
impl GenerateNumerologyChartRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(full_name: String, year: i64, month: i64, day: i64) -> Self {
        Self {
            current_year: Default::default(),
            day,
            full_name,
            month,
            year,
        }
    }
    /// Sets `currentYear`.
    #[must_use]
    pub fn with_current_year(mut self, value: i64) -> Self {
        self.current_year = Some(value);
        self
    }
}
impl GetCitiesByCountryParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(iso2: String) -> Self {
        Self {
            iso2,
            limit: Default::default(),
            offset: Default::default(),
        }
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl GetCriticalDaysRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(birth_date: String) -> Self {
        Self {
            birth_date,
            end_date: Default::default(),
            start_date: Default::default(),
        }
    }
    /// Sets `endDate`.
    #[must_use]
    pub fn with_end_date(mut self, value: String) -> Self {
        self.end_date = Some(value);
        self
    }
    /// Sets `startDate`.
    #[must_use]
    pub fn with_start_date(mut self, value: String) -> Self {
        self.start_date = Some(value);
        self
    }
}
impl GetDailyAngelNumberRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            date: Default::default(),
            seed: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `seed`.
    #[must_use]
    pub fn with_seed(mut self, value: String) -> Self {
        self.seed = Some(value);
        self
    }
}
impl GetDailyBiorhythmRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            date: Default::default(),
            seed: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `seed`.
    #[must_use]
    pub fn with_seed(mut self, value: String) -> Self {
        self.seed = Some(value);
        self
    }
}
impl GetDailyCardRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            date: Default::default(),
            seed: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `seed`.
    #[must_use]
    pub fn with_seed(mut self, value: String) -> Self {
        self.seed = Some(value);
        self
    }
}
impl GetDailyCrystalRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            date: Default::default(),
            seed: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `seed`.
    #[must_use]
    pub fn with_seed(mut self, value: String) -> Self {
        self.seed = Some(value);
        self
    }
}
impl GetDailyDreamSymbolRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            date: Default::default(),
            seed: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `seed`.
    #[must_use]
    pub fn with_seed(mut self, value: String) -> Self {
        self.seed = Some(value);
        self
    }
}
impl GetDailyHexagramRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            date: Default::default(),
            seed: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `seed`.
    #[must_use]
    pub fn with_seed(mut self, value: String) -> Self {
        self.seed = Some(value);
        self
    }
}
impl GetDailyNumberRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            date: Default::default(),
            seed: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `seed`.
    #[must_use]
    pub fn with_seed(mut self, value: String) -> Self {
        self.seed = Some(value);
        self
    }
}
impl GetDreamSymbolParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(id: String) -> Self {
        Self { id }
    }
}
impl GetForecastRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(birth_date: String) -> Self {
        Self {
            birth_date,
            end_date: Default::default(),
            start_date: Default::default(),
        }
    }
    /// Sets `endDate`.
    #[must_use]
    pub fn with_end_date(mut self, value: String) -> Self {
        self.end_date = Some(value);
        self
    }
    /// Sets `startDate`.
    #[must_use]
    pub fn with_start_date(mut self, value: String) -> Self {
        self.start_date = Some(value);
        self
    }
}
impl GetKpAyanamsaParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            date: Default::default(),
            time: Default::default(),
            timezone: Default::default(),
        }
    }
    /// Sets `date`.
    #[must_use]
    pub fn with_date(mut self, value: String) -> Self {
        self.date = Some(value);
        self
    }
    /// Sets `time`.
    #[must_use]
    pub fn with_time(mut self, value: String) -> Self {
        self.time = Some(value);
        self
    }
    /// Sets `timezone`.
    #[must_use]
    pub fn with_timezone(mut self, value: String) -> Self {
        self.timezone = Some(value);
        self
    }
}
impl GetMonthlyTropicalEphemerisRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            month: Default::default(),
            year: Default::default(),
        }
    }
    /// Sets `month`.
    #[must_use]
    pub fn with_month(mut self, value: i64) -> Self {
        self.month = Some(value);
        self
    }
    /// Sets `year`.
    #[must_use]
    pub fn with_year(mut self, value: i64) -> Self {
        self.year = Some(value);
        self
    }
}
impl GetPhasesRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(birth_date: String) -> Self {
        Self {
            birth_date,
            target_date: Default::default(),
        }
    }
    /// Sets `targetDate`.
    #[must_use]
    pub fn with_target_date(mut self, value: String) -> Self {
        self.target_date = Some(value);
        self
    }
}
impl GetRandomSymbolsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self { count: Default::default() }
    }
    /// Sets `count`.
    #[must_use]
    pub fn with_count(mut self, value: i64) -> Self {
        self.count = Some(value);
        self
    }
}
impl GetReadingRequest {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(birth_date: String) -> Self {
        Self {
            birth_date,
            target_date: Default::default(),
        }
    }
    /// Sets `targetDate`.
    #[must_use]
    pub fn with_target_date(mut self, value: String) -> Self {
        self.target_date = Some(value);
        self
    }
}
impl ListCountriesParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            limit: Default::default(),
            offset: Default::default(),
        }
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl SearchCitiesParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new(q: String) -> Self {
        Self {
            limit: Default::default(),
            offset: Default::default(),
            q,
        }
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
}
impl SearchDreamSymbolsParams {
    /// Builds the value from its required fields, in specification order. Add optional fields with the `with_` setters.
    pub fn new() -> Self {
        Self {
            letter: Default::default(),
            limit: Default::default(),
            offset: Default::default(),
            q: Default::default(),
        }
    }
    /// Sets `letter`.
    #[must_use]
    pub fn with_letter(mut self, value: String) -> Self {
        self.letter = Some(value);
        self
    }
    /// Sets `limit`.
    #[must_use]
    pub fn with_limit(mut self, value: i64) -> Self {
        self.limit = Some(value);
        self
    }
    /// Sets `offset`.
    #[must_use]
    pub fn with_offset(mut self, value: i64) -> Self {
        self.offset = Some(value);
        self
    }
    /// Sets `q`.
    #[must_use]
    pub fn with_q(mut self, value: String) -> Self {
        self.q = Some(value);
        self
    }
}