@metriport/api-sdk 0.0.343 → 0.30.0-alpha.1

package/dist/medical/client/metriport.js

@@ -0,0 +1,956 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MetriportMedicalApi = void 0;
+const medical_1 = require("@metriport/shared/medical");
+const axios_1 = __importDefault(require("axios"));
+const crypto_1 = __importDefault(require("crypto"));
+const http_status_1 = __importDefault(require("http-status"));
+const shared_1 = require("../../shared");
+const base_update_1 = require("../models/common/base-update");
+const document_1 = require("../models/document");
+const facility_1 = require("../models/facility");
+const network_query_1 = require("@metriport/shared/domain/network-query");
+const organization_1 = require("../models/organization");
+const patient_1 = require("../models/patient");
+const NO_DATA_MESSAGE = "No data returned from API";
+const BASE_PATH = "/medical/v1";
+const ORGANIZATION_URL = `/organization`;
+const FACILITY_URL = `/facility`;
+const COHORT_URL = `/cohort`;
+const NETWORK_ENTRY_URL = `/network-entry`;
+const NETWORK_QUERY_URL = `/network/query`;
+const PATIENT_URL = `/patient`;
+const DOCUMENT_URL = `/document`;
+const TOKEN_URL = `/token`;
+const REQUEST_ID_HEADER_NAME = "x-metriport-request-id";
+class MetriportMedicalApi {
+    // TODO this should be private
+    api;
+    _lastRequestId;
+    optionsForSettingsEndpoints = {
+        baseURL: "/",
+    };
+    static headers = {
+        clientApp: "x-metriport-client",
+    };
+    /**
+     * Creates a new instance of the Metriport Medical API client.
+     *
+     * @param apiKey Your Metriport API key.
+     * @param options - Optional parameters
+     * @param options.additionalHeaders - HTTP headers to be used in all requests.
+     * @param options.axios - Axios instance, default, useful when the dependency is not being imported
+     *          properly by NPM.
+     * @param options.sandbox - Indicates whether to connect to the sandbox, default false.
+     * @param options.timeout - Connection timeout in milliseconds, default 20 seconds.
+     */
+    constructor(apiKey, options = {}) {
+        const { sandbox, timeout } = options;
+        const mode = options.mode || "api-key";
+        const headers = {
+            ...(mode === "api-key" ? { [shared_1.API_KEY_HEADER]: apiKey } : { [shared_1.JWT_HEADER]: "Bearer " + apiKey }),
+            ...options.additionalHeaders,
+        };
+        const baseHostAndProtocol = options.baseAddress ?? (sandbox ? shared_1.BASE_ADDRESS_SANDBOX : shared_1.BASE_ADDRESS);
+        const baseURL = baseHostAndProtocol + BASE_PATH;
+        const axiosConfig = {
+            timeout: timeout ?? shared_1.DEFAULT_AXIOS_TIMEOUT_MILLIS,
+            baseURL,
+            headers,
+        };
+        this.optionsForSettingsEndpoints.baseURL = baseHostAndProtocol;
+        if (axios_1.default) {
+            this.api = axios_1.default.create(axiosConfig);
+        }
+        else if (options.axios) {
+            this.api = options.axios.create(axiosConfig);
+        }
+        else {
+            throw new Error(`Failed to initialize Axios`);
+        }
+    }
+    /**
+     * The ID from the last request made to the API.
+     */
+    get lastRequestId() {
+        return this._lastRequestId;
+    }
+    /**
+     * Gets the settings for your account.
+     *
+     * @returns Your account settings.
+     */
+    async getSettings() {
+        const resp = await this.api.get("/settings", {
+            ...this.optionsForSettingsEndpoints,
+        });
+        return resp.data;
+    }
+    /**
+     * Update the settings for your account.
+     *
+     * @returns Your updated account settings.
+     */
+    async updateSettings(webhookUrl) {
+        const resp = await this.api.post("/settings", { webhookUrl }, { ...this.optionsForSettingsEndpoints });
+        return resp.data;
+    }
+    /**
+     * Gets the status of communication with your app's webhook.
+     *
+     * @returns The status of communication with your app's webhook.
+     */
+    async getWebhookStatus() {
+        const resp = await this.api.get("/settings/webhook", {
+            ...this.optionsForSettingsEndpoints,
+        });
+        return resp.data;
+    }
+    /**
+     * Retries failed webhook requests.
+     *
+     * @returns void
+     */
+    async retryWebhookRequests() {
+        await this.api.post("/settings/webhook/retry", undefined, {
+            ...this.optionsForSettingsEndpoints,
+        });
+    }
+    /**
+     * Creates a new organization if one does not already exist.
+     *
+     * @param data The data to be used to create a new organization.
+     * @throws Error (400) if an organization already exists for the customer.
+     * @returns The created organization.
+     */
+    async createOrganization(data) {
+        const resp = await this.api.post(ORGANIZATION_URL, data);
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return organization_1.organizationSchema.parse(resp.data);
+    }
+    /**
+     * Updates an organization.
+     *
+     * @param organization The organization data to be updated.
+     * @return The updated organization.
+     */
+    async updateOrganization(organization) {
+        const payload = {
+            ...organization,
+            id: undefined,
+        };
+        const resp = await this.api.put(`${ORGANIZATION_URL}/${organization.id}`, payload, {
+            headers: { ...(0, base_update_1.getETagHeader)(organization) },
+        });
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return organization_1.organizationSchema.parse(resp.data);
+    }
+    /**
+     * Retrieve an organization representing this account.
+     *
+     * @returns The organization, or undefined if no organization has been created.
+     */
+    async getOrganization() {
+        const resp = await this.api.get(ORGANIZATION_URL);
+        if (!resp.data)
+            return undefined;
+        return organization_1.organizationSchema.parse(resp.data);
+    }
+    /**
+     * Creates a new facility.
+     *
+     * @param data The data to be used to create a new facility.
+     * @return The newly created facility.
+     */
+    async createFacility(data) {
+        const resp = await this.api.post(`${FACILITY_URL}`, data);
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return facility_1.facilitySchema.parse(resp.data);
+    }
+    /**
+     * Returns a facility.
+     *
+     * @param id The ID of the facility to be returned.
+     * @return The facilities.
+     */
+    async getFacility(id) {
+        const resp = await this.api.get(`${FACILITY_URL}/${id}`);
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return facility_1.facilitySchema.parse(resp.data);
+    }
+    /**
+     * Updates a facility.
+     *
+     * @param facility The facility data to be updated.
+     * @return The updated facility.
+     */
+    async updateFacility(facility) {
+        const payload = {
+            ...facility,
+            id: undefined,
+        };
+        const resp = await this.api.put(`${FACILITY_URL}/${facility.id}`, payload, {
+            headers: { ...(0, base_update_1.getETagHeader)(facility) },
+        });
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return facility_1.facilitySchema.parse(resp.data);
+    }
+    /**
+     * Returns the facilities associated with this account.
+     *
+     * @return The list of facilities.
+     */
+    async listFacilities() {
+        const resp = await this.api.get(`${FACILITY_URL}`);
+        if (!resp.data)
+            return [];
+        return facility_1.facilityListSchema.parse(resp.data).facilities;
+    }
+    /**
+     * Deletes a facility. It will fail if the facility has patients associated with it.
+     *
+     * @param facilityId The ID of facility to be deleted.
+     */
+    async deleteFacility(facilityId, eTag) {
+        await this.api.delete(`${FACILITY_URL}/${facilityId}`, {
+            headers: { ...(0, base_update_1.getETagHeader)({ eTag }) },
+        });
+    }
+    /**
+     * Returns the network entries supported by Metriport.
+     *
+     * @param filter Full text search filters, optional. If not provided, all network entries will be returned
+     *                (according to pagination settings).
+     *                See https://docs.metriport.com/medical-api/more-info/filters
+     * @param pagination Pagination settings, optional. If not provided, we paginate with a default page size of 100 items, and the first page will be returned.
+     *                   See https://docs.metriport.com/medical-api/more-info/pagination
+     * @returns An object containing:
+     * - `networkEntries` - The network entries in the current page.
+     * - `meta` - Pagination information, including how to get to the next page.
+     */
+    async listNetworkEntries({ filter, pagination, } = {}) {
+        const resp = await this.api.get(`${NETWORK_ENTRY_URL}`, {
+            params: {
+                filter,
+                ...getPaginationParams(pagination),
+            },
+        });
+        if (!resp.data)
+            return { meta: { itemsOnPage: 0 }, networkEntries: [] };
+        return resp.data;
+    }
+    async listNetworkEntriesPage(url) {
+        const resp = await this.api.get(url);
+        return resp.data;
+    }
+    /**
+     * Starts a network query for the specified patient across available health data networks.
+     * This triggers an asynchronous query against various kinds of health data sources including
+     * HIEs, pharmacies, and laboratories.
+     *
+     * As data from each source is processed and merged into the patient's consolidated data,
+     * `network-query.*` webhook events are emitted.
+     *
+     * Note: This endpoint returns a 2XX status code even when one or more data sources fail
+     * to start. Source-level failures are reported in the `errors` array of the response body.
+     *
+     * @param request.patientId The ID of the patient for which to query health data.
+     * @param request.sources An array of data sources to query. Must contain at least one value.
+     *        Possible values: "hie", "pharmacy", "lab".
+     * @param request.metadata Optional custom metadata to include with the request.
+     *        This will be returned in webhook payloads.
+     * @returns The network query status including requestId, status, sources, and any errors.
+     */
+    async startNetworkQuery(request) {
+        const { patientId, sources, metadata } = request;
+        const resp = await this.api.post(NETWORK_QUERY_URL, { sources, metadata }, { params: { patientId } });
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return network_query_1.networkQueryStatusDtoSchema.parse(resp.data);
+    }
+    /**
+     * Returns the status of a specific network query request.
+     * Use this to check the progress of the query.
+     *
+     * @param request.requestId The ID of the network query request.
+     *        This is returned when you start a network query.
+     * @returns The network query status including requestId, status, sources, and any errors.
+     */
+    async getNetworkQueryStatus(request) {
+        const { requestId } = request;
+        const resp = await this.api.get(`${NETWORK_QUERY_URL}/${requestId}`);
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return network_query_1.networkQueryStatusDtoSchema.parse(resp.data);
+    }
+    /**
+     * Creates a new patient at Metriport and HIEs.
+     *
+     * @param data The data to be used to create a new patient.
+     * @param facilityId The facility providing the NPI to support this operation.
+     * @param additionalQueryParams Optional, additional query parameters to be sent with the request.
+     * @return The newly created patient.
+     */
+    async createPatient(data, facilityId, additionalQueryParams = {}) {
+        const resp = await this.api.post(`${PATIENT_URL}`, data, {
+            params: { facilityId, ...additionalQueryParams },
+        });
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return resp.data;
+    }
+    /**
+     * Returns a patient.
+     *
+     * @param id The ID of the patient to be returned.
+     * @return The patient.
+     */
+    async getPatient(id) {
+        const resp = await this.api.get(`${PATIENT_URL}/${id}`);
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return resp.data;
+    }
+    /**
+     * Returns a patient based on external ID.
+     *
+     * @param externalId The external ID of the patient to be returned.
+     * @param source The source of the external ID, if required.
+     * @return The patient.
+     */
+    async getPatientByExternalId(externalId, source) {
+        const resp = await this.api.get(`${PATIENT_URL}/external-id`, {
+            params: { externalId, source },
+        });
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return resp.data;
+    }
+    /**
+     * Searches for a patient previously created at Metriport, based on demographics.
+     *
+     * @return The patient if found.
+     */
+    async matchPatient(data) {
+        try {
+            const resp = await this.api.post(`${PATIENT_URL}/match`, data);
+            if (!resp.data)
+                throw new Error(NO_DATA_MESSAGE);
+            return resp.data;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (err) {
+            if (err.response?.status !== http_status_1.default.NOT_FOUND)
+                throw err;
+            return undefined;
+        }
+    }
+    /**
+     * Maps a Metriport patient to a patient in an external EHR system and synchronizes their data.
+     *
+     * @param patientId The ID of the patient to map.
+     * @param source The source name that represents the external system/EHR, either healthie or elation. Optional.
+     * @return The Metriport patient ID and the mapping patient (external) ID.
+     * @throws error if the patient has no external ID to attempt mapping.
+     * @throws error if the mapping source is not supported.
+     * @throws error if no mapping is found.
+     * @throws error if patient demographics are not matching.
+     */
+    async syncPatient(patientId, source) {
+        const resp = await this.api.post(`${PATIENT_URL}/${patientId}/external/sync`, undefined, {
+            params: { source },
+        });
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return resp.data;
+    }
+    /**
+     * Updates a patient at Metriport and at HIEs the patient is linked to.
+     *
+     * @param patient The patient data to be updated.
+     * @param facilityId Optional. The facility providing the NPI to support this operation. If not provided and the patient has only one facility, that one will be used. If not provided and the patient has multiple facilities, an error will be thrown.
+     * @param additionalQueryParams Optional, additional query parameters to be sent with the request.
+     * @return The updated patient.
+     */
+    async updatePatient(patient, facilityId, additionalQueryParams = {}) {
+        const payload = {
+            ...patient,
+            id: undefined,
+        };
+        const resp = await this.api.put(`${PATIENT_URL}/${patient.id}`, payload, {
+            params: { facilityId, ...additionalQueryParams },
+            headers: { ...(0, base_update_1.getETagHeader)(patient) },
+        });
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return resp.data;
+    }
+    /**
+     * Updates a patient's HIE opt-out status.
+     *
+     * @param patientId The ID of the patient whose opt-out status should be updated
+     * @param hieOptOut Boolean indicating whether to opt the patient out (true) or in (false)
+     * @returns The updated opt-out status
+     */
+    async updatePatientHieOptOut(patientId, hieOptOut) {
+        const resp = await this.api.put(`${PATIENT_URL}/${patientId}/hie-opt-out`, undefined, {
+            params: { hieOptOut },
+        });
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return resp.data;
+    }
+    /**
+     * Sets the facilities associated with a patient. This operation overrides any existing
+     * facility associations and replaces them with the provided list.
+     *
+     * @param patientId The ID of the patient to set facilities for.
+     * @param facilityIds The array of facility IDs to associate with the patient. This will replace all existing associations.
+     * @returns The updated facilities associated with the patient.
+     */
+    async setPatientFacilities(patientId, facilityIds) {
+        const resp = await this.api.post(`${PATIENT_URL}/${patientId}/facility`, {
+            facilityIds,
+        });
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return resp.data.facilities;
+    }
+    /**
+     * Gets all facilities associated with a patient.
+     *
+     * @param patientId The ID of the patient whose facilities are to be returned.
+     * @returns Array of facilities associated with the patient.
+     */
+    async getPatientFacilities(patientId) {
+        const resp = await this.api.get(`${PATIENT_URL}/${patientId}/facility`);
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return resp.data.facilities;
+    }
+    // TODO #870 remove this
+    /** ---------------------------------------------------------------------------
+     * Returns a patient's consolidated data.
+     * @deprecated Use startConsolidatedQuery() and getConsolidatedQueryStatus() instead.
+     *
+     * Note if only patientId is provided the endpoint may take long to respond as its
+     * fetching all the resources for the patient.
+     *
+     * @param patientId The ID of the patient whose data is to be returned.
+     * @param resources Optional array of resources to be returned.
+     * @param dateFrom Optional start date that resources will be filtered by (inclusive). Format is YYYY-MM-DD.
+     * @param dateTo Optional end date that resources will be filtered by (inclusive). Format is YYYY-MM-DD.
+     * @param fromDashboard Optional parameter to indicate that the request is coming from the dashboard.
+     * @return Patient's consolidated data.
+     */
+    async getPatientConsolidated(patientId, resources, dateFrom, dateTo, fromDashboard) {
+        const resp = await this.api.get(`${PATIENT_URL}/${patientId}/consolidated`, {
+            params: { resources: resources && resources.join(","), dateFrom, dateTo, fromDashboard },
+        });
+        return resp.data;
+    }
+    /** ---------------------------------------------------------------------------
+     * Start a query for the patient's consolidated data (FHIR resources).
+     * The results are sent through Webhook (see https://docs.metriport.com/medical-api/more-info/webhooks).
+     * Only one query per given patient can be executed at a time.
+     *
+     * @param patientId The ID of the patient whose data is to be returned.
+     * @param resources Optional array of resources to be returned (defaults to all resource types).
+     * @param dateFrom Optional start date that resources will be filtered by (inclusive). Format is YYYY-MM-DD.
+     * @param dateTo Optional end date that resources will be filtered by (inclusive). Format is YYYY-MM-DD.
+     * @param conversionType Optional to indicate how the medical record should be rendered - one of:
+     *      "pdf", "html", or "json" (defaults to "json"). The Webhook payload
+     *      will contain a signed URL to download the file, which is active for 10 minutes.
+     * @param fromDashboard Optional parameter to indicate that the request is coming from the dashboard.
+     * @param metadata Optional metadata to be sent along the webhook request as response of this query.
+     * @return The consolidated data query status.
+     */
+    async startConsolidatedQuery(patientId, resources, dateFrom, dateTo, conversionType = "json", fromDashboard, metadata) {
+        const whMetadata = { metadata: metadata };
+        const resp = await this.api.post(`${PATIENT_URL}/${patientId}/consolidated/query`, whMetadata, {
+            params: {
+                resources: resources && resources.join(","),
+                dateFrom,
+                dateTo,
+                fromDashboard,
+                conversionType,
+            },
+        });
+        return resp.data;
+    }
+    /** ---------------------------------------------------------------------------
+     * Get the consolidated data query status for a given patient.
+     * The results to the query are sent through Webhook (see
+     * startConsolidatedQuery() and https://docs.metriport.com/medical-api/more-info/webhooks).
+     *
+     * @param patientId The ID of the patient whose data is to be returned.
+     * @return The consolidated data query status.
+     */
+    async getConsolidatedQueryStatus(patientId) {
+        const resp = await this.api.get(`${PATIENT_URL}/${patientId}/consolidated/query`);
+        return resp.data;
+    }
+    /** ---------------------------------------------------------------------------
+     * Get the consolidated data query status for a given patient and requestId.
+     * The results to the query are sent through Webhook (see
+     * startConsolidatedQuery() and https://docs.metriport.com/medical-api/more-info/webhooks).
+     *
+     * @param patientId The ID of the patient whose data is to be returned.
+     * @param requestId The ID of the request to get the status of.
+     * @return The single consolidated data query status.
+     */
+    async getSingleConsolidatedQueryStatus(patientId, requestId) {
+        const resp = await this.api.get(`${PATIENT_URL}/${patientId}/consolidated/query/${requestId}`);
+        return resp.data;
+    }
+    /** ---------------------------------------------------------------------------
+     * Add patient data as FHIR resources. Those can later be queried with startConsolidatedQuery(),
+     * and will be made available to HIEs.
+     *
+     * Note: each call to this function is limited to 1Mb of data (and 50 resources when in sandbox).
+     * You can make multiple calls to this function to add more data.
+     *
+     * @param patientId The ID of the patient to associate resources to.
+     * @param payload The FHIR Bundle to create resources.
+     * @return FHIR Bundle with operation outcome.
+     */
+    async createPatientConsolidated(patientId, payload) {
+        const resp = await this.api.put(`${PATIENT_URL}/${patientId}/consolidated`, payload);
+        this._lastRequestId = resp.headers[REQUEST_ID_HEADER_NAME];
+        return resp.data;
+    }
+    /** ---------------------------------------------------------------------------
+     * Returns the amount of resources available for a given patient, per resource type.
+     *
+     * @param patientId The ID of the patient whose data is to be returned.
+     * @param resources Optional array of resources to be considered.
+     * @param dateFrom Optional start date that resources will be filtered by (inclusive). Format is YYYY-MM-DD.
+     * @param dateTo Optional end date that resources will be filtered by (inclusive). Format is YYYY-MM-DD.
+     * @return the amount of resources available per resource type for the given Patient.
+     */
+    async countPatientConsolidated(patientId, resources, dateFrom, dateTo) {
+        const resp = await this.api.get(`${PATIENT_URL}/${patientId}/consolidated/count`, {
+            params: { resources: resources && resources.join(","), dateFrom, dateTo },
+        });
+        return resp.data;
+    }
+    /**
+     * Returns the medical record summary for a given patient.
+     *
+     * @param patientId The ID of the patient whose medical record summary is to be returned.
+     * @param conversionType The format of the medical record summary to be returned. Accepts "html" or "pdf".
+     * @return The medical record summary for the given patient.
+     */
+    async getPatientMedicalRecord(patientId, conversionType) {
+        const resp = await this.api.get(`${PATIENT_URL}/${patientId}/medical-record`, {
+            params: { conversionType },
+        });
+        return patient_1.medicalRecordUrlResponseSchema.parse(resp.data);
+    }
+    /**
+     * Removes a patient at Metriport and at HIEs the patient is linked to.
+     *
+     * @param patientId The ID of the patient to be deleted.
+     * @param facilityId The facility providing the NPI to support this operation.
+     */
+    async deletePatient(patientId, facilityId, eTag) {
+        await this.api.delete(`${PATIENT_URL}/${patientId}`, {
+            params: { facilityId },
+            headers: { ...(0, base_update_1.getETagHeader)({ eTag }) },
+        });
+    }
+    /**
+     * Returns the patients associated with given facility.
+     *
+     * @param facilityId The ID of the facility, optional. If not provided, patients from all facilities
+     *                   will be returned.
+     * @param filters Full text search filters, optional. If not provided, all patients will be returned
+     *                (according to pagination settings).
+     *                See https://docs.metriport.com/medical-api/more-info/filters
+     * @param pagination Pagination settings, optional. If not provided, the first page will be returned.
+     *                   See https://docs.metriport.com/medical-api/more-info/pagination
+     * @returns An object containing:
+     * - `patients` - A single page containing the patients corresponding to the given facility.
+     * - `meta` - Pagination information, including how to get to the next page.
+     */
+    async listPatients({ facilityId, filters, pagination, } = {}) {
+        const resp = await this.api.get(`${PATIENT_URL}`, {
+            params: {
+                facilityId,
+                filters,
+                ...getPaginationParams(pagination),
+            },
+        });
+        if (!resp.data)
+            return { patients: [], meta: { itemsOnPage: 0 } };
+        return resp.data;
+    }
+    async listPatientsPage(url) {
+        const resp = await this.api.get(url);
+        return resp.data;
+    }
+    /**
+     * Deletes an existing cohort.
+     * @param id The ID of the cohort to delete.
+     */
+    async deleteCohort(id) {
+        await this.api.delete(`${COHORT_URL}/${id}`);
+    }
+    /**
+     * Update an existing cohort. This does a partial update of payload contents excluding settings.
+     * Please contact us if you need to update cohort settings.
+     * @param cohort The properties of the cohort to update, including the id.
+     * @returns The updated cohort.
+     */
+    async updateCohort(cohort) {
+        const { id, ...cohortData } = cohort;
+        const resp = await this.api.patch(`${COHORT_URL}/${id}`, cohortData, {
+            headers: { ...(0, base_update_1.getETagHeader)({ eTag: cohort.eTag }) },
+        });
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return resp.data;
+    }
+    /**
+     * Returns the cohort with the given ID.
+     * @param id The ID of the cohort to return.
+     * @returns The specified cohort.
+     */
+    async getCohort(id) {
+        const resp = await this.api.get(`${COHORT_URL}/${id}`);
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return resp.data;
+    }
+    /**
+     * Returns all available cohorts.
+     * @returns All available cohorts.
+     */
+    async listCohorts() {
+        const resp = await this.api.get(`${COHORT_URL}`);
+        if (!resp.data)
+            return { cohorts: [] };
+        return resp.data;
+    }
+    /**
+     * Add patients to a cohort.
+     * @param cohortId The ID of the cohort to add patients to.
+     * @param patientIds The IDs of the patients to add to the cohort.
+     * @param allPatients Property to confirm you want to assign all patients to the cohort.
+     * @returns The updated cohort with a message.
+     */
+    async addPatientsToCohort({ cohortId, patientIds, allPatients, }) {
+        const data = {
+            allPatients,
+            patientIds,
+        };
+        const resp = await this.api.post(`${COHORT_URL}/${cohortId}/patient`, data);
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return resp.data;
+    }
+    /**
+     * Remove patients from a cohort.
+     * @param cohortId The ID of the cohort to remove patients from.
+     * @param patientIds The IDs of the patients to remove from the cohort.
+     * @param allPatients Property to confirm you want to remove all patients from the cohort.
+     * @returns The updated cohort with a message.
+     */
+    async removePatientsFromCohort({ cohortId, patientIds, allPatients, }) {
+        const data = {
+            allPatients,
+            patientIds,
+        };
+        const resp = await this.api.delete(`${COHORT_URL}/${cohortId}/patient`, { data });
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return resp.data;
+    }
+    /**
+     * Lists patients in a cohort.
+     * @param id The ID of the cohort to list patients from.
+     * @param pagination Pagination settings, optional. If not provided, the first page will be returned.
+     *                   See https://docs.metriport.com/medical-api/more-info/pagination
+     * @returns An object containing:
+     * - `patients` - A single page containing the patients in the cohort.
+     * - `meta` - Pagination information, including how to get to the next page.
+     */
+    async listPatientsInCohort({ id, pagination, }) {
+        const resp = await this.api.get(`${COHORT_URL}/${id}/patient`, {
+            params: {
+                ...getPaginationParams(pagination),
+            },
+        });
+        if (!resp.data)
+            return { patients: [], meta: { itemsOnPage: 0 } };
+        return resp.data;
+    }
+    async getCohortPatientsPage(url) {
+        const resp = await this.api.get(url);
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return resp.data;
+    }
+    /**
+     * Add a patient to multiple cohorts.
+     * @param patientId The ID of the patient to add to cohorts.
+     * @param cohortIds The IDs of the cohorts to add the patient to.
+     * @returns The list of cohorts the patient is a member of.
+     */
+    async addPatientToCohorts(patientId, cohortIds) {
+        const resp = await this.api.post(`${PATIENT_URL}/${patientId}/cohort`, { cohortIds });
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return resp.data;
+    }
+    /**
+     * Returns all cohorts assigned to a patient.
+     * @param id The ID of the patient.
+     * @returns The list of cohorts assigned to the patient.
+     */
+    async listCohortsForPatient(id) {
+        const resp = await this.api.get(`${PATIENT_URL}/${id}/cohort`);
+        if (!resp.data)
+            return { cohorts: [] };
+        return resp.data;
+    }
+    /**
+     * Returns document references for the given patient across HIEs.
+     *
+     * @param patientId Patient ID for which to retrieve document metadata.
+     * @param filters.dateFrom Optional start date that docs will be filtered by (inclusive).
+     *    If the type is Date, its assumed UTC. If the type is string, its assumed to be ISO 8601 (Date only).
+     * @param filters.dateTo Optional end date that docs will be filtered by (inclusive).
+     *    If the type is Date, its assumed UTC. If the type is string, its assumed to be ISO 8601 (Date only).
+     * @param filters.content Optional value to search on the document reference
+     *    (partial match and case insentitive, minimum 3 chars).
+     * @return The list of document references.
+     */
+    async listDocuments(patientId, { dateFrom, dateTo, content } = {}) {
+        const parsedDateFrom = (0, shared_1.optionalDateToISOString)(dateFrom);
+        const parsedDateTo = (0, shared_1.optionalDateToISOString)(dateTo);
+        const resp = await this.api.get(`${DOCUMENT_URL}`, {
+            params: {
+                patientId,
+                dateFrom: parsedDateFrom,
+                dateTo: parsedDateTo,
+                content,
+            },
+        });
+        if (!resp.data)
+            return { documents: [] };
+        return resp.data;
+    }
+    /**
+     * @deprecated Use listDocuments() instead.
+     *
+     * Returns document references for the given patient across HIEs, in the DTO format.
+     *
+     * @param patientId Patient ID for which to retrieve document metadata.
+     * @param filters.dateFrom Optional start date that docs will be filtered by (inclusive).
+     *    If the type is Date, its assumed UTC. If the type is string, its assumed to be ISO 8601 (Date only).
+     * @param filters.dateTo Optional end date that docs will be filtered by (inclusive).
+     *    If the type is Date, its assumed UTC. If the type is string, its assumed to be ISO 8601 (Date only).
+     * @param filters.content Optional value to search on the document reference
+     *    (partial match and case insentitive, minimum 3 chars).
+     * @return The list of document references.
+     */
+    async listDocumentsAsDTO(patientId, { dateFrom, dateTo, content } = {}) {
+        const parsedDateFrom = (0, shared_1.optionalDateToISOString)(dateFrom);
+        const parsedDateTo = (0, shared_1.optionalDateToISOString)(dateTo);
+        const resp = await this.api.get(`${DOCUMENT_URL}`, {
+            params: {
+                patientId,
+                dateFrom: parsedDateFrom,
+                dateTo: parsedDateTo,
+                content,
+                output: "dto",
+            },
+        });
+        if (!resp.data)
+            return [];
+        return document_1.documentListSchema.parse(resp.data).documents;
+    }
+    /**
+     * Start a document query for the given patient across HIEs.
+     *
+     * @param patientId Patient ID for which to retrieve document metadata.
+     * @param facilityId The facility providing the NPI to support this operation (optional).
+     *        If not provided and the patient has only one facility, that one will be used.
+     *        If not provided and the patient has multiple facilities, an error will be thrown.
+     * @param metadata Optional metadata to be sent along the webhook request as response of this query.
+     * @return The document query request ID, progress & status indicating whether its being executed or not.
+     */
+    async startDocumentQuery(patientId, facilityId, metadata) {
+        const whMetadata = { metadata: metadata };
+        const resp = await this.api.post(`${DOCUMENT_URL}/query`, whMetadata, {
+            params: {
+                patientId,
+                facilityId,
+            },
+        });
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return document_1.documentQuerySchema.parse(resp.data);
+    }
+    /**
+     * Start a bulk document download for a given patient, with the payload returned to the webhook.
+     *
+     * @param patientId Patient ID for which to retrieve document URLs.
+     * @param metadata Optional metadata to be sent along the webhook request as response of this query.
+     * @return The document query request ID, progress, and status indicating whether it's being executed or not.
+     */
+    async startBulkGetDocumentUrl(patientId, metadata) {
+        const whMetadata = { metadata: metadata };
+        const resp = await this.api.post(`${DOCUMENT_URL}/download-url/bulk`, whMetadata, {
+            params: {
+                patientId,
+            },
+        });
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return document_1.bulkGetDocumentUrlQuerySchema.parse(resp.data);
+    }
+    /**
+     * Returns the document query status for the specified patient.
+     *
+     * @param patientId Patient ID for which to retrieve document query status.
+     * @return The document query request ID, progress & status indicating whether its being executed or not.
+     */
+    async getDocumentQueryStatus(patientId) {
+        const resp = await this.api.get(`${DOCUMENT_URL}/query`, {
+            params: { patientId },
+        });
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return document_1.documentQuerySchema.parse(resp.data);
+    }
+    /**
+     * Returns a URL that can be used to download the document.
+     *
+     * @param req.query.fileName The file name of the document in s3.
+     * @param req.query.conversionType The doc type to convert to. Valid values are "html" and "pdf".
+     * @return presigned url
+     */
+    //eslint-disable-next-line @typescript-eslint/no-explicit-any
+    async getDocumentUrl(fileName, conversionType) {
+        const resp = await this.api.get(`${DOCUMENT_URL}/download-url`, {
+            params: {
+                fileName,
+                conversionType,
+            },
+        });
+        return resp.data;
+    }
+    /**
+     * @deprecated - Use createDocumentReference() instead.
+     * Returns a URL to upload a file to Metriport and make the document available to other HIEs.
+     * To upload your file contents, execute a PUT request using this URL with the file contents as the request body.
+     * Refer to Metriport documentation for more details:
+     * https://docs.metriport.com/medical-api/api-reference/document/post-upload-url
+     *
+     * @param patientId - the ID of the patient.
+     * @param docRef - a FHIR Document Reference for this file upload. Mandatory fields include DocumentReference.description, DocumentReference.type, and DocumentReference.context. Besides that, try to include as much metadata on the document as possible. Note that you DO NOT need to fill in the Organization or Patient fields under the author or contained fields - Metriport will fill this in and overwrite whatever you put in.
+     * Refer to Metriport's documentation for more details: https://docs.metriport.com/medical-api/fhir/resources/documentreference.
+     *
+     * @returns A URL string to be used for subsequent file upload.
+     */
+    async getDocumentUploadUrl(patientId, docRef) {
+        const url = `${DOCUMENT_URL}/upload-url/?patientId=${patientId}`;
+        const resp = await this.api.post(url, docRef);
+        return resp.data;
+    }
+    /**
+     * Creates a DocumentReference and returns its ID along with a URL to upload the respective Document file to Metriport and make this document available to other HIEs.
+     * To upload your file contents, execute a PUT request using the returned uploadUrl with the file contents as the request body.
+     * Refer to Metriport Documentation for more details:
+     * https://docs.metriport.com/medical-api/api-reference/document/post-upload-url
+     *
+     * @param patientId - the ID of the patient.
+     * @param docRef - a FHIR Document Reference for this file upload. Mandatory fields include DocumentReference.description, DocumentReference.type, and DocumentReference.context. Besides that, try to include as much metadata on the document as possible. Note that you DO NOT need to fill in the Organization or Patient fields under the author or contained fields - Metriport will fill this in and overwrite whatever you put in.
+     * Refer to Metriport's documentation for more details: https://docs.metriport.com/medical-api/fhir/resources/documentreference.
+     *
+     * @returns The DocumentReference ID, and the URL to be used for subsequent file upload.
+     */
+    async createDocumentReference(patientId, docRef) {
+        const url = `${DOCUMENT_URL}/upload/?patientId=${patientId}`;
+        const resp = await this.api.post(url, docRef);
+        return resp.data;
+    }
+    /**
+     * Verifies the signature of a webhook request.
+     * Refer to Metriport's documentation for more details: https://docs.metriport.com/medical-api/more-info/webhooks.
+     *
+     * @param key - your webhook key.
+     * @param body - the raw body of the webhook request, as string or Buffer.
+     * @param signature - the signature obtained from the webhook request header.
+     * @returns True if the signature is verified, false otherwise.
+     * @throws Error if the body is not a string.
+     */
+    verifyWebhookSignature(key, body, signature) {
+        return MetriportMedicalApi.verifyWebhookSignature(key, body, signature);
+    }
+    /**
+     * Verifies the signature of a webhook request.
+     * Refer to Metriport's documentation for more details: https://docs.metriport.com/medical-api/more-info/webhooks.
+     *
+     * @param key - your webhook key.
+     * @param body - the raw body of the webhook request, as string or Buffer.
+     * @param signature - the signature obtained from the webhook request header.
+     * @returns True if the signature is verified, false otherwise.
+     * @throws Error if the body is not a string.
+     */
+    static verifyWebhookSignature(key, body, signature) {
+        if (typeof body !== "string" && !(body instanceof Buffer)) {
+            throw new Error("Body must be a string or Buffer");
+        }
+        const normalizedBody = typeof body === "string" ? body : body.toString();
+        const receivedSignature = signature;
+        const expectedSignature = crypto_1.default.createHmac("sha256", key).update(normalizedBody).digest("hex");
+        const a = Buffer.from(expectedSignature);
+        const b = Buffer.from(receivedSignature);
+        if (Buffer.byteLength(a) != Buffer.byteLength(b))
+            return false;
+        return crypto_1.default.timingSafeEqual(a, b);
+    }
+    static parseWebhookResponse(reqBody, throwOnError = true) {
+        if (throwOnError) {
+            try {
+                return medical_1.webhookRequestSchema.parse(reqBody);
+            }
+            catch (error) {
+                throw new Error(`Failed to parse webhook request`, { cause: error });
+            }
+        }
+        const parse = medical_1.webhookRequestSchema.safeParse(reqBody);
+        if (parse.success)
+            return parse.data;
+        return new medical_1.WebhookRequestParsingFailure(parse.error, parse.error.format());
+    }
+    /**
+     * Creates an access token for embedding Metriport components in your application.
+     *
+     * @param data.expirationInSeconds - Optional expiration time in seconds (max 36000, default 36000).
+     * @returns The generated access token.
+     */
+    async createEmbedToken(data) {
+        const resp = await this.api.post(`${TOKEN_URL}/embed`, data);
+        if (!resp.data)
+            throw new Error(NO_DATA_MESSAGE);
+        return resp.data;
+    }
+}
+exports.MetriportMedicalApi = MetriportMedicalApi;
+function getPaginationParams(pagination) {
+    const { fromItem, toItem, count } = pagination ?? {};
+    return { fromItem, toItem, count };
+}
+//# sourceMappingURL=metriport.js.map