# AUTO-GENERATED FILE. DO NOT EDIT MANUALLY.
# Generated by scripts/generate.py

from typing import Dict, Any, Optional
from .core import BaseClient

class Miracle(BaseClient):
    """
    Official Python Client for the MIRACLE API.
    
    Base URL: https://ref.miracle-api.workers.dev/exec
    """

    def la_da__values(self, parameter: str, gender: str, method: str) -> Dict[str, Any]:
        """
        Retrieves normal reference values (mean, sd, ll, ul, units) for various left atrial measurements.
        
        Args:
            parameter (str): The specific LA measurement parameter. (A=Area, D=Diameter, MX=Maximum, BSA=Body Surface Area indexed). Options: ['MXLAA_2Ch', 'MXLAA_2Ch_BSA', 'MXLAA_3Ch', 'MXLAA_3Ch_BSA', 'MXLAA_4Ch', 'MXLAA_4Ch_BSA', 'MXLALD_2Ch', 'MXLALD_2Ch_BSA', 'MXLATD_2Ch', 'MXLATD_2Ch_BSA', 'MXLALD_3Ch', 'MXLALD_3Ch_BSA', 'MXLAAPD_3Ch', 'MXLAAPD_3Ch_BSA', 'MXLALD_4Ch', 'MXLALD_4Ch_BSA', 'MXLATD_4Ch', 'MXLATD_4Ch_BSA']
        gender (str): Gender of the subject. Case-insensitive.. Options: ['male', 'female']
        method (str): The imaging method used. Case-insensitive.. Options: ['bSSFP']
        """
        params = {'domain': 'LA_DA', 'parameter': parameter, 'gender': gender, 'method': method}
        return self._make_request(params)

    def la_vf__values(self, parameter: str, gender: str, method: str) -> Dict[str, Any]:
        """
        Retrieves normal reference values (mean, sd, ll, ul) for a specified left atrial parameter, based on gender and measurement method.
        
        Args:
            parameter (str): The specific left atrial parameter to evaluate.. Options: ['MXLAV', 'MXLAVi', 'MNLAVi', 'LASV', 'LASVi', 'LAEF']
        gender (str): Gender of the subject. Case-insensitive.. Options: ['male', 'female']
        method (str): The imaging method used for the measurement.
- `BPAL_AE`: Biplane area-length method; LA appendage **excluded**.
- `SM_AE`: Simpson’s method; LA appendage **excluded**.
- `SM_AI`: Simpson’s method; LA appendage **included**.
. Options: ['BPAL_AE', 'SM_AE', 'SM_AI']
        """
        params = {'domain': 'LA_VF', 'parameter': parameter, 'gender': gender, 'method': method}
        return self._make_request(params)

    def ra_da__values(self, parameter: str, gender: str) -> Dict[str, Any]:
        """
        Retrieves normal reference values (mean, sd, ll, ul, units) for various right atrial measurements based on the parameter and gender.
        
        Args:
            parameter (str): The specific RA measurement parameter.. Options: ['MXRAA_2Ch']
        gender (str): Gender of the subject. Case-insensitive.. Options: ['male', 'female']
        """
        params = {'domain': 'RA_DA', 'parameter': parameter, 'gender': gender}
        return self._make_request(params)

    def ra_vf__values(self, parameter: str, gender: str, method: str) -> Dict[str, Any]:
        """
        Retrieves normal reference values (mean, sd, ll, ul) for a specified right atrial parameter, based on gender and measurement method.
        
        Args:
            parameter (str): The specific right atrial parameter to evaluate.. Options: ['MXRAV', 'MXRAVi', 'MNRAV', 'MNRAVi', 'RAEF', 'RASV', 'RASVi']
        gender (str): Gender of the subject. Case-insensitive.. Options: ['male', 'female']
        method (str): The imaging method used for the measurement.
- `BPAL_AE`: Biplane area-length method; RA appendage **excluded**.
- `SM_AE`: Simpson’s method; RA appendage **excluded**.
- `SM_AI`: Simpson’s method; RA appendage **included**.
. Options: ['BPAL_AE', 'SM_AE', 'SM_AI']
        """
        params = {'domain': 'RA_VF', 'parameter': parameter, 'gender': gender, 'method': method}
        return self._make_request(params)

    def t1_relax__values(self, parameter: str, fs: float, vendor: str, technique: str) -> Dict[str, Any]:
        """
        Retrieves normal reference values (mean, sd, ll, ul) for T1 mapping or ECV based on a specific combination of scanner and sequence parameters.
        
        Args:
            parameter (str): The primary parameter to evaluate.. Options: ['T1_NATIVE', 'ECV']
        fs (float): Field Strength of the MRI scanner in Tesla (T).. Options: ['1.5', '3']
        vendor (str): The manufacturer of the MRI scanner. Case-insensitive.. Options: ['Siemens', 'Philips']
        technique (str): The pulse sequence used for the measurement. Case-insensitive.. Options: ['MOLLI', 'ShMOLLI']
        """
        params = {'domain': 'T1_RELAX', 'parameter': parameter, 'fs': fs, 'vendor': vendor, 'technique': technique}
        return self._make_request(params)

    def t2_relaxation_values(self, parameter: str, author_year: str, fs: float, vendor: str, technique: str) -> Dict[str, Any]:
        """
        Retrieves reference values (mean, sd, ll, ul) for native T2 relaxation time by matching the exact combination of `author_year`, `fs` (field strength), `vendor`, and `technique`.
        
        ### Valid Parameter Combinations
        Not all authors have published data for all combinations of field strength and technique. You must use one of the following valid combinations:
        
        - **Wassmuth_2013**:
          - `fs=1.5`, `vendor=Siemens`, `technique=T2P bSSFP`
          - `fs=1.5`, `vendor=Siemens`, `technique=FLASH`
        - **Hinojar_2016**:
          - `fs=3`, `vendor=Philips`, `technique=GSE`
        - **Ridouani_2018**:
          - `fs=1.5`, `vendor=Siemens`, `technique=T2P bSSFP`
        - **Granitz_2019**:
          - `fs=1.5`, `vendor=Philips`, `technique=GSE`
          - `fs=3`, `vendor=Philips`, `technique=GSE`
        
        Args:
            parameter (str): Parameter name. Must be `T2_RELAX`.. Options: ['T2_RELAX']
        author_year (str): The publication source for the reference values.. Options: ['Wassmuth_2013', 'Hinojar_2016', 'Ridouani_2018', 'Granitz_2019']
        fs (float): MRI scanner field strength in Tesla.. Options: ['1.5', '3']
        vendor (str): The MRI scanner manufacturer.. Options: ['Siemens', 'Philips']
        technique (str): The specific MRI pulse sequence used.. Options: ['T2P bSSFP', 'FLASH', 'GSE']
        """
        params = {'domain': '15_T2_RELAX', 'parameter': parameter, 'author_year': author_year, 'fs': fs, 'vendor': vendor, 'technique': technique}
        return self._make_request(params)

    def mbf__values(self, parameter: str, author_year: str, gender: str) -> Dict[str, Any]:
        """
        Retrieves reference values for Myocardial Blood Flow (MBF) based on the specified parameter and author.
        
        ### Key Logic:
        - **Optional Gender:** The `gender` parameter is optional. 
          - If you provide a `gender` (e.g., `male`), the API will search for gender-specific data.
          - If you **omit** the `gender` parameter, the API will search for the overall, non-gender-specific value.
          - *Note:* Not all authors have provided gender-specific data.
        
        - **Data Availability:** Not every author has published data for every parameter. If you request a combination that does not exist in the data source (e.g., gender-specific data from an author who only published overall values), the API will return a `404 Not Found` error.
        
        Args:
            parameter (str): The specific MBF parameter to evaluate.. Options: ['MBF_REST', 'MBF_ADENOSINE_STRESS', 'PERF_RESERVE']
        author_year (str): The author/publication source for the reference data.. Options: ['Wang_2006', 'Madriago_2015', 'Brown_2018']
        gender (str): Optional. Specify to get gender-specific values. Omit for overall values.. Options: ['male', 'female']
        """
        params = {'domain': 'MBF', 'parameter': parameter, 'author_year': author_year, 'gender': gender}
        return self._make_request(params)

    def pediatric_reference_values(self, parameter: str, gender: str, age: float, av: float, ht_cm: float, wt_kg: float) -> Dict[str, Any]:
        """
        Calculates z-scores (SDS) and percentiles for Cardiac MRI parameters in pediatric patients.
        
        Args:
            parameter (str): Cardiac parameter to evaluate (must start with "LAVi" or "RAVi")
        gender (str): Patient gender. Options: ['Male', 'Female']
        age (float): Patient age in years

**Age Restrictions:**
- Male patients: 6-20 years
- Female patients: 4-18 years

        av (float): Measured atrial volume in millimeters (mm)
        ht_cm (float): Patient height in centimeters (cm)
        wt_kg (float): Patient weight in kilograms (kg)
        """
        params = {'domain': 'pediatric_atrial', 'parameter': parameter, 'gender': gender, 'age': age, 'av': av, 'ht_cm': ht_cm, 'wt_kg': wt_kg}
        return self._make_request(params)

    def pediatric_ventricle_reference_values(self, parameter: str, gender: str, measured: float, ht_cm: float, wt_kg: float) -> Dict[str, Any]:
        """
        Provides Z-scores, percentiles, and reference ranges for ventricular cardiac parameters in children (0-18 years) based on gender and body surface area (BSA), which is calculated from the provided height and weight.
        
        The reference values are derived from the paper: *'Multicentre reference values for cardiac magnetic resonance imaging derived ventricular size and function for children aged 0–18 years' (van der Ven et al., 2020)*. All calculations are based on allometric models using the patient's BSA.
        
        Args:
            parameter (str): The cardiac parameter to evaluate. Use the 'i' suffix for BSA-indexed values (e.g., LVEDVi).. Options: ['LVEDV', 'LVEDVi', 'LVESV', 'LVESVi', 'LVSV', 'LVSVi', 'LVM', 'LVMi', 'RVEDV', 'RVEDVi', 'RVESV', 'RVESVi', 'RVSV', 'RVSVi', 'RVM', 'RVMi']
        gender (str): Patient's gender.. Options: ['Male', 'Female']
        measured (float): The measured value of the specified parameter (e.g., in mL or mL/m²).
        ht_cm (float): Patient's height in centimeters (cm).
        wt_kg (float): Patient's weight in kilograms (kg).
        """
        params = {'domain': '18_PEDS_VENTRICLE', 'parameter': parameter, 'gender': gender, 'measured': measured, 'ht_cm': ht_cm, 'wt_kg': wt_kg}
        return self._make_request(params)

    def athlete_reference_values(self, parameter: str, gender: str, sport_act_hrs: float) -> Dict[str, Any]:
        """
        Provides reference values for cardiac parameters in athletes based on activity level.
        
        **Activity Level Categories:**
        - NON: Less than 9 hours of sports activity per week
        - REGULAR: 9-18 hours of sports activity per week
        - ELITE: More than 18 hours of sports activity per week (up to 168 hours/week)
        
        The API automatically derives the activity category from the provided sport_act_hrs value.
        
        Args:
            parameter (str): Cardiac parameter to evaluate. Options: ['LVEDV', 'LVEDV_BSA', 'LVESV', 'LVESV_BSA', 'LVM', 'LVM_BSA', 'LVEF', 'MX_IVS', 'RVEDV', 'RVEDV_BSA', 'RVESV', 'RVESV_BSA', 'RVM', 'RVM_BSA', 'RVEF']
        gender (str): Athlete gender. Options: ['Male', 'Female']
        sport_act_hrs (float): Hours of sports activity per week

**Valid Range:** 0-168 hours (168 hours = total hours in a week)

The API will automatically derive the activity category:
- < 9 hours: NON
- 9-18 hours: REGULAR
- > 18 hours: ELITE

        """
        params = {'domain': 'athletes', 'parameter': parameter, 'gender': gender, 'sport_act_hrs': sport_act_hrs}
        return self._make_request(params)

    def lv_reference_values(self, parameter: str, gender: str, pm: str, age: float) -> Dict[str, Any]:
        """
        Provides reference values for left ventricular parameters.
        
        Important notes:
        - The API matches the exact combination of `parameter`, `gender`, `pm`, and `age` to return appropriate reference values.
        - The `pm` parameter specifies whether papillary muscles are included in "mass" or "volume" calculations.
        - Age validation:
          - If `pm=mass`, request `age` **must** be between **18** and **83** (inclusive).
          - If `pm=volume`, request `age` **must** be between **16** and **83** (inclusive).
          - The `age` query parameter must be an integer. The sheet matching process prefers an exact numeric `age` row; if none exists it will fall back to a row with a blank age cell.
        
        Args:
            parameter (str): Cardiac parameter to evaluate. Options: ['LVEDV', 'LVEDVi', 'LVESV', 'LVESVi', 'LVSV', 'LVSVi', 'LVEF', 'LVM', 'LVMi', 'CO', 'CI', 'LVM/EDV']
        gender (str): Patient gender. Options: ['male', 'female']
        pm (str): Papillary muscle inclusion; one of `mass` or `volume`. Options: ['mass', 'volume']
        age (float): Patient age in years (integer).
Note: allowed request age range is 16–83 overall; however, if `pm=mass` the request age must be 18–83.

        """
        params = {'domain': 'LV', 'parameter': parameter, 'gender': gender, 'pm': pm, 'age': age}
        return self._make_request(params)

    def mpsv_aa_4_d__values(self, parameter: str, age: float) -> Dict[str, Any]:
        """
        Retrieves normal reference values (mean, sd, ll, ul) for ascending aorta mean peak systolic velocity based on the subject's age. Measured 6 cm proximal from the most cranial point of the aortic arch centerline.
        
        Args:
            parameter (str): The specific velocity parameter to evaluate.. Options: ['Velocity']
        age (float): Subject's age in years.
        """
        params = {'domain': 'MPSV_AA_4D', 'parameter': parameter, 'age': age}
        return self._make_request(params)

    def mavpv_4_d__values(self, parameter: str, gender: str, measured: float) -> Dict[str, Any]:
        """
        Retrieves normal mean aortic valve peak velocity reference values (mean, sd, ll, ul) by 4D‑flow CMR for men and women. It also calculates the percentile rank of a user-provided `measured` velocity. The peak velocity represents the maximum speed of blood flow across the aortic valve during systolic ejection.
        
        Args:
            parameter (str): The specific velocity parameter to evaluate.. Options: ['Velocity']
        gender (str): Gender of the subject. Case-insensitive.. Options: ['male', 'female']
        measured (float): The user-measured aortic valve peak velocity in m/s.
        """
        params = {'domain': 'MAVPV_4D', 'parameter': parameter, 'gender': gender, 'measured': measured}
        return self._make_request(params)

    def asl_da__values(self, parameter: str, gender: str, phase: str) -> Dict[str, Any]:
        """
        Retrieves normal reference values (units, mean, sd, ll, ul) for aortic sinus luminal diameters and area based on the subject's gender and the cardiac phase (systole or diastole).
        
        Args:
            parameter (str): The specific aortic sinus parameter to evaluate.. Options: ['ASD_CUCO', 'ASD_CUCO_BSA', 'ASD_CUCU', 'ASD_CUCU_BSA', 'ASA', 'ASA_BSA']
        gender (str): Gender of the subject. Case-insensitive.. Options: ['male', 'female']
        phase (str): The cardiac cycle phase. Case-insensitive.. Options: ['systole', 'diastole']
        """
        params = {'domain': 'ASL_DA', 'parameter': parameter, 'gender': gender, 'phase': phase}
        return self._make_request(params)

    def ta_d__values(self, parameter: str, gender: str, phase: str, technique: str) -> Dict[str, Any]:
        """
        Retrieves normal reference values (mean, sd, ll, ul) for thoracic aortic luminal diameters. The lookup requires an exact match for `parameter`, `gender`, `phase`, and `technique`.
        
        Args:
            parameter (str): The specific aortic segment to measure.. Options: ['ASC_AD', 'PRX_DES_AD', 'DIST_DES_AD']
        gender (str): Gender of the subject. Case-insensitive.. Options: ['male', 'female']
        phase (str): The cardiac cycle phase of the measurement.. Options: ['diastole']
        technique (str): The imaging technique used.. Options: ['bSSFP']
        """
        params = {'domain': 'TA_D', 'parameter': parameter, 'gender': gender, 'phase': phase, 'technique': technique}
        return self._make_request(params)

    def ta_d_a_wl__values(self, parameter: str, gender: str, age: float, technique: str) -> Dict[str, Any]:
        """
        Retrieves normal values of descending thoracic aortic diameter, area, and wall thickness for young men and women aged **25–35 years**.
        
        Args:
            parameter (str): The specific aortic parameter to evaluate.. Options: ['LD_DESC_AORTA', 'TD_DESC_AORTA', 'LA_DESC_AORTA', 'TA_DESC_AORTA', 'WA_DESC_AORTA', 'WT_DESC_AORTA']
        gender (str): Gender of the subject. Case-insensitive.. Options: ['male', 'female']
        age (float): The subject's age. Must be a whole number between 25 and 35, inclusive.
        technique (str): The imaging technique used.. Options: ['FS_3D_T1_BB_VISTA']
        """
        params = {'domain': 'TA_D', 'parameter': parameter, 'gender': gender, 'age': age, 'technique': technique}
        return self._make_request(params)

    def aa_d__values(self, parameter: str, gender: str, age: float, technique: str) -> Dict[str, Any]:
        """
        Retrieves reference values for ascending aortic diameter based on parameter type, gender, age, and imaging technique. Provides absolute and Body Surface Area (BSA) indexed normal values of ascending aortic luminal diameter for men and women of different age categories. Data is based on measurements from phase contrast images.
        
        Args:
            parameter (str): The specific aortic parameter to retrieve.. Options: ['AALD', 'AALD_BSA']
        gender (str): Gender of the subject. Case-insensitive.. Options: ['male', 'female']
        age (float): The subject's age in years as a whole number.
        technique (str): The imaging technique used for measurement.. Options: ['phase_contrast', 'FS_3D_T1_BB_VISTA']
        """
        params = {'domain': '25_AA_D', 'parameter': parameter, 'gender': gender, 'age': age, 'technique': technique}
        return self._make_request(params)

    def aortic_root_d__values(self, parameter: str, gender: str, technique: str) -> Dict[str, Any]:
        """
        Retrieves normal reference values (mean, sd, ll, ul) for aortic root diameters based on the measurement parameter, subject's gender, and imaging technique. Provides normal diameters of the aortic root for men and women, measured on sagittal left ventricular outflow tract balanced steady-state free precession (bSSFP) cardiac MRI.
        
        Args:
            parameter (str): The specific aortic root parameter to evaluate.. Options: ['AAD', 'AAD_BSA', 'ASD', 'ASD_BSA', 'STJD', 'STJD_BSA']
        gender (str): Gender of the subject. Case-insensitive.. Options: ['Male', 'Female']
        technique (str): The imaging technique used for the measurement.. Options: ['SAG_LVOT_bSSFP']
        """
        params = {'domain': 'AORTIC_ROOT_D', 'parameter': parameter, 'gender': gender, 'technique': technique}
        return self._make_request(params)

    def peds_aorta_csa_z_score(self, parameter: str, gender: str, level: str, measured: float, age: float) -> Dict[str, Any]:
        """
        Calculates the z-score, percentile, and normal limits for a measured aortic cross-sectional area based on the patient's age, gender, and the specific aortic level measured. Provides **LMS parameters to calculate z-scores for aortic cross-sectional area (CSA) relative to age** in children and young adults.
        
        Args:
            parameter (str): The parameter being measured. Must be `CSA`.. Options: ['CSA']
        gender (str): Gender of the patient. Case-insensitive.. Options: ['male', 'female']
        level (str): The anatomical level of the aorta where the measurement was taken.. Options: ['Ascending_Aorta', 'Aortic_Arch', 'Aortic_Isthmus', 'Descending_Aorta']
        measured (float): The measured cross-sectional area in mm².
        age (float): Patient's age in years. Use `0` for infants under 1 year.
        """
        params = {'domain': 'PEDS_AORTA_CSA', 'parameter': parameter, 'gender': gender, 'level': level, 'measured': measured, 'age': age}
        return self._make_request(params)

    def peds_aortic_d(self, parameter: str, wt_kg: float, ht_cm: float, measured: float) -> Dict[str, Any]:
        """
        Calculates normal aortic diameters in children based on a contrast-enhanced 3D-CMRA reference.
        
        Args:
            parameter (str): The anatomical site of the aortic measurement.. Options: ['AORTIC_SINUS', 'STJ', 'ASCENDING_AORTA', 'PRX_BCA', '1ST_TRANSVERSE_SEG', '2ND_TRANSVERSE_SEG', 'ISTMIC_REGION', 'DESCENDING_AORTA', 'TA_AT_DIAPH']
        wt_kg (float): Patient's weight in kilograms (kg). Used to calculate BSA.
        ht_cm (float): Patient's height in centimeters (cm). Used to calculate BSA.
        measured (float): The patient's measured aortic diameter in millimeters (mm).
        """
        params = {'domain': 'PEDS_AORTIC_D', 'parameter': parameter, 'wt_kg': wt_kg, 'ht_cm': ht_cm, 'measured': measured}
        return self._make_request(params)

    def adult_aa_distensibility__values(self, parameter: str, gender: str, age: float, site: str) -> Dict[str, Any]:
        """
        Retrieves reference values for regional aortic distensibility (RAD) based on the subject's gender, age, and measurement site. The data is based on measurements of the aortic root for men and women, typically acquired via sagittal left ventricular outflow tract balanced steady-state free precession (bSSFP) imaging.
        
        Args:
            parameter (str): The measurement parameter. Currently only `RAD` is supported.. Options: ['RAD']
        gender (str): Gender of the subject. Case-insensitive.. Options: ['Male', 'Female']
        age (float): The subject's age as a whole number.
        site (str): The anatomical site of the measurement.. Options: ['ASC_AORTA', 'PRX_DESC_AORTA']
        """
        params = {'domain': '29_AA_DISTENSIBILITY', 'parameter': parameter, 'gender': gender, 'age': age, 'site': site}
        return self._make_request(params)

    def lv_age_reference_values(self, parameter: str, gender: str, age: float, pm: str) -> Dict[str, Any]:
        """
        Retrieves standard reference values for various left ventricular (LV) parameters based on a patient's age, gender, and whether papillary muscles were included in the mass calculation.
        
        Args:
            parameter (str): The specific cardiac parameter for which to retrieve reference values.. Options: ['LVEDVi', 'LVESVi', 'LVSVi', 'LVEF', 'LVMi']
        gender (str): The gender of the patient (case-insensitive in lookup).. Options: ['male', 'female']
        age (float): The age of the patient in years. Used to determine the `age_grp`.
        pm (str): Specifies papillary muscle inclusion. Must be `mass`.. Options: ['mass']
        """
        params = {'domain': 'LV_AGE', 'parameter': parameter, 'gender': gender, 'age': age, 'pm': pm}
        return self._make_request(params)

    def adult_pwv__values(self, parameter: str, gender: str, age: float) -> Dict[str, Any]:
        """
        Retrieves normal reference values (median, 5th percentile, 95th percentile) for aortic pulse wave velocity based on the subject's age. The API matches the provided `age` to an age category (e.g., "30-39") in the reference data to find the correct values.
        
        Args:
            parameter (str): The specific PWV measurement parameter. `PWV` represents a regional aortic measurement.. Options: ['PWV']
        gender (str): Gender of the subject. Case-insensitive. (Not used in lookup but required for the call).. Options: ['male', 'female']
        age (float): The subject's age in years.
        """
        params = {'domain': 'ADULT_PWV', 'parameter': parameter, 'gender': gender, 'age': age}
        return self._make_request(params)

    def peds_aa_distensibility_z_score(self, parameter: str, gender: str, age: float, measured: float) -> Dict[str, Any]:
        """
        Provides **LMS parameters to calculate z-scores for distensibility of the ascending aorta (AA)** relative to age in children.
        
        Args:
            parameter (str): The parameter being measured. Must be `AA_DISTENSIBILITY`.. Options: ['AA_DISTENSIBILITY']
        gender (str): Gender of the patient. Case-insensitive.. Options: ['male', 'female']
        age (float): Patient's age in years. Use `0` for infants under 1 year.
        measured (float): The measured distensibility value (in 10^-3 mm Hg^-1).
        """
        params = {'domain': 'PEDS_AA_DISTENSIBILITY', 'parameter': parameter, 'gender': gender, 'age': age, 'measured': measured}
        return self._make_request(params)

    def peds_pwv_z_score(self, parameter: str, gender: str, age: float, measured: float) -> Dict[str, Any]:
        """
        Calculates the z-score, percentile, and normal limits for a measured pulse wave velocity (PWV) based on the patient's age and gender. Provides **LMS parameters to calculate z-scores for pulse wave velocity (PWV) relative to age** in children and young adults.
        
        Args:
            parameter (str): The parameter being measured. Must be `PWV`.. Options: ['PWV']
        gender (str): Gender of the patient. Case-insensitive.. Options: ['male', 'female']
        age (float): Patient's age in years. Use `0` for infants under 1 year.
        measured (float): The measured pulse wave velocity in m/s.
        """
        params = {'domain': 'PEDS_PWV', 'parameter': parameter, 'gender': gender, 'age': age, 'measured': measured}
        return self._make_request(params)

    def adult_pa_reference_values(self, parameter: str, gender: str, vessel: str) -> Dict[str, Any]:
        """
        Retrieves reference values for various pulmonary artery parameters based on vessel location and gender. Provides normal dimensions and distension values of the pulmonary arteries in healthy adults.
        
        Args:
            parameter (str): The specific parameter to evaluate.. Options: ['SYSTOLIC_DIAMETER', 'DIASTOLIC_DIAMETER', 'SYSTOLIC_AREA', 'DIASTOLIC_AREA', 'DISTENSION']
        gender (str): Gender of the subject. Case-insensitive.. Options: ['Male', 'Female']
        vessel (str): The pulmonary artery vessel to query (Main, Right, or Left).. Options: ['MPA', 'RPA', 'LPA']
        """
        params = {'domain': 'ADULT_PA', 'parameter': parameter, 'gender': gender, 'vessel': vessel}
        return self._make_request(params)

    def peds_pa__values(self, parameter: str, wt_kg: float, ht_cm: float, measured: float) -> Dict[str, Any]:
        """
        Calculates reference values and z-scores for pediatric pulmonary artery diameters based on a subject's weight, height, and a measured diameter. Diameters are measured perpendicular to the vessel on contrast-enhanced CMRA.
        
        Provides z-scores and normal reference diameters for the pulmonary arteries in children based on body surface area (BSA).
        
        Args:
            parameter (str): The specific pulmonary artery segment to evaluate.. Options: ['MPA_AXIAL', 'MPA_SAGITTAL', 'PRX_RPA_AX', 'DISTAL_RPA_AX', 'PRX_RPA_RAO', 'DISTAL_RPA_RAO', 'PRX_LPA_AX', 'DISTAL_LPA_AX', 'PRX_LPA_LAO', 'DISTAL_LPA_LAO']
        wt_kg (float): Subject's weight in kilograms (kg).
        ht_cm (float): Subject's height in centimeters (cm).
        measured (float): The observed/measured diameter in millimeters (mm).
        """
        params = {'domain': 'PEDS_PA', 'parameter': parameter, 'wt_kg': wt_kg, 'ht_cm': ht_cm, 'measured': measured}
        return self._make_request(params)

    def lv_reference(self, parameter: str, gender: str) -> Dict[str, Any]:
        """
        This endpoint returns reference values for Left Ventricular Functional and Geometric parameters
        based on query parameters.
        
        Args:
            parameter (str): The LV parameter to look up. Must be one of the allowed echocardiographic measurements.
. Options: ['PFRE', 'PFRE_BSA', 'PFRA_EDV', 'PFRA', 'PFRA_BSA', 'PFRA_PFRA', 'SEPTAL_AVPD', 'SEPTAL_AVPD_LL', 'LATERAL_AVPD', 'LATERAL_AVPD_LL', 'SPHERICITY_INDX_DIAS', 'SPHERICITY_INDX_SYS', 'LVEDD_4Ch', 'LVEDD_SAx', 'LVESD_4Ch', 'LVESD_SAx']
        gender (str): Gender for which to retrieve reference values.. Options: ['male', 'female']
        """
        params = {'domain': 'LV_FG', 'parameter': parameter, 'gender': gender}
        return self._make_request(params)

    def lv_fd_bmi__values(self, parameter: str, gender: str, BMI: float) -> Dict[str, Any]:
        """
        Retrieves normal reference values (mean, sd, ll, ul) for the maximal apical fractal dimension (FD) (unitless) of left ventricular trabeculation in the adult stratified by sex and body mass index (BMI) based on the subject's sex and BMI.
        
        Args:
            parameter (str): The specific fractal dimension parameter to evaluate. Currently, only `MX_AP_FD` (maximal apical fractal dimension) is supported.. Options: ['MX_AP_FD']
        gender (str): Gender of the subject. Case-insensitive.. Options: ['male', 'female']
        BMI (float): The subject's Body Mass Index as a numeric value.
        """
        params = {'domain': 'LV_FD_BMI', 'parameter': parameter, 'gender': gender, 'BMI': BMI}
        return self._make_request(params)

    def lv_fd_ethnicity__values(self, parameter: str, ethnicity: str) -> Dict[str, Any]:
        """
        Retrieves normal reference values (mean, sd, ll, ul) for left ventricular fractal dimension based on the parameter and ethnicity.
        
        Args:
            parameter (str): The specific fractal dimension parameter to evaluate (Global or Maximal Apical).. Options: ['GLB_FD', 'MX_AP_FD']
        ethnicity (str): Ethnicity of the subject group. Case-insensitive.. Options: ['Black', 'White', 'Singaporean Chinese']
        """
        params = {'domain': 'LV_FD_ETHINICITY', 'parameter': parameter, 'ethnicity': ethnicity}
        return self._make_request(params)

    def lv__strain__values(self, parameter: str, technique: str, gender: str) -> Dict[str, Any]:
        """
        Retrieves normal reference values (mean, sd, ll, ul) for LV global peak strain based on the parameter, imaging technique, and (conditionally) gender.
        **Conditional Gender:** The `gender` parameter is required **only** when `technique` is `2D_FT_CMR`. For other techniques (`TAGGED_CMR`, `3D_FT_CMR`), it must be omitted.
        
        Args:
            parameter (str): The strain parameter to evaluate.. Options: ['CIRCUM_STRAIN', 'LONG_STRAIN']
        technique (str): The imaging technique used to measure the strain.. Options: ['TAGGED_CMR', '2D_FT_CMR', '3D_FT_CMR']
        gender (str): Required **only** when `technique` is `2D_FT_CMR`. Should be omitted otherwise. Case-insensitive.. Options: ['male', 'female']
        """
        params = {'domain': 'LV_STRAIN', 'parameter': parameter, 'technique': technique, 'gender': gender}
        return self._make_request(params)

    def lvmt_reference_values(self, parameter: str, segment: str, gender: str) -> Dict[str, Any]:
        """
        Provides reference values for left ventricular myocardial thickness measurements.
        
        **Important Segment Note:**
        - For parameter=SA: Valid segments are Basal_Anterior, Basal_Anteroseptal, Basal_Inferoseptal, Basal_Inferior, Basal_Inferolateral, Basal_Anterolateral, Mid_Anterior, Mid_Anteroseptal, Mid_Inferoseptal, Mid_Inferior, Mid_Inferolateral, Mid_Anterolateral, Apical_Anterior, Apical_Septal, Apical_Inferior, Apical_Lateral
        - For parameter=LA: Valid segments are Basal_Anterior, Basal_Inferior, Basal_Septal, Basal_Lateral, Basal_Mean, Mid_Anterior, Mid_Inferior, Mid_Septal, Mid_Lateral, Mid_Mean, Apical_Anterior, Apical_Inferior, Apical_Septal, Apical_Lateral, Apical_Mean
        
        The API matches the exact combination of parameter, segment, and gender to return appropriate reference values.
        
        Args:
            parameter (str): Measurement type parameter. Options: ['SA', 'LA']
        segment (str): Cardiac segment to evaluate

**Important:** Valid segments differ based on parameter value:

**For SA (Short Axis):**
- Basal_Anterior
- Basal_Anteroseptal
- Basal_Inferoseptal
- Basal_Inferior
- Basal_Inferolateral
- Basal_Anterolateral
- Mid_Anterior
- Mid_Anteroseptal
- Mid_Inferoseptal
- Mid_Inferior
- Mid_Inferolateral
- Mid_Anterolateral
- Apical_Anterior
- Apical_Septal
- Apical_Inferior
- Apical_Lateral

**For LA (Long Axis):**
- Basal_Anterior
- Basal_Inferior
- Basal_Septal
- Basal_Lateral
- Basal_Mean
- Mid_Anterior
- Mid_Inferior
- Mid_Septal
- Mid_Lateral
- Mid_Mean
- Apical_Anterior
- Apical_Inferior
- Apical_Septal
- Apical_Lateral
- Apical_Mean

        gender (str): Patient gender. Options: ['Male', 'Female']
        """
        params = {'domain': 'LVMT', 'parameter': parameter, 'segment': segment, 'gender': gender}
        return self._make_request(params)

    def rv__values(self, parameter: str, gender: str, age: float, pm: str) -> Dict[str, Any]:
        """
        Retrieves normal reference values (mean, sd, ll, ul, units) for right ventricular measurements.
        **Papillary Muscles (`pm`):** This required parameter specifies how papillary muscles were treated in the original contouring: `mass` (included in mass, excluded from volume) or `volume` (included in volume, excluded from mass).
        
        Args:
            parameter (str): The specific cardiac parameter to evaluate.. Options: ['RVEDV', 'RVEDVi', 'RVESV', 'RVESVi', 'RVSV', 'RVSVi', 'RVEF', 'RVM', 'RVMi', 'RVCO', 'RVCi']
        gender (str): Gender of the subject. Case-insensitive.. Options: ['male', 'female']
        age (float): The subject's age as a whole number.
        pm (str): Papillary muscle inclusion method.. Options: ['mass', 'volume']
        """
        params = {'domain': 'RV', 'parameter': parameter, 'gender': gender, 'age': age, 'pm': pm}
        return self._make_request(params)

    def rv_age__values(self, parameter: str, gender: str, age: float) -> Dict[str, Any]:
        """
        Retrieves normal reference values (mean, sd, ll, ul) for right ventricular measurements based on the subject's age and gender.
        **Age Validation:** The API strictly accepts an `age` between **20 and 59**, inclusive. Any age outside this range will result in a `400 Bad Request` error.
        
        Args:
            parameter (str): The specific right ventricular parameter to evaluate.. Options: ['RVEDVi', 'RVESVi', 'RVSVi', 'RVEF']
        gender (str): Gender of the subject. Case-insensitive.. Options: ['male', 'female']
        age (float): The subject's age as a whole number. Must be between 20 and 59.
        """
        params = {'domain': 'RV_AGE', 'parameter': parameter, 'gender': gender, 'age': age}
        return self._make_request(params)
