Integrating Health Indices

If you are using our embedded UX flow (the “Full UX flow” described here), the Health Indices are automatically integrated. You don’t need to do anything special to show or compute them— the user is guided to enter their risk factors and the results are displayed in the SDK’s UI.
The instructions below are only relevant if you want to compute health indices through the API—for example, if you are using the Health Indices completely standalone, independently of the video measurement.

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;
 
  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;
 
  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;
 
  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 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<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
 
  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
}

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 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.

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
}

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;
}

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.

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;

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.

Overview Customizable Health Indices