@icure/api 5.3.4 → 5.3.6

package/icc-x-api/icc-receipt-x-api.ts

@@ -0,0 +1,105 @@
+import { IccReceiptApi } from '../icc-api'
+import { IccCryptoXApi } from './icc-crypto-x-api'
+import * as _ from 'lodash'
+import * as models from '../icc-api/model/models'
+import { IccDataOwnerXApi } from './icc-data-owner-x-api'
+import { AuthenticationProvider, NoAuthenticationProvider } from './auth/AuthenticationProvider'
+
+export class IccReceiptXApi extends IccReceiptApi {
+  dataOwnerApi: IccDataOwnerXApi
+
+  constructor(
+    host: string,
+    headers: { [key: string]: string },
+    private crypto: IccCryptoXApi,
+    dataOwnerApi: IccDataOwnerXApi,
+    authenticationProvider: AuthenticationProvider = new NoAuthenticationProvider(),
+    fetchImpl: (input: RequestInfo, init?: RequestInit) => Promise<Response> = typeof window !== 'undefined'
+      ? window.fetch
+      : typeof self !== 'undefined'
+      ? self.fetch
+      : fetch
+  ) {
+    super(host, headers, authenticationProvider, fetchImpl)
+    this.dataOwnerApi = dataOwnerApi
+  }
+
+  newInstance(user: models.User, r: any): Promise<models.Receipt> {
+    const receipt = new models.Receipt(
+      _.extend(
+        {
+          id: this.crypto.randomUuid(),
+          _type: 'org.taktik.icure.entities.Receipt',
+          created: new Date().getTime(),
+          modified: new Date().getTime(),
+          responsible: this.dataOwnerApi.getDataOwnerOf(user),
+          author: user.id,
+          codes: [],
+          tags: [],
+        },
+        r || {}
+      )
+    )
+
+    return this.initDelegationsAndEncryptionKeys(user, receipt)
+  }
+
+  initEncryptionKeys(user: models.User, rcpt: models.Receipt) {
+    const dataOwnerId = this.dataOwnerApi.getDataOwnerOf(user)
+
+    return this.crypto.initEncryptionKeys(rcpt, dataOwnerId).then((eks) => {
+      let promise = Promise.resolve(
+        _.extend(rcpt, {
+          encryptionKeys: eks.encryptionKeys,
+        })
+      )
+      ;(user.autoDelegations ? (user.autoDelegations.all || []).concat(user.autoDelegations.medicalInformation || []) : []).forEach(
+        (delegateId) =>
+          (promise = promise.then((receipt) =>
+            this.crypto.appendEncryptionKeys(receipt, dataOwnerId, delegateId, eks.secretId).then((extraEks) => {
+              return _.extend(extraEks.modifiedObject, {
+                encryptionKeys: extraEks.encryptionKeys,
+              })
+            })
+          ))
+      )
+      return promise
+    })
+  }
+
+  private initDelegationsAndEncryptionKeys(user: models.User, receipt: models.Receipt): Promise<models.Receipt> {
+    const dataOwnerId = this.dataOwnerApi.getDataOwnerOf(user)
+
+    return Promise.all([
+      this.crypto.initObjectDelegations(receipt, null, dataOwnerId, null),
+      this.crypto.initEncryptionKeys(receipt, dataOwnerId),
+    ]).then((initData) => {
+      const dels = initData[0]
+      const eks = initData[1]
+      _.extend(receipt, {
+        delegations: dels.delegations,
+        cryptedForeignKeys: dels.cryptedForeignKeys,
+        secretForeignKeys: dels.secretForeignKeys,
+        encryptionKeys: eks.encryptionKeys,
+      })
+
+      let promise = Promise.resolve(receipt)
+      ;(user.autoDelegations ? (user.autoDelegations.all || []).concat(user.autoDelegations.medicalInformation || []) : []).forEach(
+        (delegateId) =>
+          (promise = promise.then((receipt) =>
+            this.crypto.addDelegationsAndEncryptionKeys(null, receipt, dataOwnerId, delegateId, dels.secretId, eks.secretId).catch((e) => {
+              console.log(e)
+              return receipt
+            })
+          ))
+      )
+      return promise
+    })
+  }
+
+  logReceipt(user: models.User, docId: string, refs: Array<string>, blobType: string, blob: ArrayBuffer) {
+    return this.newInstance(user, { documentId: docId, references: refs })
+      .then((rcpt) => this.createReceipt(rcpt))
+      .then((rcpt) => (blob.byteLength != 0 ? this.setReceiptAttachment(rcpt.id!, blobType, '', <any>blob) : Promise.resolve(rcpt)))
+  }
+}

package/icc-x-api/icc-time-table-x-api.ts

@@ -0,0 +1,69 @@
+import * as i18n from './rsrc/contact.i18n'
+
+import * as _ from 'lodash'
+import { IccTimeTableApi } from '../icc-api'
+import { User } from '../icc-api/model/User'
+import { TimeTable } from '../icc-api/model/TimeTable'
+import { IccCryptoXApi } from './icc-crypto-x-api'
+import { IccDataOwnerXApi } from './icc-data-owner-x-api'
+import { AuthenticationProvider, NoAuthenticationProvider } from './auth/AuthenticationProvider'
+
+export class IccTimeTableXApi extends IccTimeTableApi {
+  i18n: any = i18n
+  crypto: IccCryptoXApi
+  dataOwnerApi: IccDataOwnerXApi
+
+  constructor(
+    host: string,
+    headers: { [key: string]: string },
+    crypto: IccCryptoXApi,
+    dataOwnerApi: IccDataOwnerXApi,
+    authenticationProvider: AuthenticationProvider = new NoAuthenticationProvider(),
+    fetchImpl: (input: RequestInfo, init?: RequestInit) => Promise<Response> = typeof window !== 'undefined'
+      ? window.fetch
+      : typeof self !== 'undefined'
+      ? self.fetch
+      : fetch
+  ) {
+    super(host, headers, authenticationProvider, fetchImpl)
+    this.crypto = crypto
+    this.dataOwnerApi = dataOwnerApi
+  }
+
+  newInstance(user: User, tt: TimeTable) {
+    const timeTable = _.extend(
+      {
+        id: this.crypto.randomUuid(),
+        _type: 'org.taktik.icure.entities.TimeTable',
+        created: new Date().getTime(),
+        modified: new Date().getTime(),
+        responsible: this.dataOwnerApi.getDataOwnerOf(user),
+        author: user.id,
+        codes: [],
+        tags: [],
+      },
+      tt || {}
+    )
+
+    return this.crypto.initObjectDelegations(timeTable, null, this.dataOwnerApi.getDataOwnerOf(user), null).then((initData) => {
+      _.extend(timeTable, { delegations: initData.delegations })
+
+      let promise = Promise.resolve(timeTable)
+      ;(user.autoDelegations ? (user.autoDelegations.all || []).concat(user.autoDelegations.medicalInformation || []) : []).forEach(
+        (delegateId) =>
+          (promise = promise
+            .then((patient) =>
+              this.crypto.extendedDelegationsAndCryptedForeignKeys(
+                patient,
+                null,
+                this.dataOwnerApi.getDataOwnerOf(user),
+                delegateId,
+                initData.secretId
+              )
+            )
+            .then((extraData) => _.extend(timeTable, { delegations: extraData.delegations })))
+      )
+      return promise
+    })
+  }
+}

package/icc-x-api/icc-user-x-api.ts

@@ -0,0 +1,20 @@
+import { IccUserApi } from '../icc-api/api/IccUserApi'
+import { AuthenticationProvider, NoAuthenticationProvider } from './auth/AuthenticationProvider'
+
+export class IccUserXApi extends IccUserApi {
+  fetchImpl: (input: RequestInfo, init?: RequestInit) => Promise<Response>
+
+  constructor(
+    host: string,
+    headers: { [key: string]: string },
+    authenticationProvider: AuthenticationProvider = new NoAuthenticationProvider(),
+    fetchImpl: (input: RequestInfo, init?: RequestInit) => Promise<Response> = typeof window !== 'undefined'
+      ? window.fetch
+      : typeof self !== 'undefined'
+      ? self.fetch
+      : fetch
+  ) {
+    super(host, headers, authenticationProvider, fetchImpl)
+    this.fetchImpl = fetchImpl
+  }
+}

package/icc-x-api/index.ts

@@ -0,0 +1,227 @@
+import { IccAgendaApi, IccAuthApi, IccEntityrefApi, IccGroupApi, IccInsuranceApi, IccPatientApi, IccPermissionApi, OAuthThirdParty } from '../icc-api'
+import { IccUserXApi } from './icc-user-x-api'
+import { IccCryptoXApi } from './icc-crypto-x-api'
+import { IccContactXApi } from './icc-contact-x-api'
+import { IccInvoiceXApi } from './icc-invoice-x-api'
+import { IccDocumentXApi } from './icc-document-x-api'
+import { IccHcpartyXApi } from './icc-hcparty-x-api'
+import { IccFormXApi } from './icc-form-x-api'
+import { IccHelementXApi } from './icc-helement-x-api'
+import { IccClassificationXApi } from './icc-classification-x-api'
+import { IccCalendarItemXApi } from './icc-calendar-item-x-api'
+import { IccPatientXApi } from './icc-patient-x-api'
+import { IccMessageXApi } from './icc-message-x-api'
+import { IccReceiptXApi } from './icc-receipt-x-api'
+import { IccAccesslogXApi } from './icc-accesslog-x-api'
+import { IccTimeTableXApi } from './icc-time-table-x-api'
+import { IccDeviceApi } from '../icc-api'
+import { IccCodeXApi } from './icc-code-x-api'
+import { IccMaintenanceTaskXApi } from './icc-maintenance-task-x-api'
+import { IccDataOwnerXApi } from './icc-data-owner-x-api'
+import { retry } from './utils'
+import { StorageFacade } from './storage/StorageFacade'
+import { KeyStorageFacade } from './storage/KeyStorageFacade'
+import { LocalStorageImpl } from './storage/LocalStorageImpl'
+import { KeyStorageImpl } from './storage/KeyStorageImpl'
+import {
+  BasicAuthenticationProvider,
+  EnsembleAuthenticationProvider,
+  JwtAuthenticationProvider,
+  NoAuthenticationProvider,
+} from './auth/AuthenticationProvider'
+
+export * from './icc-accesslog-x-api'
+export * from './icc-bekmehr-x-api'
+export * from './icc-calendar-item-x-api'
+export * from './icc-classification-x-api'
+export * from './icc-code-x-api'
+export * from './icc-contact-x-api'
+export * from './icc-crypto-x-api'
+export * from './icc-doctemplate-x-api'
+export * from './icc-document-x-api'
+export * from './icc-form-x-api'
+export * from './icc-hcparty-x-api'
+export * from './icc-helement-x-api'
+export * from './icc-invoice-x-api'
+export * from './icc-message-x-api'
+export * from './icc-patient-x-api'
+export * from './icc-user-x-api'
+export * from './icc-time-table-x-api'
+export * from './icc-receipt-x-api'
+export * from './utils'
+export { KeyStorageFacade } from './storage/KeyStorageFacade'
+export { LocalStorageImpl } from './storage/LocalStorageImpl'
+export { StorageFacade } from './storage/StorageFacade'
+export { KeyStorageImpl } from './storage/KeyStorageImpl'
+
+export interface Apis {
+  authApi: IccAuthApi
+  codeApi: IccCodeXApi
+  entityReferenceApi: IccEntityrefApi
+  userApi: IccUserXApi
+  permissionApi: IccPermissionApi
+  healthcarePartyApi: IccHcpartyXApi
+  deviceApi: IccDeviceApi
+  cryptoApi: IccCryptoXApi
+  accessLogApi: IccAccesslogXApi
+  agendaApi: IccAgendaApi
+  contactApi: IccContactXApi
+  formApi: IccFormXApi
+  groupApi: IccGroupApi
+  invoiceApi: IccInvoiceXApi
+  insuranceApi: IccInsuranceApi
+  documentApi: IccDocumentXApi
+  healthcareElementApi: IccHelementXApi
+  classificationApi: IccClassificationXApi
+  calendarItemApi: IccCalendarItemXApi
+  receiptApi: IccReceiptXApi
+  timetableApi: IccTimeTableXApi
+  patientApi: IccPatientXApi
+  messageApi: IccMessageXApi
+  maintenanceTaskApi: IccMaintenanceTaskXApi
+  dataOwnerApi: IccDataOwnerXApi
+}
+
+export const Api = async function (
+  host: string,
+  username: string,
+  password: string,
+  crypto: Crypto = typeof window !== 'undefined' ? window.crypto : typeof self !== 'undefined' ? self.crypto : ({} as Crypto),
+  fetchImpl: (input: RequestInfo, init?: RequestInit) => Promise<Response> = typeof window !== 'undefined'
+    ? window.fetch
+    : typeof self !== 'undefined'
+    ? self.fetch
+    : fetch,
+  forceBasic = false,
+  autoLogin = true,
+  storage?: StorageFacade<string>,
+  keyStorage?: KeyStorageFacade,
+  headers = {},
+  icureTokens?: { token: string; refreshToken: string },
+  thirdPartyTokens: { [thirdParty: string]: string } = {}
+): Promise<Apis> {
+  const _storage = storage || new LocalStorageImpl()
+  const _keyStorage = keyStorage || new KeyStorageImpl(_storage)
+
+  // The AuthenticationProvider needs a AuthApi without authentication because it will only call methods without authentication
+  const authenticationProvider = forceBasic
+    ? new BasicAuthenticationProvider(username, password)
+    : icureTokens
+    ? new JwtAuthenticationProvider(new IccAuthApi(host, headers, new NoAuthenticationProvider(), fetchImpl), undefined, undefined, icureTokens)
+    : new EnsembleAuthenticationProvider(
+        new IccAuthApi(host, headers, new NoAuthenticationProvider(), fetchImpl),
+        username,
+        password,
+        3600,
+        thirdPartyTokens
+      )
+
+  // Here I instantiate a separate instance of the AuthApi that can call also login-protected methods (logout)
+  const authApi = new IccAuthApi(host, headers, authenticationProvider, fetchImpl)
+  const codeApi = new IccCodeXApi(host, headers, authenticationProvider, fetchImpl)
+  const entityReferenceApi = new IccEntityrefApi(host, headers, authenticationProvider, fetchImpl)
+  const userApi = new IccUserXApi(host, headers, authenticationProvider, fetchImpl)
+  const permissionApi = new IccPermissionApi(host, headers, authenticationProvider, fetchImpl)
+  const healthcarePartyApi = new IccHcpartyXApi(host, headers, authenticationProvider, fetchImpl)
+  const deviceApi = new IccDeviceApi(host, headers, authenticationProvider, fetchImpl)
+  const cryptoApi = new IccCryptoXApi(
+    host,
+    headers,
+    healthcarePartyApi,
+    new IccPatientApi(host, headers, authenticationProvider, fetchImpl),
+    deviceApi,
+    crypto,
+    _storage,
+    _keyStorage
+  )
+  const dataOwnerApi = new IccDataOwnerXApi(cryptoApi, new IccPatientApi(host, headers, authenticationProvider, fetchImpl))
+  const accessLogApi = new IccAccesslogXApi(host, headers, cryptoApi, dataOwnerApi, authenticationProvider, fetchImpl)
+  const agendaApi = new IccAgendaApi(host, headers, authenticationProvider, fetchImpl)
+  const contactApi = new IccContactXApi(host, headers, cryptoApi, dataOwnerApi, authenticationProvider, fetchImpl)
+  const formApi = new IccFormXApi(host, headers, cryptoApi, dataOwnerApi, authenticationProvider, fetchImpl)
+  const groupApi = new IccGroupApi(host, headers, authenticationProvider)
+  const invoiceApi = new IccInvoiceXApi(host, headers, cryptoApi, entityReferenceApi, dataOwnerApi, authenticationProvider, fetchImpl)
+  const insuranceApi = new IccInsuranceApi(host, headers, authenticationProvider, fetchImpl)
+  const documentApi = new IccDocumentXApi(host, headers, cryptoApi, authApi, dataOwnerApi, authenticationProvider, fetchImpl)
+  const healthcareElementApi = new IccHelementXApi(host, headers, cryptoApi, dataOwnerApi, ['descr', 'note'], authenticationProvider, fetchImpl)
+  const classificationApi = new IccClassificationXApi(host, headers, cryptoApi, dataOwnerApi, authenticationProvider, fetchImpl)
+  const calendarItemApi = new IccCalendarItemXApi(
+    host,
+    headers,
+    cryptoApi,
+    dataOwnerApi,
+    ['details', 'title', 'patientId'],
+    authenticationProvider,
+    fetchImpl
+  )
+  const receiptApi = new IccReceiptXApi(host, headers, cryptoApi, dataOwnerApi, authenticationProvider, fetchImpl)
+  const timetableApi = new IccTimeTableXApi(host, headers, cryptoApi, dataOwnerApi, authenticationProvider, fetchImpl)
+  const patientApi = new IccPatientXApi(
+    host,
+    headers,
+    cryptoApi,
+    contactApi,
+    formApi,
+    healthcareElementApi,
+    invoiceApi,
+    documentApi,
+    healthcarePartyApi,
+    classificationApi,
+    dataOwnerApi,
+    calendarItemApi,
+    ['note'],
+    authenticationProvider,
+    fetchImpl
+  )
+  const messageApi = new IccMessageXApi(host, headers, cryptoApi, dataOwnerApi, authenticationProvider, fetchImpl)
+  const maintenanceTaskApi = new IccMaintenanceTaskXApi(
+    host,
+    headers,
+    cryptoApi,
+    healthcarePartyApi,
+    dataOwnerApi,
+    ['properties'],
+    authenticationProvider,
+    fetchImpl
+  )
+
+  if (autoLogin) {
+    if (username != undefined && password != undefined) {
+      try {
+        await retry(() => authApi.login({ username, password }), 3, 1000, 1.5)
+      } catch (e) {
+        console.error('Incorrect user and password used to instantiate Api, or network problem', e)
+      }
+    }
+  } else {
+    console.info('Auto login skipped')
+  }
+
+  return {
+    cryptoApi,
+    authApi,
+    codeApi,
+    userApi,
+    permissionApi,
+    patientApi,
+    healthcarePartyApi,
+    deviceApi,
+    accessLogApi,
+    contactApi,
+    healthcareElementApi,
+    documentApi,
+    formApi,
+    invoiceApi,
+    insuranceApi,
+    messageApi,
+    entityReferenceApi,
+    receiptApi,
+    agendaApi,
+    calendarItemApi,
+    classificationApi,
+    timetableApi,
+    groupApi,
+    maintenanceTaskApi,
+    dataOwnerApi,
+  }
+}

package/icc-x-api/rsrc/codelng.ts

@@ -0,0 +1,8 @@
+export default {
+  'BE-THESAURUS': ['fr', 'nl'],
+  'CD-ATC': ['fr', 'nl'],
+  'CD-DRUG-CNK': ['fr', 'nl'],
+  'CD-INNCLUSTER': ['fr', 'nl'],
+  ICPC: ['fr', 'nl'],
+  ICD: ['fr', 'nl'],
+}

package/icc-x-api/rsrc/contact.i18n.ts

@@ -0,0 +1,110 @@
+export default {
+  fr: {
+    package: 'boîte',
+    packages: 'boîtes',
+    packageOf: 'boîte de',
+    packagesOf: 'boîtes de',
+    during: 'pendant',
+    take_s_: 'prise(s)',
+    weekly: '/semaine',
+    monthly: '/mois',
+    daily: '/jour',
+    the: 'le',
+    onDay: 'le jour',
+    on: 'le',
+    afterwakingup: 'Au lever',
+    afterbreakfast: 'Après ptit déj.',
+    afterdinner: 'Après rep. soir',
+    afterlunch: 'Après rep. midi',
+    afternoon: 'Après-midi',
+    beforebreakfast: 'Avant ptit déj.',
+    beforedinner: 'Avant rep. soir',
+    beforelunch: 'Avant rep. midi',
+    duringbreakfast: 'Pdt ptit déj.',
+    duringdinner: 'Pdt rep. soir',
+    duringlunch: 'Pdt rep. midi',
+    betweenbreakfastandlunch: 'Entre ptit déj et rep. midi',
+    betweenlunchanddinner: 'Entre rep. midi et rep. soir',
+    betweendinnerandsleep: 'Entre rep. soir et couch.',
+    evening: 'Soir',
+    knownuse: 'Usage connu',
+    morning: 'Matin',
+    night: 'Avt couch.',
+    midday: 'Midi',
+    noon: 'Midi',
+    at: 'à',
+    thehourofsleep: 'Au coucher',
+  },
+  en: {
+    package: 'package',
+    packages: 'packages',
+    packageOf: 'package of',
+    packagesOf: 'packages of',
+    during: 'during',
+    take_s_: 'take(s)',
+    weekly: 'weekly',
+    monthly: 'monthly',
+    daily: 'daily',
+    the: 'the',
+    onDay: 'on day',
+    on: 'on',
+    afterwakingup: 'After Waking Up',
+    afterbreakfast: 'After Breakfast',
+    afterdinner: 'After Dinner',
+    afterlunch: 'After Lunch',
+    afternoon: 'Afternoon',
+    beforebreakfast: 'Before Breakfast',
+    beforedinner: 'Before Dinner',
+    beforelunch: 'Before Lunch',
+    duringbreakfast: 'During Breakfast',
+    duringdinner: 'During Dinner',
+    duringlunch: 'During Lunch',
+    betweenbreakfastandlunch: 'Between Breakfast and Lunch',
+    betweenlunchanddinner: 'Between Lunch and Dinner',
+    betweendinnerandsleep: 'Between Dinner and Sleep',
+    evening: 'Evening',
+    knownuse: 'Known Usage',
+    morning: 'Morning',
+    night: 'Night',
+    midday: 'Midday',
+    noon: 'Noon',
+    at: 'at',
+    thehourofsleep: 'At Bedtime',
+  },
+  nl: {
+    package: 'verpakking',
+    packages: 'verpakkingen',
+    packageOf: 'verpakking van',
+    packagesOf: 'verpakkingen van',
+    during: 'gedurende',
+    take_s_: 'inname(s)',
+    weekly: 'wekelijks',
+    monthly: 'maandelijks',
+    daily: 'dagelijks',
+    the: 'de',
+    onDay: 'op dag',
+    on: 'op',
+    afterwakingup: 'Bij het opstaan',
+    afterbreakfast: 'Na ontbijt',
+    afterdinner: 'Na avondeten',
+    afterlunch: 'Na middageten',
+    afternoon: 'Namiddag',
+    beforebreakfast: 'Voor ontbijt',
+    beforedinner: 'Voor avondeten',
+    beforelunch: 'Voor middageten',
+    duringbreakfast: 'Tijdens ontbijt',
+    duringdinner: 'Tijdens avondeten',
+    duringlunch: 'Tijdens middageten',
+    betweenbreakfastandlunch: 'Tussen ontbijt en middageten',
+    betweenlunchanddinner: 'Tussen middag- en avondeten',
+    betweendinnerandsleep: 'Tussen avondmaal en slapeneten',
+    evening: 'Avond',
+    knownuse: 'Gekend gebruik',
+    morning: "'s Morgens",
+    night: 'Vóór slapengaan',
+    midday: 'Middag',
+    noon: 'Middag',
+    at: 'om',
+    thehourofsleep: 'Voor het slapen',
+  },
+}

package/icc-x-api/rsrc/icd10.ts

@@ -0,0 +1,113 @@
+export default {
+  'A00-B99': {
+    en: 'Infectious and parasitic',
+    fr: 'Infections & parasites',
+    colour: 'ICD-10--IV',
+  },
+  'C00-D48': {
+    en: 'Neoplasms',
+    fr: 'Tumeurs',
+    colour: 'ICD-10--IV',
+  },
+  'D49-D89': {
+    en: 'Blood & immunity',
+    fr: 'Sang & immunité',
+    colour: 'ICD-10--IV',
+  },
+  'E00-E99': {
+    en: 'Endocrine, nutritional & metabolic',
+    fr: 'Endocrino, nutrition et métabolisme',
+    colour: 'ICD-10--IV',
+  },
+  'F00-F99': {
+    en: 'Mental and behavioural disorders',
+    fr: 'Troubles mentaux et du comportement',
+    colour: 'ICD-10--V',
+  },
+  'G00-G99': {
+    en: 'Nervous system',
+    fr: 'Système nerveux',
+    colour: 'ICD-10--VI',
+  },
+  'H00-H59': {
+    en: 'Eye and adnexa',
+    fr: 'Œil et de ses annexes',
+    colour: 'ICD-10--VII',
+  },
+  'H60-H99': {
+    en: 'Ear and mastoid process',
+    fr: "Oreille et de l'apophyse mastoïde",
+    colour: 'ICD-10--VII',
+  },
+  'I00-I99': {
+    en: 'Circulatory system',
+    fr: 'Appareil circulatoire',
+    colour: 'ICD-10--VIII',
+  },
+  'J00-J99': {
+    en: 'Respiratory system',
+    fr: 'Appareil respiratoire',
+    colour: 'ICD-10--IX',
+  },
+  'K00-K99': {
+    en: 'Digestive system',
+    fr: 'Appareil digestif',
+    colour: 'ICD-10--X',
+  },
+  'L00-L99': {
+    en: 'Skin and subcutaneous tissue',
+    fr: 'Peau et Tissu cellulaire sous-cutané',
+    colour: 'ICD-10--XI',
+  },
+  'M00-M99': {
+    en: 'Musculoskeletal system and connective tissue',
+    fr: 'Système ostéo-articulaire, des muscles et du tissu conjonctif',
+    colour: 'ICD-10--XII',
+  },
+  'N00-N99': {
+    en: 'Genitourinary system',
+    fr: 'Appareil génito-urinaire',
+    colour: 'ICD-10--XIII',
+  },
+  'O00-O99': {
+    en: 'Pregnancy, childbirth and the puerperium',
+    fr: 'Grossesse, accouchement et puerpéralité',
+    colour: 'ICD-10--XIV',
+  },
+  'P00-P99': {
+    en: 'Perinatal period conditions',
+    fr: 'Affections périnatale',
+    colour: 'ICD-10--XV',
+  },
+  'Q00-Q99': {
+    en: 'Congenital malformations, deformations and chromosomal abnormalities',
+    fr: 'Malformations congénitales et anomalies chromosomiques',
+    colour: 'ICD-10--XVI',
+  },
+  'R00-R69': {
+    en: 'Symptoms and signs',
+    fr: 'Symptômes et signes',
+    colour: 'ICD-10--other',
+  },
+  'R70-R94': {
+    en: 'Abnormal clinical and laboratory findings',
+    fr: 'Examens cliniques et laboratoires anormaux',
+    colour: 'ICD-10--other',
+  },
+  'R95-R99': {
+    en: 'Ill-defined and unknown causes of mortality',
+    fr: 'Cause de décès mal-définie ou inconnue',
+    colour: 'ICD-10--other',
+  },
+  'S00-T99': {
+    en: 'Injuries & poisoning',
+    fr: 'Traumato & toxicologie',
+    colour: 'ICD-10--other',
+  },
+  'U00-Y99': { en: 'Unsorted', fr: 'Non-classé', colour: 'ICD-10--other' },
+  'Z00-Z99': {
+    en: 'General health status',
+    fr: 'Etat général',
+    colour: 'ICD-10--other',
+  },
+}

package/icc-x-api/rsrc/icpc2.ts

@@ -0,0 +1,22 @@
+export default {
+  A: { en: 'General and unspecified', colour: 'ICPC-2--A' },
+  B: {
+    en: 'Blood, blood forming organs, lymphatics, spleen',
+    colour: 'ICPC-2--B',
+  },
+  D: { en: 'Digestive', colour: 'ICPC-2--D' },
+  F: { en: 'Eye', colour: 'ICPC-2--F' },
+  H: { en: 'Ear', colour: 'ICPC-2--H' },
+  K: { en: 'Circulatory', colour: 'ICPC-2--K' },
+  L: { en: 'Musculoskeletal', colour: 'ICPC-2--L' },
+  N: { en: 'Neurological', colour: 'ICPC-2--N' },
+  P: { en: 'Psychological', colour: 'ICPC-2--P' },
+  R: { en: 'Respiratory', colour: 'ICPC-2--R' },
+  S: { en: 'Skin', colour: 'ICPC-2--S' },
+  T: { en: 'Endocrine, metabolic and nutritional', colour: 'ICPC-2--T' },
+  U: { en: 'Urology', colour: 'ICPC-2--U' },
+  W: { en: 'Pregnancy, childbirth, family planning', colour: 'ICPC-2--W' },
+  X: { en: 'Female genital system and breast', colour: 'ICPC-2--X' },
+  Y: { en: 'Male genital system', colour: 'ICPC-2--Y' },
+  Z: { en: 'Social problems', colour: 'ICPC-2--Z' },
+}