oro-sdk 2.1.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 ORO Health Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,72 @@
+# oro-sdk
+
+ORO SDK package is intended to be run in browser only. It contains everything needed to interact with backend services, especially the vault.
+
+## Requirements
+
+-   npm 6.14.11
+
+> Powered by [tsdx](https://github.com/formium/tsdx)
+
+## Local development
+
+> If you cannot see Jest types try opening this folder in a seperate VSCode window.
+### Set up project
+
+```bash
+npm install
+```
+
+Then, it's possible to either build/watch component by using
+
+```bash
+npm start # watch
+npm build # build
+```
+
+### Linking the SDK locally:
+
+Ensure that you are running `node v14.17.0` and `npm v6.14.13`, you can use nvm to quickly install and use different versions of node via the commandline https://github.com/nvm-sh/nvm
+```
+❯ npm -v
+6.14.13
+
+❯ node -v
+v14.17.0
+```
+In **`oro-apis/sdk/js`**:
+
+Use [npm link](https://docs.npmjs.com/cli/v7/commands/npm-link)
+
+```bash
+npm install
+npm run link:watch
+```
+
+In **`oro-apps/web`**:
+
+```bash
+npm uninstall oro-sdk-ts
+npm link oro-sdk-ts
+```
+
+in `/web/src/services/oro-client.ts` set the correct module, at line 15 comment out the module definition and use the already written local definition, don't forget to change PATH_TO_oro-apis to what it is on your machine. When done it should look like this:
+
+```js
+const module = await import('PATH_TO_oro-apis/sdk/js/node_modules/oro-toolbox')
+//const module = await import('oro-toolbox')
+```
+
+Do the same for `/web/src/server.ts` uncomment line 94 and update the path to match your machine:
+
+```js
+sirv('PATH_TO_oro-apis/sdk/js/node_modules/oro-toolbox', { dev }),
+```
+
+You can then run the app locally:
+
+```bash
+npm run dev
+```
+
+> Caveat: There is some caveat using `npm link` please see [doc](https://docs.npmjs.com/cli/v7/commands/npm-link#caveat)

package/dist/client.d.ts

@@ -0,0 +1,464 @@
+import * as OroToolbox from 'oro-toolbox';
+import { Consult, ConsultRequest, DataCreateResponse, Document, DocumentType, Grant, IdentityResponse, LocalEncryptedData, LocalizedData, LockboxManifest, Meta, Metadata, MetadataCategory, PopulatedWorkflowData, Practice, RecoveryData, RegisterPatientOutput, TokenData, TosAndCpAcceptanceRequest, UserPreference, Uuid, VaultIndex, WorkflowData } from './models';
+import { ConsultService, DiagnosisService, GuardService, PracticeService, TellerService, VaultService, WorkflowService } from './services';
+export declare class OroClient {
+    private toolbox;
+    tellerClient: TellerService;
+    vaultClient: VaultService;
+    guardClient: GuardService;
+    practiceClient: PracticeService;
+    consultClient: ConsultService;
+    workflowClient: WorkflowService;
+    diagnosisClient: DiagnosisService;
+    private authenticationCallback?;
+    private rsa?;
+    private secrets;
+    private cachedMetadataGrants;
+    private cachedManifest;
+    private vaultIndex?;
+    constructor(toolbox: typeof OroToolbox, tellerClient: TellerService, vaultClient: VaultService, guardClient: GuardService, practiceClient: PracticeService, consultClient: ConsultService, workflowClient: WorkflowService, diagnosisClient: DiagnosisService, authenticationCallback?: ((err: Error) => void) | undefined);
+    /**
+     * clears the vaultIndex and cached metadata grants
+    */
+    cleanIndex(): Promise<void>;
+    /**
+     * Generates an RSA key pair and password payload (rsa private key encrypted with the password)
+     * Calls Guard to sign up with the email address, password, practice, legal and token data
+     *
+     * @param email
+     * @param password
+     * @param practice
+     * @param legal
+     * @param tokenData
+     * @returns
+     */
+    signUp(email: string, password: string, practice: Practice, tosAndCpAcceptance: TosAndCpAcceptanceRequest, tokenData?: TokenData, subscription?: boolean): Promise<IdentityResponse>;
+    /**
+     * Parse the given accessToken claims by calling guard whoami and update theidentity to set it's emailConfirmed flag
+     * @param accessToken
+     * @returns The identity related to confirmedEmail
+     */
+    confirmEmail(accessToken: string): Promise<IdentityResponse>;
+    /**
+     * Calls Guard to sign in with the email address, password and one time password (if MFA is enabled)
+     * Then recover's the rsa private key from the recovery payload
+     *
+     * @param practiceUuid
+     * @param email
+     * @param password
+     * @param otp
+     * @returns the user identity
+     */
+    signIn(practiceUuid: Uuid, email: string, password: string, otp?: string): Promise<IdentityResponse>;
+    /**
+     * Will attempt to recover an existing login session and set back
+     * the private key in scope
+     */
+    resumeSession(): Promise<void>;
+    /**
+     * This function let's you encrypt locally an Object
+     * @param value the Object to encrypt
+     * @returns a LocalEncryptedData Object
+     * @throws IncompleteAuthentication if rsa is not set
+     * @calls authenticationCallback if rsa is not set
+     */
+    localEncryptToJsonPayload(value: any): LocalEncryptedData;
+    /**
+     * This function let's you decrypt a LocalEncryptedData object
+     * @param value a LocalEncryptedData object
+     * @returns a decrypted Object
+     * @throws IncompleteAuthentication if rsa is not set
+     * @calls authenticationCallback if rsa is not set
+     */
+    localDecryptJsonPayload({ encryptedKey, encryptedData, }: LocalEncryptedData): any;
+    /**
+     * Effectively kills your "session"
+     */
+    signOut(): Promise<void>;
+    /**
+     * @name registerPatient
+     * @description The complete flow to register a patient
+     *
+     * Steps:
+     * 1. Create a consult (checks if payment has been done)
+     * 2. Creates a lockbox
+     * 3. Grants lockbox access to all practice personnel
+     * 4. Creates secure identification, medical, onboarding data
+     * 5. Generates and stores the rsa key pair and recovery payloads
+     *
+     * @param patientUuid
+     * @param consult
+     * @param workflow
+     * @param recoveryQA
+     * @returns
+     */
+    registerPatient(patientUuid: Uuid, consult: ConsultRequest, workflow: WorkflowData, recoveryQA?: {
+        recoverySecurityQuestions: string[];
+        recoverySecurityAnswers: string[];
+    }): Promise<RegisterPatientOutput>;
+    /**
+     * Builds the vault index for the logged user
+     *
+     * Steps:
+     * 1. Retrieves, decrypts and sets the lockbox IndexSnapshot
+     * 2. Retrieves, decrypts and adds all other index entries starting at the snapshot timestamp
+     * 3. Updates the IndexSnapshot if changed
+     * @deprecated
+     * @returns the latest vault index
+     */
+    buildVaultIndex(forceRefresh?: boolean): Promise<void>;
+    /**
+     * Setter for the vault index
+     * @param index
+     */
+    setVaultIndex(index: VaultIndex): void;
+    /**
+     * Fetches all grants, and consultations that exist in each lockbox
+     * Then updates the index for the current user with the lockbox consult relationship
+     */
+    forceUpdateIndexEntries(): Promise<void>;
+    /**
+     * Generates, encrypts and adds entries to vault index for a given index owner
+     *
+     * @param entries
+     * @param indexOwnerUuid
+     */
+    vaultIndexAdd(entries: VaultIndex, indexOwnerUuid?: Uuid): Promise<void>;
+    /**
+     * adds or updates the index snapshot for the logged user
+     * @param index
+     */
+    indexSnapshotAdd(index: VaultIndex): Promise<void>;
+    /**
+     * @name grantLockbox
+     * @description Grants a lockbox by retrieving the shared secret of the lockbox and encrypting it with the grantees public key
+     * @param granteeUuid
+     * @param lockboxUuid
+     * @param lockboxOwnerUuid the lockbox owner (ignored if lockbox is owned by self)
+     */
+    grantLockbox(granteeUuid: Uuid, lockboxUuid: Uuid, lockboxOwnerUuid?: Uuid): Promise<void>;
+    /**
+     * @name createMessageData
+     * @description Creates a Base64 encrypted Payload to send and store in the vault from a message string
+     * @param lockboxUuid
+     * @param message
+     * @param consultationId the consultation for which this message is sent
+     * @param lockboxOwnerUuid the lockbox owner (ignored if lockbox is owned by self)
+     * @param previousDataUuid if it's a revision of existing file, specify the previous data uuid
+     * @returns the data uuid
+     */
+    createMessageData(lockboxUuid: Uuid, message: string, consultationId: string, lockboxOwnerUuid?: Uuid, previousDataUuid?: Uuid): Promise<DataCreateResponse>;
+    /**
+     * @name createMessageAttachmentData
+     * @description Creates a Base64 encrypted Payload to send and store in the vault from a file
+     * @param lockboxUuid
+     * @param data the file stored
+     * @param consultationId the consultation for which this message is sent
+     * @param lockboxOwnerUuid the lockbox owner (ignored if lockbox is owned by self)
+     * @param previousDataUuid if it's a revision of existing file, specify the previous data uuid
+     * @returns the data uuid
+     */
+    createMessageAttachmentData(lockboxUuid: Uuid, data: File, consultationId: string, lockboxOwnerUuid?: Uuid, previousDataUuid?: Uuid): Promise<DataCreateResponse>;
+    /**
+     * @name createAttachmentData
+     * @description Creates a Base64 encrypted Payload to send and store in the vault from a file
+     * @param lockboxUuid
+     * @param data the file stored
+     * @param consultationId the consultation for which this message is sent
+     * @param category the category for the attachment data
+     * @param lockboxOwnerUuid the lockbox owner (ignored if lockbox is owned by self)
+     * @param previousDataUuid if it's a revision of existing file, specify the previous data uuid
+     * @returns the data uuid
+     */
+    createConsultationAttachmentData(lockboxUuid: Uuid, data: File, consultationId: string, documentType: DocumentType, lockboxOwnerUuid?: Uuid, previousDataUuid?: Uuid): Promise<DataCreateResponse>;
+    /**
+     * @name createJsonData
+     * @description Creates a Base64 encrypted Payload to send and store in the vault. With the data input as a JSON
+     * @param lockboxUuid
+     * @param data
+     * @param meta
+     * @param privateMeta the metadata that will be secured in the vault
+     * @param lockboxOwnerUuid the lockbox owner (ignored if lockbox is owned by self)
+     * @param previousDataUuid if it's a revision of existing data, specify the previous data uuid
+     * @returns the data uuid
+     */
+    createJsonData<T = Meta>(lockboxUuid: Uuid, data: any, meta?: T, privateMeta?: {
+        [val: string]: any;
+    }, lockboxOwnerUuid?: Uuid, previousDataUuid?: Uuid): Promise<DataCreateResponse>;
+    /**
+     * Get or upsert a data in lockbox
+     * @param lockboxUuid the lockbox uuid
+     * @param data the data to insert
+     * @param publicMetadata the public Metadata
+     * @param privateMetadata the private Metadata
+     * @param forceReplace set true when the insertion of data requires to replace the data when it exists already
+     * @returns the data uuid
+     */
+    getOrInsertJsonData<M = Metadata>(lockboxUuid: Uuid, data: any, publicMetadata: M, privateMetadata: Metadata, forceReplace?: boolean): Promise<Uuid>;
+    /**
+     * @name createBytesData
+     * @description Creates a Base64 encrypted Payload to send and store in the vault. With the data input as a Bytes
+     * @param lockboxUuid
+     * @param data
+     * @param meta
+     * @param privateMeta the metadata that will be secured in the vault
+     * @param lockboxOwnerUuid the lockbox owner (ignored if lockbox is owned by self)
+     * @param previousDataUuid if it's a revision of existing data, specify the previous data uuid
+     * @returns the data uuid
+     */
+    createBytesData<T = Meta>(lockboxUuid: Uuid, data: Uint8Array, meta: T, privateMeta: {
+        [val: string]: any;
+    }, lockboxOwnerUuid?: Uuid, previousDataUuid?: Uuid): Promise<DataCreateResponse>;
+    /**
+     * @name getJsonData
+     * @description Fetches and decrypts the lockbox data with the cached shared secret.
+     * Decrypts the data to a valid JSON object. If this is impossible, the call to the WASM binary will fail
+     *
+     * @type T is the generic type specifying the return type object of the function
+     * @param lockboxUuid
+     * @param dataUuid
+     * @param lockboxOwnerUuid the lockbox owner (ignored if lockbox is owned by self)
+     * @returns the data specified by the generic type <T>
+     */
+    getJsonData<T = any>(lockboxUuid: Uuid, dataUuid: Uuid, lockboxOwnerUuid?: Uuid): Promise<T>;
+    /**
+     * @description Fetches and decrypts the lockbox data with the cached shared secret.
+     * @param lockboxUuid
+     * @param dataUuid
+     * @param lockboxOwnerUuid the lockbox owner (ignored if lockbox is owned by self)
+     * @returns the bytes data
+     */
+    getBytesData(lockboxUuid: Uuid, dataUuid: Uuid, lockboxOwnerUuid?: Uuid): Promise<Uint8Array>;
+    /**
+     * @name getGrants
+     * @description Get all lockboxes granted to user with the applied filter
+     * @note this function returns cached grants and will not update unless the page is refreshed
+     * @todo some versions of lockboxes do not make use of lockbox metadata
+     *  in this case, all lockboxes need to be filtered one-by-one to find the correct one
+     *  Remove if this is no longer the case
+     * @param filter: the consultationId in which the grant exists
+     * @returns decrypted lockboxes granted to user
+     */
+    getGrants(filter?: {
+        consultationId: Uuid;
+    }, forceRefresh?: boolean): Promise<Grant[]>;
+    /**
+     * @name getCachedSecretCryptor
+     * @description Retrieves the cached lockbox secret or fetches the secret from vault, then creates the symmetric cryptor and stores it in memory
+     * @param lockboxUuid
+     * @param lockboxOwnerUuid the lockbox owner (ignored if lockbox is owned by self)
+     * @returns
+     */
+    getCachedSecretCryptor(lockboxUuid: string, lockboxOwnerUuid?: string): Promise<OroToolbox.CryptoChaCha>;
+    /**
+     * Retrieves the patient personal information associated to the `consultationId`
+     * The `consultationId` only helps to retrieve the patient lockboxes
+     * Note: it is possible to have several personal informations data
+     * @param consultationId The consultation Id
+     * @param category The personal MetadataCategory to fetch
+     * @param forceRefresh force data refresh (default to false)
+     * @returns the personal data
+     */
+    getPersonalInformationsFromConsultId(consultationId: Uuid, category: MetadataCategory.Personal | MetadataCategory.ChildPersonal | MetadataCategory.OtherPersonal, forceRefresh?: boolean): Promise<LocalizedData<PopulatedWorkflowData>[]>;
+    /**
+     * Retrieves the patient medical data associated to the `consultationId`
+     * The `consultationId` only helps to retrieve the patient lockboxes
+     * Note: it is possible to have several medical data
+     * @param consultationId The consultation Id
+     * @param forceRefresh force data refresh (default to false)
+     * @returns the medical data
+     */
+    getMedicalDataFromConsultId(consultationId: Uuid, forceRefresh?: boolean): Promise<LocalizedData<PopulatedWorkflowData>[]>;
+    private getMetaCategoryFromConsultId;
+    /**
+     * @description retrieves the personal information stored in the first owned lockbox
+     * @param userId The user Id
+     * @returns the personal data
+     */
+    getPersonalInformations(userId: Uuid): Promise<LocalizedData<PopulatedWorkflowData>>;
+    /**
+     * Retrieves the grant associated to a consultationId
+     * @note returns the first grant only
+     * @param consultationId The consultationId
+     * @returns the grant
+     */
+    getGrantFromConsultId(consultationId: Uuid): Promise<Grant | undefined>;
+    /**
+     * retrieves the identity associated to the `consultationId`
+     * @param consultationId The consultation Id
+     * @returns the identity
+     */
+    getIdentityFromConsultId(consultationId: Uuid): Promise<IdentityResponse | undefined>;
+    /**
+     * retrieves the lockbox manifest for a given lockbox and add's its private metadata
+     * @note the lockbox manifest will retrieved the cached manifest first unless force refresh is enabled
+     * @param lockboxUuid
+     * @param filter
+     * @param expandPrivateMetadata
+     * @param lockboxOwnerUuid
+     * @param forceRefresh
+     * @returns the lockbox manifest
+     */
+    getLockboxManifest(lockboxUuid: Uuid, filter: Metadata, expandPrivateMetadata: boolean, lockboxOwnerUuid?: Uuid, forceRefresh?: boolean): Promise<LockboxManifest>;
+    /**
+     * @description Create or update the personal information and store it in the first owned lockbox
+     * @param identity The identity to use
+     * @param data The personal data to store
+     * @param dataUuid (optional) The dataUuid to update
+     * @returns
+     */
+    createPersonalInformations(identity: IdentityResponse, data: PopulatedWorkflowData, dataUuid?: string): Promise<DataCreateResponse>;
+    /**
+     * Create or update user Preference
+     * @param identity
+     * @param preference
+     * @param dataUuid
+     * @returns
+     */
+    createUserPreference(identity: IdentityResponse, preference: UserPreference, dataUuid?: string): Promise<DataCreateResponse>;
+    /**
+     * retrieves the user preference from a grant
+     * @param grant The grant
+     * @returns the user preference
+     */
+    getDataFromGrant<T = any>(grant: Grant, filter: Metadata): Promise<LocalizedData<T>>;
+    /**
+     * retrieves the user preference from a consultation id
+     * @param consultationId The related consultationId
+     * @returns the user preference
+     */
+    getUserPreferenceFromConsultId(consultationId: string): Promise<LocalizedData<UserPreference>>;
+    /**
+     * retrieves the user preference stored in the first owned lockbox from identity
+     * @param identity The identity to use
+     * @returns the user preference
+     */
+    getUserPreference(identity: IdentityResponse): Promise<LocalizedData<UserPreference>>;
+    /**
+     * retrieves the user preference from a consultation id
+     * @param consultationId The related consultationId
+     * @returns the user preference
+     */
+    getRecoveryDataFromConsultId(consultationId: string): Promise<LocalizedData<RecoveryData>>;
+    /**
+     * retrieves the user preference stored in the first owned lockbox from identity
+     * @param identity The identity to use
+     * @returns the user preference
+     */
+    getRecoveryData(identity: IdentityResponse): Promise<LocalizedData<RecoveryData>>;
+    /**
+     * @name getAssignedConsultations
+     * @description finds all assigned or owned consultations for the logged user
+     * Steps:
+     *  - Retrieves all granted lockboxes given to the logged user
+     *  - for each lockbox, find all consultation ids
+     *  - for each consultation id, retrieve the consult information
+     *  @param practiceUuid the uuid of the practice to look consult into
+     * @returns the list of consults
+     */
+    getAssignedConsultations(practiceUuid: Uuid, forceRefresh?: boolean): Promise<Consult[]>;
+    /**
+     * Gets the past consultations of the patient as well as his relatives if any
+     * @param consultationId any consultation uuid from which we will fetch all the other consultations of the same patient as the owner of this consultation id
+     * @param practiceUuid
+     */
+    getPastConsultationsFromConsultId(consultationId: string, practiceUuid: string): Promise<Consult[] | undefined>;
+    /**
+     * @name getPatientConsultationData
+     * @description retrieves the consultation data
+     * @param consultationId
+     * @returns
+     */
+    getPatientConsultationData(consultationId: Uuid, forceRefresh?: boolean): Promise<PopulatedWorkflowData[]>;
+    /**
+     * This function returns the patient prescriptions
+     * @param consultationId
+     * @returns
+     */
+    getPatientPrescriptionsList(consultationId: Uuid): Promise<Document[]>;
+    /**
+     * This function returns the patient results
+     * @param consultationId
+     * @returns
+     */
+    getPatientResultsList(consultationId: Uuid): Promise<Document[]>;
+    /**
+     * returns the patient treatment plan options
+     * @param consultationId
+     * @returns Document[] corresponding to the patient treatment plan options
+     */
+    getPatientTreatmentPlans(consultationId: Uuid): Promise<Document[]>;
+    /**
+     * returns a specific patient treatment plan option
+     * @param consultationId
+     * @param treatmentPlanId
+     * @returns
+     */
+    getPatientTreatmentPlanByUuid(consultationId: Uuid, treatmentPlanId: Uuid): Promise<Document[]>;
+    /**
+     * @name getPatientDocumentsList
+     * @description applies the provided filter to the vault to only find those documents
+     * @param filters the applied filters (e.g. type of documents)
+     * @param expandPrivateMetadata whether or not, the private metadata needs to be retrieved
+     *  (more computationally expensive)
+     * @param consultationId
+     * @returns the filtered document list
+     */
+    getPatientDocumentsList(filters: Object, expandPrivateMetadata: boolean, consultationId: Uuid): Promise<Document[]>;
+    /****************************************************************************************************************
+     *                                                  RECOVERY                                                    *
+     ****************************************************************************************************************/
+    /**
+     * @name recoverPrivateKeyFromSecurityQuestions
+     * @description Recovers and sets the rsa private key from the answered security questions
+     * @param id
+     * @param recoverySecurityQuestions
+     * @param recoverySecurityAnswers
+     * @param threshold the number of answers needed to recover the key
+     */
+    recoverPrivateKeyFromSecurityQuestions(id: Uuid, recoverySecurityQuestions: string[], recoverySecurityAnswers: string[], threshold: number): Promise<void>;
+    /**
+     * @name recoverPrivateKeyFromPassword
+     * @description Recovers and sets the rsa private key from the password
+     * @param id
+     * @param password
+     */
+    recoverPrivateKeyFromPassword(id: Uuid, password: string): Promise<void>;
+    /**
+     * @name recoverPrivateKeyFromMasterKey
+     * @description Recovers and sets the rsa private key from the master key
+     * @param id
+     * @param masterKey
+     */
+    recoverPrivateKeyFromMasterKey(id: Uuid, masterKey: string): Promise<void>;
+    /**
+     * @description Generates and updates the security questions and answers payload using new recovery questions and answers
+     * Important: Since the security questions generate a payload for the private key, they will never be stored on the device as they must remain secret!!!
+     * @param id
+     * @param recoverySecurityQuestions
+     * @param recoverySecurityAnswers
+     * @param threshold the number of answers needed to rebuild the secret
+     */
+    updateSecurityQuestions(id: Uuid, recoverySecurityQuestions: string[], recoverySecurityAnswers: string[], threshold: number): Promise<IdentityResponse>;
+    /**
+     * @description Generates and stores the payload encrypted payload and updates the password itself (double hash)
+     * @important
+     *  the recovery payload uses a singly hashed password and the password stored is doubly hashed so
+     *  the stored password cannot derive the decryption key in the payload
+     * @note
+     *  the old password must be provided when not performing an account recovery
+     * @param id
+     * @param newPassword
+     * @param oldPassword
+     */
+    updatePassword(id: Uuid, newPassword: string, oldPassword?: string): Promise<IdentityResponse>;
+    /**
+     * @description Generates and stores the master key encrypted payload
+     * Important
+     *  Since the master key is used to generate a payload for the private key, it will never be stored on the device as it must remain secret!
+     * @param id
+     * @param masterKey
+     * @param lockboxUuid
+     */
+    updateMasterKey(id: Uuid, masterKey: string, lockboxUuid: Uuid): Promise<IdentityResponse>;
+}

package/dist/helpers/client.d.ts

@@ -0,0 +1,23 @@
+import { PopulatedWorkflowData, MetadataCategory, SelectedAnswersData } from '../models';
+import { PersonalInformations } from '../models/client';
+/**
+ * This function extract PersonalInformations from data input object coming from workflow
+ * @param data extracted from WorkflowData
+ * @returns PersonalInformations of a patient
+ */
+export declare function identificationToPersonalInformations(data: any, category: MetadataCategory.Personal | MetadataCategory.ChildPersonal | MetadataCategory.OtherPersonal): PersonalInformations;
+export declare function toActualObject(data: PopulatedWorkflowData): any;
+/**
+ * This function update a PopulatedWorkflowData with PersonalInformations
+ * @param infos the personal informations
+ * @param data  the PopulatedWorkflowData
+ * @returns an updated PopulatedWorkflowData
+ */
+export declare function updatePersonalIntoPopulatedWorkflowData(infos: PersonalInformations, data: PopulatedWorkflowData, category: MetadataCategory.Personal | MetadataCategory.ChildPersonal | MetadataCategory.OtherPersonal): any;
+/**
+ * This function extract an ISO 3166-1 alpha-2 country and subdivision code from data input object coming from workflow
+ * @param answers answers from the WorkflowData
+ * @returns an ISO 3166 alpha-2 code or undefined
+ */
+export declare function extractISOLocalityForConsult(answers?: SelectedAnswersData): string | undefined;
+export declare function sessionStorePrivateKeyName(id: string): string;

package/dist/helpers/index.d.ts

@@ -0,0 +1,4 @@
+export * from './client';
+export * from './workflow';
+export * from './patient-registration';
+export * from './vault-grants';

package/dist/helpers/patient-registration.d.ts

@@ -0,0 +1,16 @@
+import { OroClient, RegisterPatientOutput } from '..';
+import { ConsultRequest, MetadataCategory, Uuid, WorkflowData } from '../models';
+export declare function registerPatient(patientUuid: Uuid, consultRequest: ConsultRequest, workflow: WorkflowData, oroClient: OroClient, masterKey?: Uuid, recoveryQA?: {
+    recoverySecurityQuestions: string[];
+    recoverySecurityAnswers: string[];
+}): Promise<RegisterPatientOutput>;
+/**
+ * Extracts the workflow MetadataCategory for Personal, ChildPersonal and OtherPersonal
+ * then stores it in the vault
+ *
+ * @param workflow
+ * @param lockboxUuid
+ * @param category
+ * @returns The data uuid
+ */
+export declare function extractAndStorePersonalWorkflowData(workflow: WorkflowData, lockboxUuid: Uuid, consultationId: Uuid, category: MetadataCategory.Personal | MetadataCategory.ChildPersonal | MetadataCategory.OtherPersonal, oroClient: OroClient): Promise<Uuid | void>;

package/dist/helpers/vault-grants.d.ts

@@ -0,0 +1,20 @@
+import { CryptoRSA } from "oro-toolbox";
+import { EncryptedIndexEntry, Grant } from "..";
+/**
+ * Decrypts and returns the encrypted grants
+ * If something went wrong during decryption, that grant will be removed from the list
+ *
+ * @param encryptedGrants: an array of encrypted grants
+ * @param rsaKey: the rsa key used to decrypt the encrypted grants
+ * @returns an array of grants
+ */
+export declare function decryptGrants(encryptedGrants: Grant[], rsaKey: CryptoRSA): Grant[];
+/**
+ * Decrypts the encrypted consult lockboxes and returns their grants
+ * If something went wrong during decryption, that grant will be removed from the list
+ *
+ * @param encryptedConsultLockboxes: an array of encrypted entries
+ * @param rsaKey: the rsa key used to decrypt the encrypted entries
+ * @returns an array of grants
+ */
+export declare function decryptConsultLockboxGrants(encryptedConsultLockboxes: EncryptedIndexEntry[], rsaKey: CryptoRSA): Grant[];

package/dist/helpers/workflow.d.ts

@@ -0,0 +1,23 @@
+import { MetadataCategory, PopulatedWorkflowData, SelectedAnswerData, SelectedAnswersData, WorkflowData, WorkflowUploadedImage } from '../models';
+export declare function filterTriggeredAnsweredWithKind(workflowData: WorkflowData, kind: 'text' | 'date' | 'number' | 'images' | 'images-alias' | 'body-parts' | 'pharmacy-picker'): Promise<SelectedAnswerData[]>;
+/**
+ * Filters and Populates the `selectedAnswers` from the workflow by
+ * Cross-referencing the `MetaCategory` of the answer's respective question
+ * Populates the fields labels and values that are of radio, dropdown and checkbox types
+ *
+ * @param workflowData
+ * @param category
+ * @returns An array of record key, value pairs
+ */
+export declare function getWorkflowDataByCategory(workflowData: WorkflowData, category: MetadataCategory): Promise<PopulatedWorkflowData>;
+export declare function getImagesFromIndexDb(answer: SelectedAnswerData): Promise<WorkflowUploadedImage[]>;
+export declare function isTriggered(triggers: string[], answers: string[]): boolean;
+export declare function flattenSelectedAnswers(answers: SelectedAnswersData): string[];
+/**
+ * This function helps you to get a valid workflow selectedAnswers structure
+ * @param workflow the workflow data to use to initialize selectedAnswers
+ * @param useDefault use workflow default values or not (this is used to avoid having unset values to appear in summaries)
+ * @returns a valid selectedAnswers structure
+ */
+export declare function getInitialisedSelectedAnswers(workflow: WorkflowData, useDefault?: boolean): any[];
+export declare function fillWorkflowFromPopulatedWorkflow(workflow: WorkflowData, populatedWorkflow: PopulatedWorkflowData): any;

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { OroClient } from './client';
+import * as OroToolboxNamespace from 'oro-toolbox';
+export declare type OroToolbox = typeof OroToolboxNamespace;
+export declare let wasmPath: string;
+declare const init: (toolbox: OroToolbox, tellerBaseURL: string, vaultBaseURL: string, guardBaseURL: string, practiceBaseURL: string, consultBaseURL: string, workflowBaseURL: string, diagnosisBaseUrl: string, authenticationCallback?: ((err: Error) => void) | undefined) => OroClient;
+export { OroClient } from './client';
+export * from './models';
+export * from './helpers';
+export * from './services';
+export { OroToolboxNamespace };
+export default init;

package/dist/index.js

@@ -0,0 +1,8 @@
+
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./oro-sdk.cjs.production.min.js')
+} else {
+  module.exports = require('./oro-sdk.cjs.development.js')
+}