Integrating risks functionality

To provide Shen.AI information about user’s risks factors you should use the following structure:

class RisksFactors {
  final int? age;               // years
  final double? cholesterol;    // mg/dL
  final double? cholesterolHdl; // mg/dL
  final double? sbp;            // mmHg
  final bool? isSmoker;
  final bool? hypertensionTreatment;
  final bool? hasDiabetes;
  final double? bodyHeight; // centimeters
  final double? bodyWeight; // kilograms
  final Gender? gender;
  final String? country; // country name ISO code: https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2
  final Race? race;
}
 
enum Gender {
  MALE(0),
  FEMALE(1),
  OTHER(2);
}
 
enum Race {
  WHITE(0),
  AFRICAN_AMERICAN(1),
  OTHER(2);
}

interface RisksFactors {
  age?: number;            // years
  cholesterol?: number;    // mg/dL
  cholesterolHdl?: number; // mg/dL
  sbp?: number;            // mmHg
  isSmoker?: boolean;
  hypertensionTreatment?: boolean;
  hasDiabetes?: boolean;
  bodyHeight?: number; // centimeters
  bodyWeight?: number; // kilograms
  gender?: Gender;
  country?: string; // country name ISO code: https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2
  race?: Race;
}
 
const enum Gender {
  MALE = 0,
  FEMALE,
  OTHER,
}
 
const enum Race {
  WHITE = 0,
  AFRICAN_AMERICAN,
  OTHER,
}

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<Boolean> isSmoker;
  public Optional<Boolean> hypertensionTreatment;
  public Optional<Boolean> hasDiabetes;
  public Optional<Float> bodyHeight;  // centimeters
  public Optional<Float> bodyWeight;  // kilograms
  public Optional<Gender> gender;
  public String country; // country name ISO code: https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2
  public Optional<Race> race;
}
 
public enum Gender {
  MALE,
  FEMALE,
  OTHER
}
 
public enum Race {
  WHITE,
  AFRICAN_AMERICAN,
  OTHER
}

interface RisksFactors {
  age?: number;            // years
  cholesterol?: number;    // mg/dL
  cholesterolHdl?: number; // mg/dL
  sbp?: number;            // mmHg
  isSmoker?: boolean;
  hypertensionTreatment?: boolean;
  hasDiabetes?: boolean;
  bodyHeight?: number; // centimeters
  bodyWeight?: number; // kilograms
  gender?: Gender;
  country?: string; // country name ISO code: https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2
  race?: Race;
}
 
const enum Gender {
  MALE = 0,
  FEMALE,
  OTHER,
}
 
const enum Race {
  WHITE = 0,
  AFRICAN_AMERICAN,
  OTHER,
}

class RisksFactors : NSObject {
  var age: NSNumber?              // years
  var cholesterol: NSNumber?      // mg/dL
  var cholesterolHDL: NSNumber?   // mg/dL
  var sbp: NSNumber?              // mmHg
  var isSmoker: NSNumber?
  var hypertensionTreatment: NSNumber?
  var hasDiabetes: NSNumber?
  var bodyHeight: NSNumber?       // centimeters
  var bodyWeight: NSNumber?       // kilograms
  var gender: Gender?
  var country: String?  // country name ISO code: https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2
  var race: Race?
}
 
enum Gender {
  case male
  case female
  case other
}
 
enum Race {
  case white
  case africanAmerican
  case other
}

If some data is not provided, then risks which requires this data also won’t be computed.

To compute the risks you should use computeHealthRisks() function. It returns the following structure, with filled only these fields, that could be computed with provided data:

 
static HealthRisks computeHealthRisks(RisksFactors healthRisksFactors);
 
 
class HealthRisks {
  final HardAndFatalEventsRisks? hardAndFatalEventsRisks;
  final CVDiseasesRisks? cvDiseases;
  final int? vascularAge;
  final RisksFactorsScores? scores;
}

import {computeHealthRisks, RisksFactors} from 'react-native-shenai-sdk';
 
async function computeHealthRisks(factors: RisksFactors): Promise<HealthRisks>
 
interface HealthRisks {
  hardAndFatalEvents: HardAndFatalEventsRisks;
  cvDiseases: CVDiseasesRisks;
  vascularAge: number | null;
  scores: RisksFactorsScores;
}

 
public HealthRisks computeHealthRisks(RisksFactors factors);
 
 
public class HealthRisks {
  public HardAndFatalEventsRisks hardAndFatalEvents;
  public CVDiseasesRisks cvDiseases;
  public Optional<Integer> vascularAge;
  public RisksFactorsScores scores;
}

 
computeHealthRisks: (factors: RisksFactors) => HealthRisks;
 
 
interface HealthRisks {
  hardAndFatalEvents: HardAndFatalEventsRisks;
  cvDiseases: CVDiseasesRisks;
  vascularAge: number | null;
  scores: RisksFactorsScores;
}

class ShenaiHealthRisks {
  func computeHealthRisks(_ risksFactors: RisksFactors) -> HealthRisks
}
 
class HealthRisks {
  var hardAndFatalEvents: HardAndFatalEventsRisks
  var cvDiseases: CVDiseasesRisks
  var vascularAge: NSNumber?
  var scores: RisksFactorsScores
}

The substructures are defined as follows:

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

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

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

Because different metrics have different value ranges, dependent also on the risks factors, Shen.AI provides methods to get minimal, maximal and reference values for each risk.

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

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>

 
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(_ risksFactors: RisksFactors) -> HealthRisks
  func getMaximalHealthRisks(_ risksFactors: RisksFactors) -> HealthRisks
  func getReferenceHealthRisks(_ risksFactors: RisksFactors) -> HealthRisks
}

Cardiovascular health risks Changelog