oro-sdk 2.1.4-dev1.0

package/dist/sdk-revision/client.d.ts

@@ -0,0 +1,21 @@
+import { OroClient, Uuid, VaultIndex } from "..";
+import { Grant } from "../models";
+/**
+ * @name filterGrantsWithLockboxMetadata
+ * @description searches for the applied filters in the vault index
+ * @param oroClient
+ * @param filter: the metadata filter applied to each the lockboxes
+ * @param vaultIndex: the index to which the filter will be applied
+ * @param forceRefresh
+ * @returns the filtered grants
+ */
+export declare function filterGrantsWithLockboxMetadata(oroClient: OroClient, filter?: {
+    consultationId: Uuid;
+}, vaultIndex?: VaultIndex, forceRefresh?: boolean): Promise<Grant[]>;
+/** Finds all grants for the logged user
+ *  requests a list of unique consultation ids for each lockbox the user has access to
+ *  builds and sets the index of consultations
+ * @param oroClient
+ * @returns the constructed vaultIndex
+ */
+export declare function buildLegacyVaultIndex(oroClient: OroClient): Promise<VaultIndex>;

package/dist/sdk-revision/index.d.ts

@@ -0,0 +1 @@
+export * from './client';

package/dist/services/api.d.ts

@@ -0,0 +1,11 @@
+import type { AxiosRequestConfig } from 'axios';
+import { AuthRefreshFunc, Tokens } from '../models';
+import { AxiosService } from './axios';
+export declare class APIService extends AxiosService {
+    private tokenRefreshFailureCallback?;
+    private authRefreshFn?;
+    constructor(config?: AxiosRequestConfig, tokenRefreshFailureCallback?: ((err: Error) => void) | undefined);
+    setAuthRefreshFn(fn: AuthRefreshFunc): void;
+    setTokens(tokens: Tokens): void;
+    getTokens(): Tokens;
+}

package/dist/services/axios.d.ts

@@ -0,0 +1,14 @@
+import type { AxiosRequestConfig } from 'axios';
+import { AxiosInstance } from 'axios';
+export declare class AxiosService {
+    protected axios: AxiosInstance;
+    constructor(config?: AxiosRequestConfig);
+    protected apiRequest(config: AxiosRequestConfig, url: string, data?: any): Promise<any>;
+    protected apiRequestHeader(config: AxiosRequestConfig, url: string, headerToRetrieve?: string, data?: any): Promise<any>;
+    get<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    deleteRequest<T = any>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    post<T = any>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+    put<T = any>(url: string, data: any, config?: AxiosRequestConfig): Promise<T>;
+    patch<T = any>(url: string, data: any, config?: AxiosRequestConfig): Promise<T>;
+    head<T = any>(url: string, config?: AxiosRequestConfig, headerToRetrieve?: string, data?: any): Promise<T>;
+}

package/dist/services/consult.d.ts

@@ -0,0 +1,54 @@
+import { APIService } from './api';
+import { Uuid, Consult, ConsultRequest, MedicalStatus, ConsultTransmission, TransmissionStatus } from '../models';
+export declare class ConsultService {
+    private api;
+    private baseURL;
+    constructor(api: APIService, baseURL: string);
+    consultCreate(c: ConsultRequest): Promise<Consult>;
+    /**
+     * This function returns the number of consults using parameters
+     * @param uuidPractice the practice uuid
+     * @param uuidRequester the requester uuid
+     * @param statusesMedical an array containing MedicalStatus to include
+     * @param statusesExclude an array containing MedicalStatus to exclude
+     * @param shortId a shortId matcher (will match all consult with a shortId starting with this `shortId`)
+     * @param columnToSortTo the list of columns separated by commas, to sort to (in order of sorting)
+     * @param orderToSortTo the type of sorting to do ('asc' for ascending or 'desc' for descending)
+     * @param perPage the number of item to retrieve per "page"
+     * @param indexPage the actual index of the page to retrieve (0 based: 0 is the first items)
+     * @param filterAssignedDoctor the uuid of the doctor for which to filter with
+     * @param filterCurrentPractitioner the uuid of the current assistant assigned to filter with
+     * @param filterIsoLocality the of isoLocality to filter with
+     * @returns a number of consult
+     */
+    countConsults(uuidPractice?: Uuid, uuidRequester?: Uuid, statusesMedical?: MedicalStatus[], statusesExclude?: MedicalStatus[], shortId?: string, columnToSortTo?: string[], orderToSortTo?: string[], perPage?: number, indexPage?: number, filterAssignedDoctor?: string, filterCurrentPractitioner?: string, filterIsoLocality?: string[]): Promise<number>;
+    /**
+     * This function get consults using parameters
+     * @param uuidPractice the practice uuid
+     * @param uuidRequester the requester uuid
+     * @param statusesMedical an array containing MedicalStatus to include
+     * @param statusesExclude an array containing MedicalStatus to exclude
+     * @param shortId a shortId matcher (will match all consult with a shortId starting with this `shortId`)
+     * @param columnToSortTo the list of columns separated by commas, to sort to (in order of sorting)
+     * @param orderToSortTo the type of sorting to do ('asc' for ascending or 'desc' for descending)
+     * @param perPage the number of item to retrieve per "page"
+     * @param indexPage the actual index of the page to retrieve (0 based: 0 is the first items)
+     * @param filterAssignedDoctor the uuid of the doctor for which to filter with
+     * @param filterCurrentPractitioner the uuid of the current assistant assigned to filter with
+     * @param filterIsoLocality the of isoLocality to filter with
+     * @returns a list of consult
+     */
+    getConsults(uuidPractice?: Uuid, uuidRequester?: Uuid, statusesMedical?: MedicalStatus[], statusesExclude?: MedicalStatus[], shortId?: string, columnToSortTo?: string[], orderToSortTo?: string[], perPage?: number, indexPage?: number, filterAssignedDoctor?: string, filterCurrentPractitioner?: string, filterIsoLocality?: string[]): Promise<Consult[]>;
+    getConsultByUUID(uuidConsult: Uuid, uuidPractice?: Uuid): Promise<Consult>;
+    updateConsultByUUID(uuidConsult: Uuid, consult: {
+        statusMedical?: MedicalStatus;
+        uuidAssignedDoctor?: Uuid;
+        neverExpires?: boolean;
+    }, uuidPractice?: Uuid, uuidRequester?: Uuid): Promise<Consult>;
+    getConsultFaxStatuses(uuidConsult: string): Promise<ConsultTransmission[]>;
+    postConsultTransmission(uuidConsult: string, nameDriver?: string, addressOrPhoneToSendTo?: string, file?: File, nameReceiver?: string, txtTransmissionTitle?: string, txtTransmissionNotes?: string): Promise<ConsultTransmission>;
+    postConsultFax(uuidConsult: string, addressReceiver: string, file: File): Promise<ConsultTransmission>;
+    postConsultEmail(uuidConsult: string, file: File): Promise<ConsultTransmission>;
+    retryConsultFax(uuidConsult: string, transmissionId: string): Promise<ConsultTransmission>;
+    updateConsultTransmissionStatus(transmissionId: string, uuidConsult: string, newStatus: TransmissionStatus): Promise<ConsultTransmission>;
+}

package/dist/services/diagnosis.d.ts

@@ -0,0 +1,44 @@
+import { Drug, TreatmentPlan, TreatmentPlans, TreatmentPlansRequest, TreatmentPlansResponse, Uuid } from '..';
+import { Diagnosis, Treatment, DiagnosisRequest, TreatmentRequest, TreatmentAndDrugPrescriptionUpdateRequest } from '../models/diagnosis';
+import { APIService } from './api';
+export declare class DiagnosisService {
+    private api;
+    private baseURL;
+    constructor(api: APIService, baseURL: string);
+    getDiagnoses(): Promise<Diagnosis[]>;
+    /**
+     * Get a diagnosis by uuid that belongs to your practice
+     * @param uuidDiagnosis the uuid of the diagnosis
+     * @returns a diagnosis
+     */
+    getDiagnosisByUuid(uuidDiagnosis: Uuid): Promise<Diagnosis>;
+    createDiagnosis(diagnosis: DiagnosisRequest): Promise<Diagnosis>;
+    updateDiagnosis(uuid: string, diagnosis: DiagnosisRequest): Promise<Diagnosis>;
+    getTreatmentsFromDiagnosisUuid(diagnosisUuid: Uuid): Promise<Treatment[]>;
+    /**
+     * This function returns treatment plans associated to a consult
+     * @param uuidConsult the consult uuid to fetch
+     * @returns an array of TreatmentPlan
+     */
+    getTreatmentPlansFromConsultUuid(uuidConsult: Uuid): Promise<TreatmentPlan[]>;
+    /**
+     * creates a new treatment for the diagnosis specified
+     * @param diagnosisUuid uuid of the diagnosis that is linked to the treatment
+     * @param treatmentRequest the treatment to be inserted
+     */
+    createTreatment(diagnosisUuid: string, treatmentRequest: TreatmentRequest): Promise<Treatment>;
+    /**
+     * This function returns populated treatment plans associated to a consult
+     * @param uuidConsult the consult uuid to fetch
+     * @returns a TreatmentPlans object
+     */
+    getTreatmentPlansPopulatedFromConsultUuid(uuidConsult: Uuid): Promise<TreatmentPlans>;
+    postPlans(plans: TreatmentPlansRequest): Promise<TreatmentPlansResponse>;
+    updateTreatmentPlan(uuidPlan: string, uuidConsult: string, diagnosisRequest: DiagnosisRequest, plan: TreatmentAndDrugPrescriptionUpdateRequest): Promise<TreatmentPlan>;
+    acceptTreatmentPlan(uuidPlan: string, uuidConsult: string): Promise<TreatmentPlan>;
+    /**
+     * retrieves all the drugs of the specified practice
+     * @param uuidPractice
+     */
+    getAllDrugs(uuidPractice: string): Promise<Drug[] | undefined>;
+}

package/dist/services/external/clinia.d.ts

@@ -0,0 +1,82 @@
+export declare type FacetFilter = 'type:PHARMACY' | 'type:CLINIC';
+export interface CliniaResponse<T> {
+    facets: any;
+    meta: {
+        query: string;
+        page: number;
+        numPages: number;
+        perPage: number;
+        total: number;
+    };
+    records: T[];
+}
+export interface PlaceData {
+    id: string;
+    documentType: string;
+    type: string;
+    name: string;
+    address: AddressData;
+    geoPoint: GeoPointData;
+    distance: number;
+    onlineBookingUrl: string;
+    openingHours: Map<string, Array<IntervalData>>;
+    phones: Array<PhoneData>;
+    socials: Array<SocialData>;
+    note: string;
+    services: Array<string>;
+    owner: string;
+}
+export interface AddressData {
+    streetAddress: string;
+    suiteNumber: string;
+    postalCode: string;
+    neighborhood: string;
+    locality: string;
+    place: string;
+    region: string;
+    regionCode: string;
+    country: string;
+    countryCode: string;
+}
+export interface PhoneData {
+    number: string;
+    extension: string;
+    countryCode: string;
+    type: 'MAIN' | 'ALTERNATE' | 'RECEPTION' | 'FAX' | 'TEXT_TELEPHONE_TTY' | 'INFO' | 'OTHER';
+    isTollFree: boolean;
+}
+export interface IntervalData {
+    start: string;
+    end: string;
+}
+export interface GeoPointData {
+    lat: number;
+    lng: number;
+}
+export interface SocialData {
+    url: string;
+    type: string;
+}
+export declare class CliniaService {
+    private url;
+    private locale?;
+    private api;
+    constructor(url: string, apiKey: string, locale?: string | undefined);
+    placeSearch(searchOptions: {
+        locale?: string;
+        query?: string;
+        facetFilters?: FacetFilter[];
+        location?: string;
+        aroundLatLng?: string;
+        page?: number;
+    }): Promise<CliniaResponse<PlaceData>>;
+    placeMatch(searchOptions: {
+        locale?: string;
+        name?: string;
+        address?: string;
+        postalCode?: string;
+        place?: string;
+        region?: string;
+        country?: string;
+    }, type?: string): Promise<PlaceData[]>;
+}

package/dist/services/external/index.d.ts

@@ -0,0 +1 @@
+export * from './clinia';

package/dist/services/guard.d.ts

@@ -0,0 +1,92 @@
+import { APIService } from './api';
+import type { AxiosAuthRefreshRequestConfig } from 'axios-auth-refresh';
+import { AuthTokenRequest, AuthTokenResponse, AuthRecoverRequest, IdentityCreateRequest, IdentityUpdateRequest, IdentityResponse, QRCodeResponse, Uuid, WhoAmIResponse, Base64String, Tokens } from '../models';
+export interface GuardRequestConfig extends AxiosAuthRefreshRequestConfig {
+    useRefreshToken: boolean;
+}
+export declare class GuardService {
+    private api;
+    private baseURL;
+    private identityCache;
+    private whoAmICache;
+    constructor(api: APIService, baseURL: string);
+    /**
+     * Will replace access and refresh tokens with `tokens`
+     *
+     * Note:
+     * ```typescript
+     * setTokens({accessToken: undefined, refreshToken: 'aTokenValue'}) // will erase accessToken and set refreshToken with 'aTokenValue'
+     * setTokens({refreshToken: 'aTokenValue'}) // will keep actual value of accessToken and set refreshToken with 'aTokenValue'
+     *
+     * ```
+     * @param tokens
+     */
+    setTokens(tokens: Tokens): void;
+    /**
+     * Allow to retrieve an access token and a refresh token in order
+     * to do authenticated request afterward
+     *
+     * @param req The credentials required to get an access token
+     * @returns AuthTokenResponse
+     */
+    authToken(req: AuthTokenRequest): Promise<AuthTokenResponse>;
+    /**
+     * Get new access and refresh token
+     *
+     * @returns AuthTokenResponse
+     */
+    authRefresh(refreshToken?: string): Promise<AuthTokenResponse>;
+    /**
+     * Call guard to overwrite existing refresh token cookie
+     *
+     * @returns void
+     */
+    authLogout(): Promise<void>;
+    /**
+     * Call guard to attempt account recovery
+     *
+     * @param req The email address / practice of the account to recover
+     * @returns void
+     */
+    authRecover(req: AuthRecoverRequest): Promise<void>;
+    /**
+     * Allow to create a new identity. The identity will then need to be confirmed
+     * via an email link
+     *
+     * @param req the information about the new identity to create
+     * @returns IdentityResponse
+     */
+    identityCreate(req: IdentityCreateRequest): Promise<IdentityResponse>;
+    /**
+     * Retrieve an identity. Will return public fields only when requested
+     * without authentication
+     *
+     * @param identityID Unique id of the identity to retrieve
+     * @returns IdentityResponse
+     */
+    identityGet(identityID: Uuid): Promise<IdentityResponse>;
+    /**
+     * Get information about the current authenticated user
+     *
+     * @param refreshCache if true it will refresh the whoAmI cache (default: false)
+     * @returns WhoAmIResponse
+     */
+    whoAmI(refreshCache?: boolean): Promise<WhoAmIResponse>;
+    /**
+     * Update an existing identity
+     *
+     * @param identityID unique id of identity to update
+     * @param req update request
+     * @returns IdentityResponse
+     */
+    identityUpdate(identityID: Uuid, req: IdentityUpdateRequest): Promise<IdentityResponse>;
+    /**
+     * Return base64 data representing a QR code that the
+     * current identity need in order to use MFA
+     *
+     * @param identityID unique id of the identity
+     * @param password the identity password (already hashed and in base64)
+     * @returns QRCodeResponse
+     */
+    identityMFAQRCode(identityID: Uuid, password: Base64String): Promise<QRCodeResponse>;
+}

package/dist/services/index.d.ts

@@ -0,0 +1,10 @@
+export * from './axios';
+export * from './api';
+export * from './consult';
+export * from './diagnosis';
+export * from './guard';
+export * from './practice';
+export * from './teller';
+export * from './vault';
+export * from './workflow';
+export * from './external';

package/dist/services/practice.d.ts

@@ -0,0 +1,100 @@
+import * as OroToolbox from 'oro-toolbox';
+import { PracticeAccount, Uuid } from '../models';
+import { Assignment, PlanType, Practice, PracticeConfigs, PracticeConfigKind, PracticePayment, PracticePaymentIntent, PracticePlan, PracticePlanPrices, PracticeWorkflow, PracticeWorkflowWithTagSpecialty, Practitioner, PractitionerLicense, PractitionerPreference, PractitionerQuota, PractitionerRole, WorkflowType } from '../models/practice';
+import { APIService } from './api';
+export declare class PracticeService {
+    private toolbox;
+    private api;
+    private baseURL;
+    constructor(toolbox: typeof OroToolbox, api: APIService, 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
+     */
+    practiceGetFromURL(practiceURL: string, params?: {
+        hydratePracticeConfigs?: boolean;
+        accounts?: boolean;
+    }): Promise<Practice | undefined>;
+    practiceGetFromUuid(practiceUuid: Uuid, locale?: string, withAccounts?: boolean): Promise<Practice>;
+    /**
+     * This function retrieves all configs of a specific practice
+     * @param practiceUuid uuid of the practice
+     * @returns the practice configs
+     */
+    practiceConfigGetFromPracticeUuid(practiceUuid: Uuid): Promise<PracticeConfigs[]>;
+    /**
+     * This function retrieves a specific config of a practice
+     * @param practiceUuid uuid of the practice
+     * @param kind of the config
+     * @returns the practice config
+     */
+    practiceConfigGetByKindForPracticeUuid(practiceUuid: Uuid, kind: PracticeConfigKind): Promise<PracticeConfigs>;
+    /**
+     * 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
+     */
+    practiceConfigCreateForPracticeUuid(practiceUuid: Uuid, config: PracticeConfigs): Promise<PracticeConfigs>;
+    /**
+     * 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
+     */
+    practiceConfigUpdate(config: PracticeConfigs): Promise<PracticeConfigs>;
+    practiceGetAccounts(practiceUuid: Uuid): Promise<PracticeAccount[]>;
+    practiceGetAccount(practiceUuid: Uuid, accountUuid: Uuid): Promise<PracticeAccount>;
+    practiceGetWorkflows(practiceUuid: Uuid): Promise<PracticeWorkflow[]>;
+    practiceGetWorkflow(practiceUuid: Uuid, workflowType: WorkflowType): Promise<PracticeWorkflowWithTagSpecialty>;
+    practiceGetPlans(practiceUuid: Uuid, planType?: PlanType): Promise<PracticePlan[]>;
+    practiceGetPlan(practiceUuid: Uuid, planId: number): Promise<PracticePlan>;
+    practiceGetPlanPrices(practiceUuid: Uuid, planId: number): Promise<PracticePlanPrices>;
+    practiceGetPayments(practiceUuid: Uuid, planType?: PlanType): Promise<PracticePayment[]>;
+    practiceGetPayment(practiceUuid: Uuid, idStripeInvoiceOrPaymentIntent: string): Promise<PracticePayment>;
+    practiceGetPaymentForStripePaymentIntentWithID(practiceUuid: Uuid, stripePaymentIntentId: number): Promise<PracticePayment>;
+    practiceGetPaymentsIntents(practiceUuid: Uuid, planType?: PlanType): Promise<PracticePaymentIntent[]>;
+    /**
+     * This function return the user hased email to be use for creating payment intent
+     * @param email the email to hash
+     * @returns a hashed email
+     */
+    getPaymentIntentHashedEmail(email: string): string;
+    practiceCreatePaymentsIntent(practiceUuid: Uuid, planId: number, userEmail: string, isoLocality?: string, url_subdomain?: string, promotionCode?: string): Promise<PracticePaymentIntent>;
+    practiceGetPaymentsIntent(practiceUuid: Uuid, paymentIntentId: number): Promise<PracticePaymentIntent>;
+    practiceUpdatePaymentsIntent(practiceUuid: string, idPraticePaymentIntent: number, practicePaymentIntent: PracticePaymentIntent, userEmail: string, promotionCode?: string): Promise<PracticePaymentIntent>;
+    practiceGetPractitioners(practiceUuid: Uuid): Promise<Practitioner[]>;
+    practiceUpdatePractitioner(practiceUuid: Uuid, practitionerUuid: Uuid, requestBody: Practitioner): Promise<Practitioner>;
+    practiceGetPractitioner(practiceUuid: Uuid, practitionerUuid: Uuid): Promise<Practitioner>;
+    practiceGetPractitionerLicenses(practiceUuid: Uuid, practitionerUuid: Uuid): Promise<PractitionerLicense[]>;
+    practiceCreatePractitionerLicense(practiceUuid: Uuid, practitionerUuid: Uuid, requestBody: PractitionerLicense): Promise<PractitionerLicense>;
+    practiceUpdatePractitionerLicense(practiceUuid: Uuid, practitionerUuid: Uuid, licenseId: number, requestBody: PractitionerLicense): Promise<PractitionerLicense>;
+    practiceGetPractitionerLicense(practiceUuid: Uuid, practitionerUuid: Uuid, licenseId: number): Promise<PractitionerLicense>;
+    practiceGetPractitionerPreferences(practiceUuid: Uuid, practitionerUuid: Uuid): Promise<PractitionerPreference[]>;
+    practiceCreatePractitionerPreference(practiceUuid: Uuid, practitionerUuid: Uuid, requestBody: PractitionerPreference): Promise<PractitionerPreference>;
+    practiceUpdatePractitionerPreference(practiceUuid: Uuid, practitionerUuid: Uuid, preferenceId: number, requestBody: PractitionerPreference): Promise<PractitionerPreference>;
+    practiceGetPractitionerPreference(practiceUuid: Uuid, practitionerUuid: Uuid, preferenceId: number): Promise<PractitionerPreference>;
+    practiceGetPractitionerRoles(practiceUuid: Uuid, practitionerUuid: Uuid): Promise<PractitionerRole[]>;
+    practiceCreatePractitionerRole(practiceUuid: Uuid, practitionerUuid: Uuid, requestBody: PractitionerRole): Promise<PractitionerRole>;
+    practiceDeletePractitionerRoles(practiceUuid: Uuid, practitionerUuid: Uuid): Promise<PractitionerRole>;
+    practiceUpdatePractitionerRole(practiceUuid: Uuid, practitionerUuid: Uuid, roleId: number, requestBody: PractitionerRole): Promise<PractitionerRole>;
+    practiceGetPractitionerRole(practiceUuid: Uuid, practitionerUuid: Uuid, roleId: number): Promise<PractitionerRole>;
+    practiceDeletePractitionerRole(practiceUuid: Uuid, practitionerUuid: Uuid, roleId: number): Promise<PractitionerRole>;
+    /**
+     * 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
+     */
+    practiceGetPractitionerSignature(practiceUuid: Uuid, practitionerUuid: Uuid): Promise<Blob>;
+    practiceGetAssignments(practiceUuid: Uuid): Promise<Assignment[]>;
+    practiceCreateAssignment(practiceUuid: Uuid, requestBody: Assignment): Promise<Assignment>;
+    practiceUpdateAssignment(practiceUuid: Uuid, assignmentId: number, requestBody: Assignment): Promise<Assignment>;
+    practiceGetAssignment(practiceUuid: Uuid, assignmentId: number): Promise<Assignment>;
+    practiceGetQuotas(practiceUuid: Uuid): Promise<PractitionerQuota[]>;
+    practiceGetQuota(practiceUuid: Uuid, quotaId: number): Promise<PractitionerQuota>;
+}

package/dist/services/teller.d.ts

@@ -0,0 +1,9 @@
+import { APIService } from './api';
+import { Consult, DataCreateResponse, LockboxDataRequest, MedicalStatus, Uuid } from '../models';
+export declare class TellerService {
+    private api;
+    private baseURL;
+    constructor(api: APIService, baseURL: string);
+    lockboxDataStore(lockboxUuid: Uuid, req: LockboxDataRequest, lockboxOwnerUuid?: Uuid, previousDataUuid?: Uuid): Promise<DataCreateResponse>;
+    updateConsultByUUID(patientUuid: Uuid, uuidConsult: Uuid, statusMedical: MedicalStatus, neverExpires?: boolean): Promise<Consult>;
+}

package/dist/services/vault.d.ts

@@ -0,0 +1,54 @@
+import { APIService } from './api';
+import { DataCreateResponse, DataResponse, GrantedLockboxes, LockboxCreateResponse, LockboxDataRequest, LockboxGrantRequest, LockboxManifest, SharedSecretResponse, Uuid, EncryptedVaultIndex, IndexKey, EncryptedIndexEntry } from '../models';
+export declare class VaultService {
+    private api;
+    private baseURL;
+    constructor(api: APIService, baseURL: string);
+    lockboxCreate(lockboxMetadata?: Object): Promise<LockboxCreateResponse>;
+    lockboxMetadataAdd(lockboxUuid: Uuid, lockboxMetadata: Object, lockboxOwnerUuid?: Uuid): Promise<LockboxCreateResponse>;
+    lockboxSecretGet(lockboxUuid: Uuid, lockboxOwnerUuid?: Uuid): Promise<SharedSecretResponse>;
+    lockboxGrant(lockboxUuid: Uuid, req: LockboxGrantRequest, lockboxOwnerUuid?: Uuid): Promise<void>;
+    /**
+     * Get all lockboxes granted to user
+     * @param filter filter of lockbox metadata
+     * @returns decrypted lockboxes granted to user
+     */
+    grantsGet(): Promise<GrantedLockboxes>;
+    /**
+     * 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
+     */
+    lockboxDataStore(lockboxUuid: Uuid, req: LockboxDataRequest, lockboxOwnerUuid?: Uuid, previousDataUuid?: Uuid): Promise<DataCreateResponse>;
+    lockboxDataGet(lockboxUuid: Uuid, dataUuid: Uuid, lockboxOwnerUuid?: Uuid, stream?: boolean): Promise<DataResponse>;
+    lockboxManifestGet(lockboxUuid: Uuid, filter?: Object, lockboxOwnerUuid?: Uuid): Promise<LockboxManifest>;
+    lockboxMetadataGet(lockboxUuid: Uuid, fields: string[], groupby: string[], filter?: Object, lockboxOwnerUuid?: Uuid): Promise<any[]>;
+    /**
+     * 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
+     */
+    vaultIndexPut(entries: EncryptedVaultIndex, indexOwnerUuid?: Uuid): Promise<void>;
+    /**
+     * 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
+     */
+    vaultIndexSnapshotPut(entry: EncryptedIndexEntry): Promise<void>;
+    /**
+     * 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
+     */
+    vaultIndexGet(indexKeys: IndexKey[], identifiers?: string[], timestamp?: Date): Promise<EncryptedVaultIndex>;
+}

package/dist/services/workflow.d.ts

@@ -0,0 +1,21 @@
+import { WorkflowData } from '../models/workflow';
+import { APIService } from './api';
+export declare class WorkflowService {
+    private api;
+    private v1Url;
+    constructor(api: APIService, url: string);
+    /**
+     * This function returns all workflows
+     * @returns desired workflow
+     */
+    getWorkflows(): Promise<WorkflowData[]>;
+    /**
+     * 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
+     */
+    getWorkflow(id: string, locale?: string, createdAt?: string): Promise<WorkflowData>;
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "version": "2.1.4-dev1.0",
+  "main": "dist/index.js",
+  "typings": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "engines": {
+    "node": ">=10",
+    "npm": ">=6.14.13"
+  },
+  "scripts": {
+    "link:watch": "npm link && tsdx watch",
+    "start": "tsdx watch",
+    "build": "tsdx build",
+    "test": "tsdx test",
+    "lint": "tsdx lint",
+    "prepare": "tsdx build",
+    "size": "size-limit",
+    "analyze": "size-limit --why",
+    "package": "tsdx build && npm publish"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "tsdx lint"
+    }
+  },
+  "name": "oro-sdk",
+  "author": "Antoine Jaouën <antoine@orohealth.me>",
+  "module": "dist/oro-sdk.esm.js",
+  "size-limit": [
+    {
+      "path": "dist/oro-sdk.cjs.production.min.js",
+      "limit": "10 KB"
+    },
+    {
+      "path": "dist/oro-sdk.esm.js",
+      "limit": "10 KB"
+    }
+  ],
+  "devDependencies": {
+    "@size-limit/preset-small-lib": "^4.10.2",
+    "@types/jest": "^27.4.1",
+    "@types/uuid": "^8.3.0",
+    "husky": "^6.0.0",
+    "prettier": "^2.5.1",
+    "prettier-plugin-svelte": "^2.3.0",
+    "size-limit": "^4.10.2",
+    "tsdx": "^0.14.1",
+    "tslib": "^2.2.0",
+    "typescript": "^4.2.4"
+  },
+  "dependencies": {
+    "axios": "^0.21.4",
+    "axios-auth-refresh": "^3.2.1",
+    "form-data": "^4.0.0",
+    "formdata-node": "^4.3.1",
+    "idb-keyval": "^5.0.6",
+    "oro-toolbox": "0.0.6",
+    "uuid": "^8.3.2"
+  }
+}