oro-sdk-apis 1.0.0

package/src/services/practice.ts

@@ -0,0 +1,430 @@
+import { Buffer } from 'buffer/'
+import { sha256 } from 'hash.js'
+import { PracticeAccount, Uuid } from '../models'
+import {
+    Assignment,
+    PlanType,
+    Practice,
+    PracticeConfigKind,
+    PracticeConfigs,
+    PracticePayment,
+    PracticePaymentIntent,
+    PracticePlan,
+    PracticePlanPrices,
+    PracticeWorkflow,
+    PracticeWorkflowWithTagSpecialty,
+    Practitioner,
+    PractitionerLicense,
+    PractitionerPreference,
+    PractitionerQuota,
+    PractitionerRole,
+    WorkflowType,
+} from '../models/practice'
+import { APIService } from './api'
+
+export class PracticeService {
+    constructor(private api: APIService, private baseURL: string) {}
+
+    /**
+     * This function get the practice from the URL of a practice
+     * It is the entry point of our web apps
+     * @param practiceURL URL of the practice to search
+     * @param hydratePracticeConfigs (optional) if set true it the Practice field configs will be set
+     * @param accounts (optional) if set true it the Practice field accounts will be set
+     * @returns the found practice or undefined
+     */
+    public practiceGetFromURL(
+        practiceURL: string,
+        params?: {
+            hydratePracticeConfigs?: boolean
+            accounts?: boolean
+        }
+    ): Promise<Practice | undefined> {
+        return this.api.get<Practice | undefined>(`${this.baseURL}/v1/practices`, {
+            params: {
+                url_practice: practiceURL,
+                ...params,
+            },
+        })
+    }
+
+    public practiceGetFromUuid(practiceUuid: Uuid, locale?: string, withAccounts?: boolean): Promise<Practice> {
+        return this.api.get<Practice>(`${this.baseURL}/v1/practices/${practiceUuid}`, {
+            params: { locale, accounts: withAccounts },
+        })
+    }
+
+    /// Practice Configs
+
+    /**
+     * This function retrieves all configs of a specific practice
+     * @param practiceUuid uuid of the practice
+     * @returns the practice configs
+     */
+    public practiceConfigGetFromPracticeUuid(practiceUuid: Uuid): Promise<PracticeConfigs[]> {
+        return this.api.get<PracticeConfigs[]>(`${this.baseURL}/v1/practices/${practiceUuid}/configs`)
+    }
+
+    /**
+     * This function retrieves a specific config of a practice
+     * @param practiceUuid uuid of the practice
+     * @param kind of the config
+     * @returns the practice config
+     */
+    public practiceConfigGetByKindForPracticeUuid(
+        practiceUuid: Uuid,
+        kind: PracticeConfigKind
+    ): Promise<PracticeConfigs> {
+        return this.api.get<PracticeConfigs>(`${this.baseURL}/v1/practices/${practiceUuid}/configs/${kind}`)
+    }
+
+    /**
+     * This function creates a config for a specific practice
+     * @param practiceUuid uuid of the practice
+     * @param config the config to add to the practice
+     * @returns the created practice config
+     */
+    public practiceConfigCreateForPracticeUuid(practiceUuid: Uuid, config: PracticeConfigs): Promise<PracticeConfigs> {
+        return this.api.post<PracticeConfigs>(`${this.baseURL}/v1/practices/${practiceUuid}/configs`, config)
+    }
+
+    /**
+     * This function updates a specific config of a practice
+     * @param practiceUuid uuid of the practice
+     * @param config the config to update
+     * @returns the practice config
+     */
+    public practiceConfigUpdate(config: PracticeConfigs): Promise<PracticeConfigs> {
+        return this.api.put<PracticeConfigs>(
+            `${this.baseURL}/v1/practices/${config.uuidPractice}/configs/${config.kind}`,
+            config
+        )
+    }
+
+    /// Accounts
+    public practiceGetAccounts(practiceUuid: Uuid): Promise<PracticeAccount[]> {
+        return this.api.get<PracticeAccount[]>(`${this.baseURL}/v1/practices/${practiceUuid}/accounts`)
+    }
+
+    public practiceGetAccount(practiceUuid: Uuid, accountUuid: Uuid): Promise<PracticeAccount> {
+        return this.api.get<PracticeAccount>(`${this.baseURL}/v1/practices/${practiceUuid}/accounts/${accountUuid}`)
+    }
+
+    /// Workflows
+    public practiceGetWorkflows(practiceUuid: Uuid): Promise<PracticeWorkflow[]> {
+        return this.api.get<PracticeWorkflow[]>(`${this.baseURL}/v1/practices/${practiceUuid}/workflows`)
+    }
+
+    public practiceGetWorkflow(
+        practiceUuid: Uuid,
+        workflowType: WorkflowType
+    ): Promise<PracticeWorkflowWithTagSpecialty> {
+        return this.api.get<PracticeWorkflowWithTagSpecialty>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/workflows/${workflowType}`
+        )
+    }
+
+    /// Plans
+    public practiceGetPlans(practiceUuid: Uuid, planType?: PlanType): Promise<PracticePlan[]> {
+        return this.api.get<PracticePlan[]>(`${this.baseURL}/v1/practices/${practiceUuid}/plans`, {
+            params: { kind: planType },
+        })
+    }
+
+    public practiceGetPlan(practiceUuid: Uuid, planId: number): Promise<PracticePlan> {
+        return this.api.get<PracticePlan>(`${this.baseURL}/v1/practices/${practiceUuid}/plans/${planId}`)
+    }
+
+    public practiceGetPlanPrices(practiceUuid: Uuid, planId: number): Promise<PracticePlanPrices> {
+        return this.api.get<PracticePlanPrices>(`${this.baseURL}/v1/practices/${practiceUuid}/plans/${planId}/prices`)
+    }
+
+    // Payments
+    public practiceGetPayments(practiceUuid: Uuid, planType?: PlanType): Promise<PracticePayment[]> {
+        return this.api.get<PracticePayment[]>(`${this.baseURL}/v1/practices/${practiceUuid}/payments`, {
+            params: { kind: planType },
+        })
+    }
+
+    public practiceGetPayment(practiceUuid: Uuid, idStripeInvoiceOrPaymentIntent: string): Promise<PracticePayment> {
+        return this.api.get<PracticePayment>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/payments/${idStripeInvoiceOrPaymentIntent}`
+        )
+    }
+
+    public practiceGetPaymentForStripePaymentIntentWithID(
+        practiceUuid: Uuid,
+        stripePaymentIntentId: number
+    ): Promise<PracticePayment> {
+        return this.api.get<PracticePayment>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/payments/${stripePaymentIntentId}`
+        )
+    }
+
+    // Payments Intent
+    public practiceGetPaymentsIntents(practiceUuid: Uuid, planType?: PlanType): Promise<PracticePaymentIntent[]> {
+        return this.api.get<PracticePaymentIntent[]>(`${this.baseURL}/v1/practices/${practiceUuid}/payments/intents`, {
+            params: { kind: planType },
+        })
+    }
+
+    /**
+     * This function return the user hased email to be use for creating payment intent
+     * @param email the email to hash
+     * @returns a hashed email
+     */
+    public getPaymentIntentHashedEmail(email: string): string {
+        return Buffer.from(sha256().update(email.toLowerCase()).digest('hex'), 'hex').toString('base64')
+    }
+
+    public practiceCreatePaymentsIntent(
+        practiceUuid: Uuid,
+        planId: number,
+        userEmail: string,
+        isoLocality?: string,
+        url_subdomain?: string,
+        promotionCode?: string
+    ): Promise<PracticePaymentIntent> {
+        return this.api.post<PracticePaymentIntent>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/payments/intents/`,
+            {
+                idPlan: planId,
+                hashUserEmail: userEmail ? this.getPaymentIntentHashedEmail(userEmail) : undefined,
+                isoLocality,
+            },
+            { params: { url_subdomain, promotionCode } }
+        )
+    }
+
+    public practiceGetPaymentsIntent(practiceUuid: Uuid, paymentIntentId: number): Promise<PracticePaymentIntent> {
+        return this.api.get<PracticePaymentIntent>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/payments/intents/${paymentIntentId}`
+        )
+    }
+
+    public practiceUpdatePaymentsIntent(
+        practiceUuid: string,
+        idPraticePaymentIntent: number,
+        practicePaymentIntent: PracticePaymentIntent,
+        userEmail: string,
+        promotionCode?: string
+    ) {
+        return this.api.put<PracticePaymentIntent>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/payments/intents/${idPraticePaymentIntent}`,
+            {
+                ...practicePaymentIntent,
+                hashUserEmail: userEmail ? this.getPaymentIntentHashedEmail(userEmail) : undefined,
+            },
+            { params: { promotionCode } }
+        )
+    }
+
+    // Practitioner
+    public practiceGetPractitioners(practiceUuid: Uuid): Promise<Practitioner[]> {
+        return this.api.get<Practitioner[]>(`${this.baseURL}/v1/practices/${practiceUuid}/practitioners`)
+    }
+
+    public practiceUpdatePractitioner(
+        practiceUuid: Uuid,
+        practitionerUuid: Uuid,
+        requestBody: Practitioner
+    ): Promise<Practitioner> {
+        return this.api.put<Practitioner>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/practitioners/${practitionerUuid}`,
+            requestBody
+        )
+    }
+
+    public practiceGetPractitioner(practiceUuid: Uuid, practitionerUuid: Uuid): Promise<Practitioner> {
+        return this.api.get<Practitioner>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/practitioners/${practitionerUuid}`
+        )
+    }
+
+    // Practitioner Licenses
+    public practiceGetPractitionerLicenses(practiceUuid: Uuid, practitionerUuid: Uuid): Promise<PractitionerLicense[]> {
+        return this.api.get<PractitionerLicense[]>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/practitioners/${practitionerUuid}/licenses`
+        )
+    }
+
+    public practiceCreatePractitionerLicense(
+        practiceUuid: Uuid,
+        practitionerUuid: Uuid,
+        requestBody: PractitionerLicense
+    ): Promise<PractitionerLicense> {
+        return this.api.post<PractitionerLicense>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/practitioners/${practitionerUuid}/licenses`,
+            requestBody
+        )
+    }
+
+    public practiceUpdatePractitionerLicense(
+        practiceUuid: Uuid,
+        practitionerUuid: Uuid,
+        licenseId: number,
+        requestBody: PractitionerLicense
+    ): Promise<PractitionerLicense> {
+        return this.api.put<PractitionerLicense>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/practitioners/${practitionerUuid}/licenses/${licenseId}`,
+            requestBody
+        )
+    }
+
+    public practiceGetPractitionerLicense(
+        practiceUuid: Uuid,
+        practitionerUuid: Uuid,
+        licenseId: number
+    ): Promise<PractitionerLicense> {
+        return this.api.get<PractitionerLicense>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/practitioners/${practitionerUuid}/licenses/${licenseId}`
+        )
+    }
+
+    // Practitioner Preferences
+    public practiceGetPractitionerPreferences(
+        practiceUuid: Uuid,
+        practitionerUuid: Uuid
+    ): Promise<PractitionerPreference[]> {
+        return this.api.get<PractitionerPreference[]>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/practitioners/${practitionerUuid}/preferences`
+        )
+    }
+
+    public practiceCreatePractitionerPreference(
+        practiceUuid: Uuid,
+        practitionerUuid: Uuid,
+        requestBody: PractitionerPreference
+    ): Promise<PractitionerPreference> {
+        return this.api.post<PractitionerPreference>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/practitioners/${practitionerUuid}/preferences`,
+            requestBody
+        )
+    }
+
+    public practiceUpdatePractitionerPreference(
+        practiceUuid: Uuid,
+        practitionerUuid: Uuid,
+        preferenceId: number,
+        requestBody: PractitionerPreference
+    ): Promise<PractitionerPreference> {
+        return this.api.put<PractitionerPreference>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/practitioners/${practitionerUuid}/preferences/${preferenceId}`,
+            requestBody
+        )
+    }
+
+    public practiceGetPractitionerPreference(
+        practiceUuid: Uuid,
+        practitionerUuid: Uuid,
+        preferenceId: number
+    ): Promise<PractitionerPreference> {
+        return this.api.get<PractitionerPreference>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/practitioners/${practitionerUuid}/preferences/${preferenceId}`
+        )
+    }
+
+    // Practitioner Roles
+    public practiceGetPractitionerRoles(practiceUuid: Uuid, practitionerUuid: Uuid): Promise<PractitionerRole[]> {
+        return this.api.get<PractitionerRole[]>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/practitioners/${practitionerUuid}/roles`
+        )
+    }
+
+    public practiceCreatePractitionerRole(
+        practiceUuid: Uuid,
+        practitionerUuid: Uuid,
+        requestBody: PractitionerRole
+    ): Promise<PractitionerRole> {
+        return this.api.post<PractitionerRole>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/practitioners/${practitionerUuid}/roles`,
+            requestBody
+        )
+    }
+
+    public practiceDeletePractitionerRoles(practiceUuid: Uuid, practitionerUuid: Uuid): Promise<PractitionerRole> {
+        return this.api.deleteRequest<PractitionerRole>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/practitioners/${practitionerUuid}/roles`
+        )
+    }
+
+    public practiceUpdatePractitionerRole(
+        practiceUuid: Uuid,
+        practitionerUuid: Uuid,
+        roleId: number,
+        requestBody: PractitionerRole
+    ): Promise<PractitionerRole> {
+        return this.api.put<PractitionerRole>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/practitioners/${practitionerUuid}/roles/${roleId}`,
+            requestBody
+        )
+    }
+
+    public practiceGetPractitionerRole(
+        practiceUuid: Uuid,
+        practitionerUuid: Uuid,
+        roleId: number
+    ): Promise<PractitionerRole> {
+        return this.api.get<PractitionerRole>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/practitioners/${practitionerUuid}/roles/${roleId}`
+        )
+    }
+
+    public practiceDeletePractitionerRole(
+        practiceUuid: Uuid,
+        practitionerUuid: Uuid,
+        roleId: number
+    ): Promise<PractitionerRole> {
+        return this.api.deleteRequest<PractitionerRole>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/practitioners/${practitionerUuid}/roles/${roleId}`
+        )
+    }
+
+    // Practitioner signature
+
+    /**
+     * This function returns the practitioner's signature as a Blob
+     * @param practiceUuid the practice uuid of the practitioner
+     * @param practitionerUuid the practitioner uuid
+     * @returns a blob representing the signature
+     */
+    public practiceGetPractitionerSignature(practiceUuid: Uuid, practitionerUuid: Uuid): Promise<Blob> {
+        return this.api.get<Blob>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/practitioners/${practitionerUuid}/signature`,
+            { responseType: 'blob' }
+        )
+    }
+
+    // Assignments
+    public practiceGetAssignments(practiceUuid: Uuid): Promise<Assignment[]> {
+        return this.api.get<Assignment[]>(`${this.baseURL}/v1/practices/${practiceUuid}/assignments`)
+    }
+
+    public practiceCreateAssignment(practiceUuid: Uuid, requestBody: Assignment): Promise<Assignment> {
+        return this.api.post<Assignment>(`${this.baseURL}/v1/practices/${practiceUuid}/assignments`, requestBody)
+    }
+
+    public practiceUpdateAssignment(
+        practiceUuid: Uuid,
+        assignmentId: number,
+        requestBody: Assignment
+    ): Promise<Assignment> {
+        return this.api.put<Assignment>(
+            `${this.baseURL}/v1/practices/${practiceUuid}/assignments/${assignmentId}`,
+            requestBody
+        )
+    }
+
+    public practiceGetAssignment(practiceUuid: Uuid, assignmentId: number): Promise<Assignment> {
+        return this.api.get<Assignment>(`${this.baseURL}/v1/practices/${practiceUuid}/assignments/${assignmentId}`)
+    }
+
+    // Quotas
+    public practiceGetQuotas(practiceUuid: Uuid): Promise<PractitionerQuota[]> {
+        return this.api.get<PractitionerQuota[]>(`${this.baseURL}/v1/practices/${practiceUuid}/quotas`)
+    }
+
+    public practiceGetQuota(practiceUuid: Uuid, quotaId: number): Promise<PractitionerQuota> {
+        return this.api.get<PractitionerQuota>(`${this.baseURL}/v1/practices/${practiceUuid}/quotas/${quotaId}`)
+    }
+}

package/src/services/teller.ts

@@ -0,0 +1,39 @@
+import { APIService } from './api'
+import { Consult, DataCreateResponse, LockboxDataRequest, MedicalStatus, Uuid } from '../models'
+export class TellerService {
+    constructor(private api: APIService, private baseURL: string) { }
+
+    public async lockboxDataStore(
+        lockboxUuid: Uuid,
+        req: LockboxDataRequest,
+        lockboxOwnerUuid?: Uuid,
+        previousDataUuid?: Uuid
+    ): Promise<DataCreateResponse> {
+        return this.api.post<DataCreateResponse>(
+            `${this.baseURL}/v1/lockboxes/${lockboxUuid}/data`,
+            req,
+            {
+                params: {
+                    lockbox_owner_uuid: lockboxOwnerUuid,
+                    data_uuid: previousDataUuid,
+                },
+            }
+        )
+    }
+
+    public updateConsultByUUID(
+        patientUuid: Uuid,
+        uuidConsult: Uuid,
+        statusMedical: MedicalStatus,
+        neverExpires?: boolean,
+    ): Promise<Consult> {
+        return this.api.put<Consult>(
+            `${this.baseURL}/v1/consults/${uuidConsult}`,
+            {
+                patientUuid,
+                statusMedical,
+                neverExpires,
+            },
+        )
+    }
+}

package/src/services/vault.ts

@@ -0,0 +1,178 @@
+import { APIService } from './api'
+import {
+    DataCreateResponse,
+    DataResponse,
+    GrantedLockboxes,
+    LockboxCreateResponse,
+    LockboxDataRequest,
+    LockboxGrantRequest,
+    LockboxManifest,
+    SharedSecretResponse,
+    Uuid,
+    EncryptedVaultIndex,
+    IndexKey,
+    EncryptedIndexEntry
+} from '../models'
+
+export class VaultService {
+    constructor(private api: APIService, private baseURL: string) { }
+
+    public async lockboxCreate(lockboxMetadata?: Object): Promise<LockboxCreateResponse> {
+        return this.api.post<LockboxCreateResponse>(
+            `${this.baseURL}/v1/lockbox`,
+            lockboxMetadata
+        )
+    }
+
+    public async lockboxMetadataAdd(
+        lockboxUuid: Uuid,
+        lockboxMetadata: Object,
+        lockboxOwnerUuid?: Uuid
+    ): Promise<LockboxCreateResponse> {
+        return this.api.put<LockboxCreateResponse>(
+            `${this.baseURL}/v1/lockbox/${lockboxUuid}`,
+            lockboxMetadata,
+            { params: { lockbox_owner_uuid: lockboxOwnerUuid } }
+        )
+    }
+
+    public async lockboxSecretGet(
+        lockboxUuid: Uuid,
+        lockboxOwnerUuid?: Uuid
+    ): Promise<SharedSecretResponse> {
+        return this.api.get<SharedSecretResponse>(
+            `${this.baseURL}/v1/lockboxes/${lockboxUuid}/secret`,
+            { params: { lockbox_owner_uuid: lockboxOwnerUuid } }
+        )
+    }
+
+    public async lockboxGrant(
+        lockboxUuid: Uuid,
+        req: LockboxGrantRequest,
+        lockboxOwnerUuid?: Uuid
+    ): Promise<void> {
+        return this.api.post<void>(
+            `${this.baseURL}/v1/lockboxes/${lockboxUuid}/grant`,
+            req,
+            { params: { lockbox_owner_uuid: lockboxOwnerUuid } }
+        )
+    }
+
+    /**
+     * Get all lockboxes granted to user
+     * @param filter filter of lockbox metadata
+     * @returns decrypted lockboxes granted to user
+     */
+    public async grantsGet(): Promise<GrantedLockboxes> {
+        return this.api.get<GrantedLockboxes>(`${this.baseURL}/v1/grants`)
+    }
+
+    /**
+     * This function create or update a data into the vault.
+     * @note At creation it is necessary to have all `req` filled
+     * @note When setting `previousDataUuid` you are updating the data. `req` metadata fields are optional.
+     * @param lockboxUuid The lockbox uuid the data will be stored in
+     * @param req The request (please see notes)
+     * @param lockboxOwnerUuid The uuid of the owner of the lockbox (@deprecated)
+     * @param previousDataUuid The data uuid of the data you want to update
+     * @returns 
+     */
+    public async lockboxDataStore(
+        lockboxUuid: Uuid,
+        req: LockboxDataRequest,
+        lockboxOwnerUuid?: Uuid,
+        previousDataUuid?: Uuid
+    ): Promise<DataCreateResponse> {
+        return this.api.post<DataCreateResponse>(
+            `${this.baseURL}/v1/lockboxes/${lockboxUuid}/data`,
+            req,
+            {
+                params: {
+                    lockbox_owner_uuid: lockboxOwnerUuid,
+                    data_uuid: previousDataUuid,
+                },
+            }
+        )
+    }
+
+    public async lockboxDataGet(
+        lockboxUuid: Uuid,
+        dataUuid: Uuid,
+        lockboxOwnerUuid?: Uuid,
+        stream: boolean = true
+    ): Promise<DataResponse> {
+        let data = await this.api.get(
+            `${this.baseURL}/v1/lockboxes/${lockboxUuid}/data/${dataUuid}`,
+            { params: { lockbox_owner_uuid: lockboxOwnerUuid, stream } }
+        )
+
+        // returned as stream, we need to put inside a DataResponse object
+        if (stream)
+            return { data }
+
+        return data
+    }
+
+    public async lockboxManifestGet(
+        lockboxUuid: Uuid,
+        filter?: Object,
+        lockboxOwnerUuid?: Uuid
+    ): Promise<LockboxManifest> {
+        return this.api.get(`${this.baseURL}/v1/lockboxes/${lockboxUuid}`, {
+            params: { lockbox_owner_uuid: lockboxOwnerUuid, filter },
+        })
+    }
+
+    public async lockboxMetadataGet(
+        lockboxUuid: Uuid,
+        fields: string[],
+        groupby: string[],
+        filter?: Object,
+        lockboxOwnerUuid?: Uuid
+    ): Promise<any[]> {
+        return this.api.get(`${this.baseURL}/v1/lockboxes/${lockboxUuid}/metadata`, {
+            params: { lockbox_owner_uuid: lockboxOwnerUuid, fields, groupby, filter },
+        })
+    }
+
+    /**
+     * inserts or updates encrypted index entries
+     * @note if the index data is being inserted for a user other than the requester, use `indexOwnerUuid`
+     * @note if a uuid for an entry is provided, the service will perform an update
+     * @param entries the encrypted index data
+     * @param indexOwnerUuid
+     */
+    public async vaultIndexPut(entries: EncryptedVaultIndex, indexOwnerUuid?: Uuid): Promise<void> {
+        return this.api.put(`${this.baseURL}/v1/index`,
+            entries,
+            {
+                params: {
+                    index_owner_uuid: indexOwnerUuid,
+                },
+            }
+        )
+    }
+
+    /**
+     * inserts or updates index snapshot for the provided index owner
+     * @note if the index data is being inserted for a user other than the requester, use `indexOwnerUuid`
+     * @param entry the encrypted index snapshot
+     */
+    public async vaultIndexSnapshotPut(entry: EncryptedIndexEntry): Promise<void> {
+        return this.api.put(`${this.baseURL}/v1/index-snapshot`, entry)
+    }
+
+    /**
+     * Retrieves the encrypted index from the vault for the requesting user
+     * @note index keys can be specified to narrow the scope of index being requested
+     * @param indexKeys accepted index fields determined by vault
+     * @param identifiers: an array of unique_hashes or consultation uuids used to identify an index entry
+     * @param timestamp the minimum timestamp that index entries were created
+     * @returns the encrypted index
+     */
+    public async vaultIndexGet(indexKeys: IndexKey[], identifiers?: string[], timestamp?: Date): Promise<EncryptedVaultIndex> {
+        return this.api.get<EncryptedVaultIndex>(`${this.baseURL}/v1/index`, {
+            params: { index_keys: indexKeys, identifiers, timestamp },
+        })
+    }
+}

package/src/services/workflow.ts

@@ -0,0 +1,36 @@
+import { WorkflowData } from '../models/workflow'
+import { APIService } from './api'
+
+export class WorkflowService {
+    private v1Url: string
+
+    constructor(private api: APIService, url: string) {
+        this.v1Url = `${url}/v1`
+    }
+
+    /**
+     * This function returns all workflows
+     * @returns desired workflow
+     */
+    public getWorkflows(): Promise<WorkflowData[]> {
+        return this.api.get<WorkflowData[]>(`${this.v1Url}/workflows`)
+    }
+
+    /**
+     * This function retrieves a workflow. If `locale` is not found, it will try to find 'en' version of it.
+     * By default, will return most recent workflow of a specific `id`. `createdAt` can be used to select older version.
+     * @param id The uuid of the workflow
+     * @param locale (optional) The desired locale of the workflow (default: 'en')
+     * @param createdAt (optional) The creation date of the workflow (also used for versionning)
+     * @returns desired workflow
+     */
+    public getWorkflow(
+        id: string,
+        locale?: string,
+        createdAt?: string
+    ): Promise<WorkflowData> {
+        return this.api.get<WorkflowData>(`${this.v1Url}/workflows/${id}`, {
+            params: { locale, createdAt },
+        })
+    }
+}