Integrating Health Indices

In the embedded UX flow (the “Full UX flow” described here), Health Indices are integrated automatically. Risk factors are collected within the SDK flow, and the results are displayed in the SDK UI.

The instructions below apply only to API-based Health Indices computation, including standalone usage outside the video-measurement flow. Standalone does not mean “without SDK initialization”. These API calls still require an initialized SDK session, and the active license must allow Health Indices.

All RisksFactors values must be passed in metric units as documented on this page: centimeters, kilograms, mmHg, and mg/dL. This remains true even when the application UI accepts inputs in imperial units.

For common pitfalls related to partial output, standalone Wellness Score expectations, and custom UI formatting, see Health Indices troubleshooting.

Providing User Risk Factors

You should construct a RisksFactors object (or equivalent structure in your platform) and pass it to the risk-computation function. If certain data is missing, the relevant risks will not be computed. The following fields are available:


class RisksFactors {
  /// Age, in years
  int? age;
 
  /// Total cholesterol, mg/dL
  double? cholesterol;
 
  /// HDL cholesterol, mg/dL
  double? cholesterolHdl;
 
  /// Systolic blood pressure, mmHg
  double? sbp;
 
  /// Diastolic blood pressure, mmHg
  double? dbp;
 
  bool? isSmoker;
  HypertensionTreatment? hypertensionTreatment;
  bool? hasDiabetes;
 
  /// Body height, centimeters
  double? bodyHeight;
 
  /// Body weight, kilograms
  double? bodyWeight;
 
  /// Waist circumference, centimeters
  double? waistCircumference;
 
  /// Neck circumference, centimeters
  double? neckCircumference;
 
  /// Hip circumference, centimeters
  double? hipCircumference;
 
  Gender? gender;
 
  /// Two-letter ISO country code, e.g. "US"
  String? country;
 
  Race? race;
 
  /// Physical activity level
  PhysicalActivity? physicalActivity;
 
  /// Triglyceride level, mg/dL
  double? triglyceride;
 
  /// Fasting glucose level, mg/dL
  double? fastingGlucose;
 
  bool? vegetableFruitDiet;
 
  bool? historyOfHighGlucose;
 
  bool? historyOfHypertension;
 
  ParentalHistory? parentalHypertension;
 
  FamilyHistory? familyDiabetes;
}
 
enum Gender {
  MALE(0),
  FEMALE(1),
  OTHER(2);
}
 
enum Race {
  WHITE(0),
  AFRICAN_AMERICAN(1),
  OTHER(2);
}
 
enum PhysicalActivity {
  SEDENTARY(0),
  LIGHTLY_ACTIVE(1),
  MODERATELY(2),
  VERY_ACTIVE(3),
  EXTRA_ACTIVE(4);
}
 
enum HypertensionTreatment {
  NOT_NEEDED(0),
  NO(1),
  YES(2);
}
 
enum ParentalHistory {
  NONE(0),
  ONE(1),
  BOTH(2);
}
 
enum FamilyHistory {
  NONE(0),
  NONE_FIRST_DEGREE(1),
  FIRST_DEGREE(2);
}


interface RisksFactors {
  /** Age, in years */
  age?: number;
  /** Total cholesterol, mg/dL */
  cholesterol?: number;
  /** HDL cholesterol, mg/dL */
  cholesterolHdl?: number;
  /** Systolic blood pressure, mmHg */
  sbp?: number;
 
  /** Diastolic blood pressure, mmHg */
  dbp?: number;
 
  isSmoker?: boolean;
  hypertensionTreatment?: HypertensionTreatment;
  hasDiabetes?: boolean;
 
  /** Body height, centimeters */
  bodyHeight?: number;
  /** Body weight, kilograms */
  bodyWeight?: number;
  /** Waist circumference, centimeters */
  waistCircumference?: number;
  /** Neck circumference, centimeters */
  neckCircumference?: number;
  /** Hip circumference, centimeters */
  hipCircumference?: number;
 
  gender?: Gender;
  /** Two-letter ISO country code, e.g. "US" */
  country?: string;
  race?: Race;
 
  /** Physical activity level */
  physicalActivity?: PhysicalActivity;
 
  vegetableFruitDiet?: boolean;
  historyOfHypertension?: boolean;
  historyOfHighGlucose?: boolean;
  /** Fasting glucose level, mg/dL */
  fastingGlucose?: number;
  /** Triglyceride level, mg/dL */
  triglyceride?: number;
  parentalHypertension?: ParentalHistory;
  familyDiabetes?: FamilyHistory;
}
 
const enum Gender {
  MALE = 0,
  FEMALE,
  OTHER,
}
 
const enum Race {
  WHITE = 0,
  AFRICAN_AMERICAN,
  OTHER,
}
 
const enum PhysicalActivity {
  SEDENTARY = 0,
  LIGHTLY_ACTIVE,
  MODERATELY,
  VERY_ACTIVE,
  EXTRA_ACTIVE,
}
 
const enum HypertensionTreatment {
  NOT_NEEDED = 0,
  NO,
  YES,
}
 
const enum ParentalHistory {
  NONE = 0,
  ONE,
  BOTH,
}
 
const enum FamilyHistory {
  NONE = 0,
  NONE_FIRST_DEGREE,
  FIRST_DEGREE,
}


interface RisksFactors {
  /** Age, in years */
  age?: number;
  /** Total cholesterol, mg/dL */
  cholesterol?: number;
  /** HDL cholesterol, mg/dL */
  cholesterolHdl?: number;
  /** Systolic blood pressure, mmHg */
  sbp?: number;
 
  /** Diastolic blood pressure, mmHg */
  dbp?: number;
 
  isSmoker?: boolean;
  hypertensionTreatment?: HypertensionTreatment;
  hasDiabetes?: boolean;
 
  /** Body height, centimeters */
  bodyHeight?: number;
  /** Body weight, kilograms */
  bodyWeight?: number;
  /** Waist circumference, centimeters */
  waistCircumference?: number;
  /** Neck circumference, centimeters */
  neckCircumference?: number;
  /** Hip circumference, centimeters */
  hipCircumference?: number;
 
  gender?: Gender;
  /** Two-letter ISO country code, e.g. "US" */
  country?: string;
  race?: Race;
 
  /** Physical activity level */
  physicalActivity?: PhysicalActivity;
 
  vegetableFruitDiet?: boolean;
  historyOfHypertension?: boolean;
  historyOfHighGlucose?: boolean;
  /** Fasting glucose level, mg/dL */
  fastingGlucose?: number;
  /** Triglyceride level, mg/dL */
  triglyceride?: number;
  parentalHypertension?: ParentalHistory;
  familyDiabetes?: FamilyHistory;
}
 
const enum Gender {
  MALE = 0,
  FEMALE,
  OTHER,
}
 
const enum Race {
  WHITE = 0,
  AFRICAN_AMERICAN,
  OTHER,
}
 
const enum PhysicalActivity {
  SEDENTARY = 0,
  LIGHTLY_ACTIVE,
  MODERATELY,
  VERY_ACTIVE,
  EXTRA_ACTIVE,
}
 
const enum HypertensionTreatment {
  NOT_NEEDED = 0,
  NO,
  YES,
}
 
const enum ParentalHistory {
  NONE = 0,
  ONE,
  BOTH,
}
 
const enum FamilyHistory {
  NONE = 0,
  NONE_FIRST_DEGREE,
  FIRST_DEGREE,
}


public sealed class RisksFactors
{
    public int? Age { get; set; }
    public double? Cholesterol { get; set; }
    public double? CholesterolHdl { get; set; }
    public double? Sbp { get; set; }
    public double? Dbp { get; set; }
    public bool? IsSmoker { get; set; }
    public HypertensionTreatment? HypertensionTreatment { get; set; }
    public bool? HasDiabetes { get; set; }
    public double? BodyHeight { get; set; }
    public double? BodyWeight { get; set; }
    public double? WaistCircumference { get; set; }
    public double? NeckCircumference { get; set; }
    public double? HipCircumference { get; set; }
    public Gender? Gender { get; set; }
    public string? Country { get; set; }
    public Race? Race { get; set; }
    public PhysicalActivity? PhysicalActivity { get; set; }
    public bool? VegetableFruitDiet { get; set; }
    public bool? HistoryOfHypertension { get; set; }
    public bool? HistoryOfHighGlucose { get; set; }
    public double? FastingGlucose { get; set; }
    public double? Triglyceride { get; set; }
    public ParentalHistory? ParentalHypertension { get; set; }
    public FamilyHistory? FamilyDiabetes { get; set; }
}
 
public enum Gender { MALE = 0, FEMALE, OTHER }
public enum Race { WHITE = 0, AFRICAN_AMERICAN, OTHER }
public enum PhysicalActivity { SEDENTARY = 0, LIGHTLY_ACTIVE, MODERATELY, VERY_ACTIVE, EXTRA_ACTIVE }
public enum HypertensionTreatment { NOT_NEEDED = 0, NO, YES }
public enum ParentalHistory { NONE = 0, ONE, BOTH }
public enum FamilyHistory { NONE = 0, NONE_FIRST_DEGREE, FIRST_DEGREE }


public class RisksFactors {
  public Optional<Integer> age;           // years
  public Optional<Float> cholesterol;     // mg/dL
  public Optional<Float> cholesterolHdl;  // mg/dL
  public Optional<Float> sbp;            // mmHg
  public Optional<Float> dbp;            // mmHg
 
  public Optional<Boolean> isSmoker;
  public Optional<HypertensionTreatment> hypertensionTreatment;
  public Optional<Boolean> hasDiabetes;
 
  public Optional<Float> bodyHeight;         // centimeters
  public Optional<Float> bodyWeight;         // kilograms
  public Optional<Float> waistCircumference; // centimeters
  public Optional<Float> neckCircumference;  // centimeters
  public Optional<Float> hipCircumference;   // centimeters
 
  public Optional<Gender> gender;
  public String country; // 2-letter ISO code, e.g. "US"
  public Optional<Race> race;
 
  public Optional<PhysicalActivity> physicalActivity;
 
  public Optional<ParentalHistory> parentalHypertension;
  public Optional<FamilyHistory> familyDiabetes;
  public Optional<Float> triglyceride;    // mg/dL
  public Optional<Float> fastingGlucose;  // mg/dL
  public Optional<Boolean> vegetableFruitDiet;
  public Optional<Boolean> historyOfHighGlucose;
  public Optional<Boolean> historyOfHypertension;
}
 
public enum Gender {
  MALE,
  FEMALE,
  OTHER
}
 
public enum Race {
  WHITE,
  AFRICAN_AMERICAN,
  OTHER
}
 
public enum PhysicalActivity {
  SEDENTARY,
  LIGHTLY_ACTIVE,
  MODERATELY,
  VERY_ACTIVE,
  EXTRA_ACTIVE
}
 
public enum HypertensionTreatment {
  NOT_NEEDED,
  NO,
  YES
}
 
public enum ParentalHistory {
  NONE,
  ONE,
  BOTH
}
 
public enum FamilyHistory {
  NONE,
  NONE_FIRST_DEGREE,
  FIRST_DEGREE
}


interface RisksFactors {
  age?: number;                  // years
  cholesterol?: number;          // mg/dL
  cholesterolHdl?: number;       // mg/dL
  sbp?: number;                  // mmHg
  dbp?: number;                  // mmHg
 
  isSmoker?: boolean;
  hypertensionTreatment?: HypertensionTreatment;  
  //   ↳ HypertensionTreatment.NOT_NEEDED | .NO | .YES
 
  hasDiabetes?: boolean;
 
  bodyHeight?: number;           // centimeters
  bodyWeight?: number;           // kilograms
  waistCircumference?: number;   // centimeters
  neckCircumference?: number;    // centimeters
  hipCircumference?: number;     // centimeters
 
  gender?: Gender;               
  //   ↳ Gender.MALE | .FEMALE | .OTHER
 
  country?: string;              // 2-letter ISO code, e.g. "US"
 
  race?: Race;                   
  //   ↳ Race.WHITE | .AFRICAN_AMERICAN | .OTHER
 
  physicalActivity?: PhysicalActivity;  
  //   ↳ PhysicalActivity.SEDENTARY | .LIGHTLY_ACTIVE 
  //     | .MODERATELY | .VERY_ACTIVE | .EXTRA_ACTIVE
 
  vegetableFruitDiet?: boolean;
  historyOfHypertension?: boolean;
  historyOfHighGlucose?: boolean;
 
  fastingGlucose?: number;       // mg/dL
  triglyceride?: number;         // mg/dL
 
  parentalHypertension?: ParentalHistory;  
  //   ↳ ParentalHistory.NONE | .ONE | .BOTH
 
  familyDiabetes?: FamilyHistory;  
  //   ↳ FamilyHistory.NONE | .NONE_FIRST_DEGREE | .FIRST_DEGREE
}


shen_risks_factors_t factors = {0};
factors.has_age = 1;
factors.age = 42;
factors.has_cholesterol = 1;
factors.cholesterol = 180.0f;
factors.has_sbp = 1;
factors.sbp = 120.0f;
factors.has_gender = 1;
factors.gender = SHEN_GENDER_FEMALE;
factors.country = "US";
 
/* Enums: SHEN_GENDER_*, SHEN_RACE_*, SHEN_PHYSICAL_ACTIVITY_*, */
/* SHEN_HYPERTENSION_TREATMENT_*, SHEN_PARENTAL_HISTORY_*, SHEN_FAMILY_HISTORY_* */


from shenai_sdk import RisksFactors, Gender
 
factors = RisksFactors(
  age=42,
  cholesterol=180.0,
  sbp=120.0,
  gender=Gender.FEMALE,
  country="US",
)


class RisksFactors : NSObject {
  var age: NSNumber?              // years
  var cholesterol: NSNumber?      // mg/dL
  var cholesterolHDL: NSNumber?   // mg/dL
  var sbp: NSNumber?              // mmHg
  var dbp: NSNumber?              // mmHg
 
  var isSmoker: NSNumber?
  var hypertensionTreatment: HypertensionTreatment?
  var hasDiabetes: NSNumber?
 
  var bodyHeight: NSNumber?       // centimeters
  var bodyWeight: NSNumber?       // kilograms
  var waistCircumference: NSNumber? // centimeters
  var neckCircumference: NSNumber? // centimeters
  var hipCircumference: NSNumber? // centimeters
 
  var gender: Gender?
  var country: String?  // 2-letter ISO code, e.g. "US"
  var race: Race?
 
  var physicalActivity: PhysicalActivity?
 
  var vegetableFruitDiet: NSNumber?
  var historyOfHypertension: NSNumber?
  var historyOfHighGlucose: NSNumber?
  var fastingGlucose: NSNumber?    // mmHg
  var triglyceride: NSNumber?      // mmHg
  var parentalHypertension: ParentalHistory?
  var familyDiabetes: FamilyHistory?
}
 
enum Gender {
  case male
  case female
  case other
}
 
enum Race {
  case white
  case africanAmerican
  case other
}
 
enum PhysicalActivity {
  case sedentary
  case lightlyActive
  case moderately
  case veryActive
  case extraActive
}
 
enum HypertensionTreatment {
  case notNeeded
  case no
  case yes
}
 
enum FamilyHistory {
  case none
  case noneFirstDegree
  case firstDegree
}
 
enum ParentalHistory {
  case none
  case one
  case both
}

Computing Health Risks

Call the computeHealthRisks() function with the RisksFactors object to compute all the available risk indices and body composition metrics. The returned structure is HealthRisks.

If some data is not provided, then any risk requiring that data will not be computed.

computeHealthRisks() runs against the initialized SDK runtime. If the SDK is not initialized yet, or the active license does not include Health Indices, the returned object can be empty.


static HealthRisks computeHealthRisks(RisksFactors factors);
 
class HealthRisks {
  HardAndFatalEventsRisks hardAndFatalEvents;
  CVDiseasesRisks cvDiseases;
  int? vascularAge;
 
  /// Computed waist-to-height ratio (WHtR)
  double? waistToHeightRatio;
 
  /// Computed body fat percentage (BFP)
  double? bodyFatPercentage;
 
  /// Computed basal metabolic rate (BMR)
  double? basalMetabolicRate;
 
  /// Computed body roundness index (BRI)
  double? bodyRoundnessIndex;
 
  /// Computed a body shape index (ABSI)
  double? aBodyShapeIndex;
 
  /// Computed conicity index (CI)
  double? conicityIndex;
 
  /// Computed total daily energy expenditure (TDEE)
  double? totalDailyEnergyExpenditure;
 
  /// Computed wellness score (WS)
  double? wellnessScore;
 
  RisksFactorsScores scores;
 
  /// Computed hypertension risk
  double? hypertensionRisk;
 
  /// Computed diabeted risk
  double? diabetesRisk;
 
  /// Computed non alcoholic fatty liver disease risk
  NAFLDRisk? nonAlcoholicFattyLiverDiseaseRisk;
}


import { computeHealthRisks, RisksFactors } from "react-native-shenai-sdk";
 
async function computeHealthRisks(factors: RisksFactors): Promise<HealthRisks>;
 
interface HealthRisks {
  hardAndFatalEvents: HardAndFatalEventsRisks;
  cvDiseases: CVDiseasesRisks;
  vascularAge: number | null;
  waistToHeightRatio: number | null;
  bodyFatPercentage: number | null;
  basalMetabolicRate: number | null;
  bodyRoundnessIndex: number | null;
  aBodyShapeIndex: number | null;
  conicityIndex: number | null;
  totalDailyEnergyExpenditure: number | null;
  wellnessScore: number | null;
  scores: RisksFactorsScores;
  hypertensionRisk?: number | null;
  diabetesRisk?: number | null;
  nonAlcoholicFattyLiverDiseaseRisk?: NAFLDRisk | null;
}


import { ShenaiSdkCapacitor, RisksFactors, HealthRisks } from 'capacitor-shenai-sdk';
 
async function computeHealthRisks(factors: RisksFactors): Promise<HealthRisks> {
  const { value } = await ShenaiSdkCapacitor.computeHealthRisks({ risksFactors: factors });
  return value;
}
 
interface HealthRisks {
  hardAndFatalEvents: HardAndFatalEventsRisks;
  cvDiseases: CVDiseasesRisks;
  vascularAge: number | null;
  waistToHeightRatio: number | null;
  bodyFatPercentage: number | null;
  basalMetabolicRate: number | null;
  bodyRoundnessIndex: number | null;
  aBodyShapeIndex: number | null;
  conicityIndex: number | null;
  totalDailyEnergyExpenditure: number | null;
  wellnessScore: number | null;
  scores: RisksFactorsScores;
  hypertensionRisk?: number | null;
  diabetesRisk?: number | null;
  nonAlcoholicFattyLiverDiseaseRisk?: NAFLDRisk | null;
}


using Shenai.Maui;
 
HealthRisks risks = await ShenaiSdk.ComputeHealthRisksAsync(factors);
 
public sealed class HealthRisks
{
    public HardAndFatalEventsRisks HardAndFatalEvents { get; set; } = new();
    public CVDiseasesRisks CvDiseases { get; set; } = new();
    public int? VascularAge { get; set; }
    public double? WaistToHeightRatio { get; set; }
    public double? BodyFatPercentage { get; set; }
    public double? BasalMetabolicRate { get; set; }
    public double? BodyRoundnessIndex { get; set; }
    public double? ABodyShapeIndex { get; set; }
    public double? ConicityIndex { get; set; }
    public double? TotalDailyEnergyExpenditure { get; set; }
    public double? WellnessScore { get; set; }
    public RisksFactorsScores Scores { get; set; } = new();
    public double? HypertensionRisk { get; set; }
    public double? DiabetesRisk { get; set; }
    public NAFLDRisk? NonAlcoholicFattyLiverDiseaseRisk { get; set; }
}


public HealthRisks computeHealthRisks(RisksFactors factors);
 
public class HealthRisks {
  public HardAndFatalEventsRisks hardAndFatalEvents;
  public CVDiseasesRisks cvDiseases;
  public Optional<Integer> vascularAge;
  public Optional<Integer> waistToHeightRatio;
  public Optional<Integer> bodyFatPercentage;
  public Optional<Integer> basalMetabolicRate;
  public Optional<Float> bodyRoundnessIndex;
  public Optional<Float> aBodyShapeIndex;
  public Optional<Float> conicityIndex;
  public Optional<Float> totalDailyEnergyExpenditure;
  public Optional<Float> wellnessScore;
  public RisksFactorsScores scores;
  public Optional<Float> hypertensionRisk;
  public Optional<Float> diabetesRisk;
  public Optional<NAFLDRisk> nonAlcoholicFattyLiverDiseaseRisk;
}


computeHealthRisks: (factors: RisksFactors) => HealthRisks;
 
interface HealthRisks {
  hardAndFatalEvents: HardAndFatalEventsRisks;
  cvDiseases: CVDiseasesRisks;
  vascularAge: number | null;
  waistToHeightRatio: number | null;
  bodyFatPercentage: number | null;
  basalMetabolicRate: number | null;
  bodyRoundnessIndex: number | null;
  aBodyShapeIndex: number | null;
  conicityIndex: number | null;
  totalDailyEnergyExpenditure: number | null;
  wellnessScore: number | null;
  scores: RisksFactorsScores;
  hypertensionRisk?: number | null;
  diabetesRisk?: number | null;
  nonAlcoholicFattyLiverDiseaseRisk?: NAFLDRisk | null;
  //   ↳ NAFLDRisk.LOW | .MODERATE | .HIGH
}


shen_health_risks_t risks = {0};
shen_compute_health_risks(ctx, &factors, &risks);


risks = sdk.compute_health_risks(factors)


class ShenaiHealthRisks {
  func computeHealthRisks(_ factors: RisksFactors) -> HealthRisks
}
 
class HealthRisks {
  var hardAndFatalEvents: HardAndFatalEventsRisks
  var cvDiseases: CVDiseasesRisks
  var vascularAge: NSNumber?                  // e.g. 52
  var waistToHeightRatio: NSNumber?           // e.g. 0.51
  var bodyFatPercentage: NSNumber?            // e.g. 24.0
  var basalMetabolicRate: NSNumber?           // e.g. 1435
  var bodyRoundnessIndex: NSNumber?           // e.g. 4.7
  var aBodyShapeIndex: NSNumber?              // e.g. 0.087
  var conicityIndex: NSNumber?                // e.g. 1.28
  var totalDailyEnergyExpenditure: NSNumber?  // e.g. 2200
  var wellnessScore: NSNumber?                // e.g. 78
  var scores: RisksFactorsScores
  var hypertensionRisk: NSNumber?
  var diabetesRisk: NSNumber?
  var nonAlcoholicFattyLiverDiseaseRisk: NAFLDRisk
}

Substructures

The HealthRisks object contains multiple substructures:


enum NAFLDRisk {
  low,
  moderate,
  high,
}
 
class HardAndFatalEventsRisks {
  final double? coronaryDeathEventRisk;
  final double? fatalStrokeEventRisk;
  final double? totalCVMortalityRisk;
  final double? hardCVEventRisk;
}
 
class CVDiseasesRisks {
  final double? overallRisk;
  final double? coronaryHeartDiseaseRisk;
  final double? strokeRisk;
  final double? heartFailureRisk;
  final double? peripheralVascularDiseaseRisk;
}
 
class RisksFactorsScores {
  final int? ageScore;
  final int? sbpScore;
  final int? smokingScore;
  final int? diabetesScore;
  final int? bmiScore;
  final int? cholesterolScore;
  final int? cholesterolHdlScore;
  final int? totalScore;
}


const enum NAFLDRisk {
  LOW = 0,
  MODERATE,
  HIGH,
}
 
interface HardAndFatalEventsRisks {
  coronaryDeathEventRisk: number | null;
  fatalStrokeEventRisk: number | null;
  totalCVMortalityRisk: number | null;
  hardCVEventRisk: number | null;
}
 
interface CVDiseasesRisks {
  overallRisk: number | null;
  coronaryHeartDiseaseRisk: number | null;
  strokeRisk: number | null;
  heartFailureRisk: number | null;
  peripheralVascularDiseaseRisk: number | null;
}
 
interface RisksFactorsScores {
  ageScore: number | null;
  sbpScore: number | null;
  smokingScore: number | null;
  diabetesScore: number | null;
  bmiScore: number | null;
  cholesterolScore: number | null;
  cholesterolHdlScore: number | null;
  totalScore: number | null;
}


enum NAFLDRisk {
  LOW = 0,
  MODERATE,
  HIGH,
}
 
interface HardAndFatalEventsRisks {
  coronaryDeathEventRisk: number | null;
  fatalStrokeEventRisk: number | null;
  totalCVMortalityRisk: number | null;
  hardCVEventRisk: number | null;
}
 
interface CVDiseasesRisks {
  overallRisk: number | null;
  coronaryHeartDiseaseRisk: number | null;
  strokeRisk: number | null;
  heartFailureRisk: number | null;
  peripheralVascularDiseaseRisk: number | null;
}
 
interface RisksFactorsScores {
  ageScore: number | null;
  sbpScore: number | null;
  smokingScore: number | null;
  diabetesScore: number | null;
  bmiScore: number | null;
  cholesterolScore: number | null;
  cholesterolHdlScore: number | null;
  totalScore: number | null;
}


public enum NAFLDRisk { LOW = 0, MODERATE, HIGH }
 
public sealed class HardAndFatalEventsRisks
{
    public double? CoronaryDeathEventRisk { get; set; }
    public double? FatalStrokeEventRisk { get; set; }
    public double? TotalCVMortalityRisk { get; set; }
    public double? HardCVEventRisk { get; set; }
}
 
public sealed class CVDiseasesRisks
{
    public double? OverallRisk { get; set; }
    public double? CoronaryHeartDiseaseRisk { get; set; }
    public double? StrokeRisk { get; set; }
    public double? HeartFailureRisk { get; set; }
    public double? PeripheralVascularDiseaseRisk { get; set; }
}
 
public sealed class RisksFactorsScores
{
    public int? AgeScore { get; set; }
    public int? SbpScore { get; set; }
    public int? SmokingScore { get; set; }
    public int? DiabetesScore { get; set; }
    public int? BmiScore { get; set; }
    public int? CholesterolScore { get; set; }
    public int? CholesterolHdlScore { get; set; }
    public int? TotalScore { get; set; }
}


public enum NAFLDRisk {
  LOW,
  MODERATE,
  HIGH
}
 
public class HardAndFatalEventsRisks {
  public Optional<Float> coronaryDeathEventRisk;
  public Optional<Float> fatalStrokeEventRisk;
  public Optional<Float> totalCVMortalityRisk;
  public Optional<Float> hardCVEventRisk;
}
 
public class CVDiseasesRisks {
  public Optional<Float> overallRisk;
  public Optional<Float> coronaryHeartDiseaseRisk;
  public Optional<Float> strokeRisk;
  public Optional<Float> heartFailureRisk;
  public Optional<Float> peripheralVascularDiseaseRisk;
}
 
public class RisksFactorsScores {
  public Optional<Integer> ageScore;
  public Optional<Integer> sbpScore;
  public Optional<Integer> smokingScore;
  public Optional<Integer> diabetesScore;
  public Optional<Integer> bmiScore;
  public Optional<Integer> cholesterolScore;
  public Optional<Integer> cholesterolHdlScore;
  public Optional<Integer> totalScore;
}


interface HardAndFatalEventsRisks {
  coronaryDeathEventRisk: number | null;
  fatalStrokeEventRisk: number | null;
  totalCVMortalityRisk: number | null;
  hardCVEventRisk: number | null;
}
 
interface CVDiseasesRisks {
  overallRisk: number | null;
  coronaryHeartDiseaseRisk: number | null;
  strokeRisk: number | null;
  heartFailureRisk: number | null;
  peripheralVascularDiseaseRisk: number | null;
}
 
interface RisksFactorsScores {
  ageScore: number | null;
  sbpScore: number | null;
  smokingScore: number | null;
  diabetesScore: number | null;
  bmiScore: number | null;
  cholesterolScore: number | null;
  cholesterolHdlScore: number | null;
  totalScore: number | null;
}


/* Substructures are available inside shen_health_risks_t. */
shen_health_risks_t risks = {0};
/* Filled via shen_compute_health_risks(). */
if (risks.hard_and_fatal_events.has_hard_cv_event_risk) {
  double value = risks.hard_and_fatal_events.hard_cv_event_risk;
}
 
/* NAFLD risk enum values: */
SHEN_NAFLD_RISK_LOW;
SHEN_NAFLD_RISK_MODERATE;
SHEN_NAFLD_RISK_HIGH;


from shenai_sdk import NafldRisk
 
risks = sdk.compute_health_risks(factors)
value = risks.hard_and_fatal_events.hard_cv_event_risk
 
NafldRisk.LOW
NafldRisk.MODERATE
NafldRisk.HIGH


enum NAFLDRisk {
  case low
  case moderate
  case high
}
 
class HardAndFatalEventsRisks {
  var coronaryDeathEventRisk: NSNumber?
  var fatalStrokeEventRisk: NSNumber?
  var totalCvMortalityRisk: NSNumber?
  var hardCvEventRisk: NSNumber?
}
 
class CVDiseasesRisks {
  var overallRisk: NSNumber?
  var coronaryHeartDiseaseRisk: NSNumber?
  var strokeRisk: NSNumber?
  var heartFailureRisk: NSNumber?
  var peripheralVascularDiseaseRisk: NSNumber?
}
 
class RisksFactorsScores {
  var ageScore: NSNumber?
  var sbpScore: NSNumber?
  var smokingScore: NSNumber?
  var diabetesScore: NSNumber?
  var bmiScore: NSNumber?
  var cholesterolScore: NSNumber?
  var cholesterolHdlScore: NSNumber?
  var totalScore: NSNumber?
}

Minimal, Maximal, and Reference Values

Different metrics have different ranges depending on the user’s risk factors. Shen.AI provides methods to retrieve the minimum and maximum values that define the normal range for each index or the low-risk range for each risk. These values indicate the lower and upper bounds of the defined range for a given metric. For some risks, the low-risk range is determined based on a combination of multiple metrics rather than a single value. Some metrics, however, are highly individual and do not have strict “normal ranges,” so no minimum or maximum is defined for them.

Reference values represent a “typical healthy profile” – the same demographics (age, gender, country, race) as the user, but with all other risk factors set to clinically normal levels. They serve as a benchmark when you need to compare a user’s current outcome against what we expect for someone like them with ideal metrics.

getMinimalRisks() and getMaximalRisks() return helper ranges for the indices, not the contribution of each input factor. It is expected that some fields are null because not every output has a strict minimum or maximum benchmark. In particular, these helpers do not populate every derived field in HealthRisks such as Wellness Score or factor-score breakdowns.


static HealthRisks getMinimalHealthRisks(RisksFactors factors);
static HealthRisks getMaximalHealthRisks(RisksFactors factors);
static HealthRisks getReferenceHealthRisks(RisksFactors factors);


import {
  getMinimalRisks,
  getMaximalRisks,
  getReferenceRisks,
} from "react-native-shenai-sdk";
 
async function getMinimalRisks(factors: RisksFactors): Promise<HealthRisks>;
async function getMaximalRisks(factors: RisksFactors): Promise<HealthRisks>;
async function getReferenceRisks(factors: RisksFactors): Promise<HealthRisks>;


import { ShenaiSdkCapacitor, RisksFactors, HealthRisks } from 'capacitor-shenai-sdk';
 
const { value: minRisks } = await ShenaiSdkCapacitor.getMinimalRisks({ risksFactors: factors });
const { value: maxRisks } = await ShenaiSdkCapacitor.getMaximalRisks({ risksFactors: factors });
const { value: refRisks } = await ShenaiSdkCapacitor.getReferenceRisks({ risksFactors: factors });


using Shenai.Maui;
 
var minRisks = await ShenaiSdk.GetMinimalRisksAsync(factors);
var maxRisks = await ShenaiSdk.GetMaximalRisksAsync(factors);
var refRisks = await ShenaiSdk.GetReferenceRisksAsync(factors);


public HealthRisks getMinimalHealthRisks(RisksFactors factors);
public HealthRisks getMaximalHealthRisks(RisksFactors factors);
public HealthRisks getReferenceHealthRisks(RisksFactors factors);


getMinimalRisks: (factors: RisksFactors) => HealthRisks;
getMaximalRisks: (factors: RisksFactors) => HealthRisks;
getReferenceRisks: (factors: RisksFactors) => HealthRisks;


shen_health_risks_t min_risks = {0};
shen_health_risks_t max_risks = {0};
shen_health_risks_t ref_risks = {0};
 
shen_get_minimal_health_risks(ctx, &factors, &min_risks);
shen_get_maximal_health_risks(ctx, &factors, &max_risks);
shen_get_reference_health_risks(ctx, &factors, &ref_risks);


min_risks = sdk.get_minimal_health_risks(factors)
max_risks = sdk.get_maximal_health_risks(factors)
ref_risks = sdk.get_reference_health_risks(factors)


class ShenaiHealthRisks {
  func getMinimalHealthRisks(_ factors: RisksFactors) -> HealthRisks
  func getMaximalHealthRisks(_ factors: RisksFactors) -> HealthRisks
  func getReferenceHealthRisks(_ factors: RisksFactors) -> HealthRisks
}

Summary of Implementation Steps

Create a RisksFactors object with the user’s details (age, blood pressure, cholesterol, anthropometric data, etc.).
Invoke computeHealthRisks() to generate HealthRisks (including vascular age, CVD risk, event risk, waist-to-height ratio, body fat percentage, and basal metabolic rate).
Display the resulting risk values and any derived body composition metrics within your application.
Optionally, retrieve minimal, maximal, or reference risk profiles for additional insights.

This comprehensive approach lets you integrate Shen.AI’s cardiovascular risk calculations and body composition estimates in a straightforward way.