oro-sdk 2.1.4-dev1.0 → 2.2.1

package/dist/services/diagnosis.d.ts

@@ -1,44 +0,0 @@
-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/guard.d.ts

@@ -1,92 +0,0 @@
-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/practice.d.ts

@@ -1,100 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,54 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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/src/models/consult.ts

@@ -1,110 +0,0 @@
-export enum AssistantType {
-    MedicalSecretary = 'MedicalSecretary',
-    Nurse = 'Nurse',
-    Specialist = 'Specialist',
-    Administrative = 'Administrative',
-    Other = 'Other',
-}
-
-export interface ConsultAssignedAssistant {
-    id?: number ///optional for insertion
-    uuidConsult: string
-    uuidAssistant: string
-    type: AssistantType
-    tagSpecialty?: string
-    duuidCurrentTaskDescription?: string
-}
-
-export enum TransmissionKind {
-    Fax = 'Fax',
-    Email = 'Email',
-    SMS = 'SMS',
-    EncryptedEmail = 'EncryptedEmail',
-    Logs = 'Logs',
-    API = 'API',
-    Other = 'Other',
-}
-
-export enum TransmissionStatus {
-    Preparing = 'Preparing',
-    Sending = 'Sending',
-    Sent = 'Sent',
-    Retrying = 'Retrying',
-    Failed = 'Failed',
-    DriverError = 'DriverError',
-    TimedOut = 'TimedOut',
-    ReceiverNotExist = 'ReceiverNotExist',
-    ReceiverNotAnswering = 'ReceiverNotAnswering',
-    ReceiverIncompatible = 'ReceiverIncompatible',
-}
-
-export interface ConsultTransmission {
-    id: number
-    uuidConsult: string
-    kind: TransmissionKind
-    status: TransmissionStatus
-    nameDriverReceiver: string
-    addressReceiver: string
-    idDriverForTransmission: string
-    txtLastDriverMessage: string
-    numTry: number
-    numTryLeft: number
-    delay: number
-    tsFirstTry: string
-    tsLastStatusUpdate: string
-    keyWebhookSecret: string
-}
-
-export enum FeeStatus {
-    NoFee = 'NoFee',
-    Pending = 'Pending',
-    Paid = 'Paid',
-    Reimbursed = 'Reimbursed',
-    Cancelled = 'Cancelled',
-    Contested = 'Contested',
-}
-
-export enum MedicalStatus {
-    Creating = 'Creating',
-    New = 'New',
-    ToAnswer = 'ToAnswer',
-    Answered = 'Answered',
-    Closed = 'Closed',
-    Reopened = 'Reopened',
-    Archived = 'Archived',
-}
-
-export enum TaskStatus {
-    None = 'None',
-    ToDo = 'ToDo',
-    InProgress = 'InProgress',
-    Blocked = 'Blocked',
-    Done = 'Done',
-}
-
-export interface ConsultRequest {
-    uuidPractice: string
-    tagSpecialtyRequired: string
-    idStripeInvoiceOrPaymentIntent: string
-    isoLocalityRequired?: string
-    isoLanguageRequired: string
-}
-export interface Consult {
-    uuid: string
-    uuidPracticeAdmin: string
-    uuidPractice: string
-    tagSpecialtyRequired: string
-    isoLanguageRequired: string
-    idPracticePayment: number
-    statusFee?: FeeStatus
-    isoLocalityRequired: string
-    statusMedical?: MedicalStatus
-    uuidAssignedDoctor: string
-    uuidCurrentAssigned: string
-    statusTask?: TaskStatus
-    hasTransmissions?: boolean
-    assignedAssistant?: ConsultAssignedAssistant[]
-    shortId?: string
-    createdAt?: string
-    expiresAt?: string
-}

package/src/models/diagnosis.ts

@@ -1,141 +0,0 @@
-export enum DiagnosisType {
-    Generic = 'Generic',
-    Private = 'Private',
-    Instance = 'Instance',
-}
-
-export interface DiagnosisRequest {
-    uuid?: string
-    name: string
-    description: string
-    type: DiagnosisType
-    parentUuid?: string
-    language: string
-    tags?: string[]
-    urlMultimedia?: string
-}
-
-export interface Diagnosis extends DiagnosisRequest {
-    uuid: string
-    uuidPractice: string
-    uuidPractitioner?: string
-    createdAt: string
-}
-
-export interface TreatmentRequest {
-    uuid?: string
-    uuidDiagnosis?: string
-    name: string
-    description: string
-    urlMultimedia?: string
-}
-
-export interface Treatment extends TreatmentRequest {
-    uuid: string
-    uuidDiagnosis: string
-    createdAt: string
-}
-
-export enum DrugType {
-    Generic = 'Generic',
-    Instance = 'Instance',
-}
-
-export interface DrugRequest {
-    name: string // name of the drug
-    description: string // Description of the drug
-    type: DrugType // Entry type
-    language: string // drug locale
-    sideEffects: string // Side effects of the drug
-    imageUrl?: string // Image URL to the drug
-    parentUuid?: string // (optional) parent uuid of the drug. In case of DrugType.Instance
-    uuid?: string // uuid of the drug (will be used as parentUuid in case of creation of new drug)
-}
-
-export interface Drug extends DrugRequest {
-    uuid: string
-    uuidPractice: string
-    uuidPractitioner?: string
-    createdAt: string
-}
-
-export interface PrescriptionRequest {
-    uuid?: string
-    uuidTreatment?: string
-    uuidDrug?: string
-    quantity: string
-    sig: string
-    renewal: string
-}
-
-export interface Prescription extends PrescriptionRequest {
-    uuid: string
-    uuidTreatment: string
-    createdAt: string
-}
-
-export enum PlanStatus {
-    Pending = 'Pending',
-    Accepted = 'Accepted',
-    Rejected = 'Rejected',
-}
-
-export interface TreatmentPlan {
-    uuid: string
-    uuidConsult: string
-    uuidDiagnosis: string
-    uuidTreatment?: string
-    status: PlanStatus
-}
-
-export interface DrugPrescription {
-    prescription: Prescription
-    drug: Drug
-}
-
-export interface TreatmentAndDrugPrescription {
-    treatment?: Treatment
-    prescriptionsAndDrugs?: DrugPrescription[]
-    status: PlanStatus
-    uuidTreatmentPlan: string
-}
-export interface TreatmentPlans {
-    uuidConsult: string
-    diagnosis: Diagnosis
-    plans?: TreatmentAndDrugPrescription[]
-}
-
-export interface DrugPrescriptionRequest {
-    prescription: PrescriptionRequest
-    drug: DrugRequest
-}
-
-export interface TreatmentAndDrugPrescriptionRequest {
-    trackingId: string
-    treatment: TreatmentRequest
-    prescriptionsAndDrugs?: DrugPrescriptionRequest[]
-}
-
-export interface TreatmentPlansRequest {
-    uuidConsult: string
-    diagnosis: DiagnosisRequest
-    plans?: TreatmentAndDrugPrescriptionRequest[]
-}
-
-export interface TreatmentAndDrugPrescriptionUpdateRequest {
-    treatment: Treatment
-    prescriptionsAndDrugs?: DrugPrescriptionRequest[]
-}
-
-export interface TreatmentPlanUpdateRequest extends TreatmentPlansRequest {
-    uuidConsult: string
-    diagnosis: DiagnosisRequest
-    plan: TreatmentAndDrugPrescriptionUpdateRequest
-}
-
-export interface TreatmentPlansResponseEntry {
-    trackingId?: string // can be undefined if treatmentPlan does not contain a treatment
-    treatmentPlan: TreatmentPlan
-}
-
-export interface TreatmentPlansResponse extends Array<TreatmentPlansResponseEntry> {}