@medipass/web-sdk 11.38.0 → 11.38.1-feature-typescript-claudia.1

package/lib/resources/payments.js.flow

@@ -1,523 +0,0 @@
-// @flow
-import braintreeClient from 'braintree-web/client';
-import braintreeGooglePayment from 'braintree-web/google-payment';
-import braintreeApplePay from 'braintree-web/apple-pay';
-import pify from '@medipass/pify';
-import env from '@medipass/utils/get-env';
-import { ERROR_MESSAGES, PAYMENT_PROVIDERS } from '@medipass/utils/constants';
-import * as sentry from '@medipass/utils/sentry';
-import _get from 'lodash/get';
-
-import request from '../utils/request';
-import doesParamExist from '../utils/does-param-exist';
-import * as patients from './patients';
-
-import type { MedipassRequestOpts } from '../_types';
-
-const PATH__PAYMENTS = '/payments';
-const pathAccountPaymentMethods = accountId => `/accounts/${accountId}/paymentmethods`;
-const pathAccountPaymentMethod = (accountId, paymentMethodId) =>
-  `/accounts/${accountId}/paymentmethods/${paymentMethodId}`;
-const pathBusinessPaymentsClientTokens = businessId => `/businesses/${businessId}/payments/clienttoken`;
-const pathBusinessPaymentMethods = businessId => `/businesses/${businessId}/paymentmethods`;
-const pathBusinessPaymentMethod = (businessId, paymentMethodId) =>
-  `/businesses/${businessId}/paymentmethods/${paymentMethodId}`;
-const pathBusinessPatientPaymentMethods = (businessId, patientId) =>
-  `/businesses/${businessId}/patients/${patientId}/paymentmethods`;
-const pathBusinessPatientPaymentMethodsByRefId = (businessId, refId) =>
-  `/businesses/${businessId}/patients/refid/${refId}/paymentmethods`;
-const pathBusinessPatientPaymentMethod = (businessId, patientId, paymentMethodId) =>
-  `/businesses/${businessId}/patients/${patientId}/paymentmethods/${paymentMethodId}`;
-const pathBusinessSalesClientToken = businessId => `/businesses/${businessId}/sales/clienttoken`;
-
-/**
- * Create an account's payment method
- * @param {String} accountId - Account ID
- * @param {Object} opts - Additional options
- * @returns {Object} The device data
- */
-export const createAccountPaymentMethod = async (
-  accountId: string,
-  nonce: string,
-  source: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ accountId, nonce, source }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathAccountPaymentMethods(accountId) }, { method: 'post', data: { nonce, source } });
-};
-
-/**
- * Get a business' payment methods
- * @param {String} businessId - Business ID
- * @param {Object} opts - Additional options
- * @returns {Object} The device data
- */
-export const createBusinessPaymentMethod = async (
-  businessId: string,
-  nonce: string,
-  source: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, nonce, source }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathBusinessPaymentMethods(businessId) },
-    { method: 'post', data: { nonce, source } }
-  );
-};
-
-/**
- * Create a business patient payment method
- * @param {String} accountId - Account ID
- * @param {String} patientId - Patient ID
- * @param {Object} opts - Additional options
- * @returns {Object} The device data
- */
-export const createBusinessPatientPaymentMethod = async (
-  businessId: string,
-  patientId: string,
-  nonce: string,
-  source: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, patientId, nonce, source }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathBusinessPatientPaymentMethods(businessId, patientId) },
-    { method: 'post', data: { nonce, source } }
-  );
-};
-
-/**
- * Delete an account's payment method
- * @param {String} accountId - Account ID
- * @param {String} paymentMethodId - Account ID
- * @param {Object} opts - Additional options
- * @returns {Object} The device data
- */
-export const deleteAccountPaymentMethod = async (
-  accountId: string,
-  paymentMethodId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ accountId, paymentMethodId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathAccountPaymentMethod(accountId, paymentMethodId) }, { method: 'delete' });
-};
-
-/**
- * Delete a business' payment method
- * @param {String} businessId - Business ID
- * @param {String} paymentMethodId - Payment Method ID
- * @param {Object} opts - Additional options
- * @returns {Object} The device data
- */
-export const deleteBusinessPaymentMethod = async (
-  businessId: string,
-  paymentMethodId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, paymentMethodId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessPaymentMethod(businessId, paymentMethodId) }, { method: 'delete' });
-};
-
-/**
- * Delete a business patient payment method
- * @param {String} businessId - Business ID
- * @param {String} patientId - Patient ID
- * @param {String} paymentMethodId - Payment Method ID
- * @param {Object} opts - Additional options
- * @returns {Object} The device data
- */
-export const deleteBusinessPatientPaymentMethod = async (
-  businessId: string,
-  patientId: string,
-  paymentMethodId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, patientId, paymentMethodId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathBusinessPatientPaymentMethod(businessId, patientId, paymentMethodId) },
-    { method: 'delete' }
-  );
-};
-
-/**
- * Get an account's payment methods
- * @param {String} accountId - Account ID
- * @param {Object} opts - Additional options
- * @returns {Object} The device data
- */
-export const getAccountPaymentMethods = async (accountId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ accountId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathAccountPaymentMethods(accountId) }, { method: 'get' });
-};
-
-/**
- * Get a business' payment methods
- * @param {String} businessId - Business ID
- * @param {Object} opts - Additional options
- * @returns {Object} The device data
- */
-export const getBusinessPaymentMethods = async (
-  businessId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessPaymentMethods(businessId) }, { method: 'get' });
-};
-
-/**
- * Get a business patient payment methods
- * @param {String} businessId - Business ID
- * @param {Object} opts - Additional options
- * @returns {Object} The payment methods data
- */
-export const getBusinessPatientPaymentMethods = async (
-  businessId: string,
-  patientId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, patientId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessPatientPaymentMethods(businessId, patientId) }, { method: 'get' });
-};
-
-/**
- * Get a business patient payment methods by ref id
- * @param {String} businessId - Business ID
- * @param {String} refId - Patient ref ID
- * @param {Object} opts - Additional options
- * @returns {Object} The payment methods data
- */
-export const getBusinessPatientPaymentMethodsByRefId = async (
-  businessId: string,
-  refId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, refId }, opts.hyperMediaEndpoint);
-
-  return request({ ...opts, path: pathBusinessPatientPaymentMethodsByRefId(businessId, refId) }, { method: 'get' });
-};
-
-/**
- * Get an account's payment method
- * @param {String} accountId - Account ID
- * @param {String} paymentMethodId - Account ID
- * @param {Object} opts - Additional options
- * @returns {Object} The device data
- */
-export const getAccountPaymentMethod = async (
-  accountId: string,
-  paymentMethodId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ accountId, paymentMethodId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathAccountPaymentMethod(accountId, paymentMethodId) }, { method: 'get' });
-};
-
-/**
- * Get a business payment method
- * @param {String} businessId - Business ID
- * @param {String} paymentMethodId - Payment Method ID
- * @param {Object} opts - Additional options
- * @returns {Object} The device data
- */
-export const getBusinessPaymentMethod = async (
-  businessId: string,
-  paymentMethodId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, paymentMethodId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessPaymentMethod(businessId, paymentMethodId) }, { method: 'get' });
-};
-
-/**
- * Get a business patient payment method
- * @param {String} businessId - Business ID
- * @param {String} patientID - Patient ID
- * @param {String} paymentMethodId - Payment Method ID
- * @param {Object} opts - Additional options
- * @returns {Object} The device data
- */
-export const getBusinessPatientPaymentMethod = async (
-  businessId: string,
-  patientId: string,
-  paymentMethodId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, patientId, paymentMethodId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathBusinessPatientPaymentMethod(businessId, patientId, paymentMethodId) },
-    { method: 'get' }
-  );
-};
-
-/**
- * Get business client token
- * @param {String} businessId - Business ID
- * @param {String} source - Source of payment
- * @param {Object} opts - Additional options
- * @returns {Object} The device data
- */
-export const getBusinessClientToken = async (
-  businessId: string,
-  source: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, source }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathBusinessPaymentsClientTokens(businessId) },
-    { method: 'get', params: { source } }
-  );
-};
-
-/**
- * Get business sales client token
- * @param {String} businessId - Business ID
- * @param {Object} opts - Additional options
- * @returns {Object} The device data
- */
-export const getBusinessSalesClientToken = async (
-  businessId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessSalesClientToken(businessId) }, { method: 'get' });
-};
-
-/**
- * Get client token
- * @param {String} source - Source of payment
- * @param {Object} opts - Additional options
- * @returns {Object} The device data
- */
-export const getClientToken = async (
-  source: string,
-  opts?: MedipassRequestOpts = { tokenType: 'account' }
-): Promise<Object> => {
-  doesParamExist({ source }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: `${PATH__PAYMENTS}/clienttoken` },
-    { method: 'get', params: { source }, tokenType: opts.tokenType }
-  );
-};
-
-/**
- * Update an account's payment method
- * @param {String} accountId - Account ID
- * @param {String} paymentMethodId - Account ID
- * @param {Object} opts - Additional options
- * @returns {Object} The device data
- */
-export const updateAccountPaymentMethod = async (
-  accountId: string,
-  paymentMethodId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ accountId, paymentMethodId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathAccountPaymentMethod(accountId, paymentMethodId) },
-    { data: body, method: 'put' }
-  );
-};
-
-/**
- * Update a business' payment method
- * @param {String} businessId - Business ID
- * @param {String} paymentMethodId - Account ID
- * @param {Object} opts - Additional options
- * @returns {Object} The device data
- */
-export const updateBusinessPaymentMethod = async (
-  businessId: string,
-  paymentMethodId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, paymentMethodId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathBusinessPaymentMethod(businessId, paymentMethodId) },
-    { data: body, method: 'put' }
-  );
-};
-
-/**
- * Update a business patient payment method
- * @param {String} businessId - Business ID
- * @param {String} paymentMethodId - Account ID
- * @param {Object} opts - Additional options
- * @returns {Object} The device data
- */
-export const updateBusinessPatientPaymentMethod = async (
-  businessId: string,
-  patientId: string,
-  paymentMethodId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, patientId, paymentMethodId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathBusinessPatientPaymentMethod(businessId, patientId, paymentMethodId) },
-    { data: body, method: 'put' }
-  );
-};
-
-//////////////////////////////////////////////////////////////
-
-export const getPaymentGatewayError = (sessionResponse: Object) => {
-  if (sessionResponse && sessionResponse.status === 'fields_in_error') {
-    return ERROR_MESSAGES.PAYMENT_GATEWAY_FIELDS;
-  } else if (sessionResponse && sessionResponse.status === 'system_error') {
-    sentry.logError(sessionResponse);
-    return ERROR_MESSAGES.PAYMENT_GATEWAY_ERROR;
-  }
-  return null;
-};
-
-/**
- * Get a business nonce
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const getNonce = async (
-  {
-    amount,
-    businessId,
-    cardNumber: _cardNumber,
-    expiry,
-    cvc,
-    paymentProvider = PAYMENT_PROVIDERS.PAYMENT_CARD,
-    isSales = true,
-    isSelfCheckoutSession,
-    source = 'mastercard'
-  }: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  const cardNumber = _cardNumber ? _cardNumber.replace(/\s/g, '') : '';
-  const cardExpiryMonth = expiry ? expiry.split('/')[0].trim() : '';
-  const cardExpiryYear = expiry ? expiry.split('/')[1].trim() : '';
-  const cardSecurityCode = cvc;
-
-  let clientToken;
-  if (businessId && isSales) {
-    // $FlowFixMe
-    clientToken = await getBusinessSalesClientToken(businessId, isSelfCheckoutSession ? { tokenType: 'session' } : {});
-  } else if (businessId) {
-    // $FlowFixMe
-    clientToken = await getBusinessClientToken(
-      businessId,
-      source,
-      isSelfCheckoutSession ? { tokenType: 'session' } : {}
-    );
-  } else {
-    // $FlowFixMe
-    clientToken = await getClientToken(source, isSelfCheckoutSession ? { tokenType: 'session' } : {});
-  }
-
-  if (!clientToken.source) clientToken.source = source;
-
-  if (clientToken.source === 'mastercard') {
-    // $FlowFixMe
-    const paymentSession = HostedForm; // eslint-disable-line no-undef
-    if (!paymentSession) {
-      throw new Error(ERROR_MESSAGES.PAYMENT_GATEWAY_ERROR);
-    }
-    paymentSession.setMerchant(clientToken.merchantId);
-    const updateSessionResponse = await pify(paymentSession.updateSession, { errorFirst: false })(
-      clientToken.clientToken,
-      {
-        cardNumber,
-        cardExpiryMonth,
-        cardExpiryYear,
-        cardSecurityCode
-      }
-    );
-    if (getPaymentGatewayError(updateSessionResponse)) {
-      throw new Error(getPaymentGatewayError(updateSessionResponse));
-    }
-    return {
-      ...clientToken,
-      nonce: clientToken.clientToken,
-      sourceResponse: updateSessionResponse
-    };
-  }
-  if (clientToken.source === 'braintree') {
-    const clientInstance = await braintreeClient.create({ authorization: clientToken.clientToken });
-    let sourceResponse = {};
-
-    if (paymentProvider === PAYMENT_PROVIDERS.PAYMENT_CARD) {
-      sourceResponse = await clientInstance.request({
-        endpoint: 'payment_methods/credit_cards',
-        method: 'post',
-        data: {
-          creditCard: {
-            number: cardNumber,
-            expirationDate: `${cardExpiryMonth}/${cardExpiryYear}`,
-            cvv: cvc,
-            options: {
-              validate: false
-            }
-          }
-        }
-      });
-      return {
-        ...clientToken,
-        nonce: _get(sourceResponse, 'creditCards[0].nonce'),
-        sourceResponse: sourceResponse
-      };
-    }
-
-    if (paymentProvider === PAYMENT_PROVIDERS.GOOGLE_PAY && amount && _get(window, 'google.payments.api')) {
-      const paymentsClient = new window.google.payments.api.PaymentsClient({
-        environment: env.ENV_NAME === 'prod' || env.ENV_NAME === 'pre-prod' ? 'PRODUCTION' : 'TEST'
-      });
-      const googlePaymentInstance = await braintreeGooglePayment.create({
-        client: clientInstance,
-        googlePayVersion: 2,
-        googleMerchantId: env.GOOGLE_MERCHANT_ID
-      });
-      const response = await paymentsClient.isReadyToPay({
-        apiVersion: 2,
-        apiVersionMinor: 0,
-        allowedPaymentMethods: googlePaymentInstance.createPaymentDataRequest().allowedPaymentMethods
-      });
-      if (response.result) {
-        const paymentDataRequest = googlePaymentInstance.createPaymentDataRequest({
-          transactionInfo: {
-            currencyCode: 'AUD',
-            totalPriceStatus: 'FINAL',
-            totalPrice: amount.replace('$', '')
-          }
-        });
-        const cardPaymentMethod = paymentDataRequest.allowedPaymentMethods[0];
-        cardPaymentMethod.parameters.billingAddressRequired = false;
-
-        const paymentData = await paymentsClient.loadPaymentData(paymentDataRequest);
-        sourceResponse = await googlePaymentInstance.parseResponse(paymentData);
-
-        return {
-          ...clientToken,
-          nonce: sourceResponse.nonce,
-          sourceResponse: sourceResponse
-        };
-      }
-    }
-    if (paymentProvider === PAYMENT_PROVIDERS.APPLE_PAY) {
-      const applePayInstance = await braintreeApplePay.create({ client: clientInstance });
-      const paymentRequest = applePayInstance.createPaymentRequest({
-        total: {
-          label: 'Medipass Payment',
-          amount: amount.replace('$', '')
-        }
-      });
-      const canMakeApplePayment = await window.ApplePaySession.canMakePaymentsWithActiveCard(
-        applePayInstance.merchantIdentifier
-      );
-      return {
-        ...clientToken,
-        applePayInstance,
-        canMakeApplePayment,
-        paymentRequest
-      };
-    }
-  }
-  return clientToken;
-};

package/lib/resources/pms.js.flow

@@ -1,102 +0,0 @@
-// @flow
-
-import request from '../utils/request';
-import doesParamExist from '../utils/does-param-exist';
-import type { MedipassRequestOpts } from '../_types';
-
-const pathBusinessPmsPractices = businessId => `/businesses/${businessId}/pmspractices`;
-const pathBusinessPmsServices = businessId => `/businesses/${businessId}/pmsservices`;
-const pathBusinessPmsStaffMembers = businessId => `/businesses/${businessId}/pmsstaff`;
-
-/**
- * Get business PMS practices
- * @param {String} businessId - Business ID
- * @param {String} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusinessPMSPractices = async (
-  businessId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessPmsPractices(businessId) }, { method: 'get', params: query });
-};
-
-/**
- * Get business PMS services
- * @param {String} businessId - Business ID
- * @param {String} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusinessPMSServices = async (
-  businessId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessPmsServices(businessId) }, { method: 'get', params: query });
-};
-
-/**
- * Get business PMS staff
- * @param {String} businessId - Business ID
- * @param {String} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusinessPMSStaffMembers = async (
-  businessId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessPmsStaffMembers(businessId) }, { method: 'get', params: query });
-};
-
-/**
- * Import business PMS practice
- * @param {String} businessId - Business ID
- * @param {String} body - Request body
- * @param {Object} opts - Additional options
- */
-export const importBusinessPMSPractice = async (
-  businessId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: `${pathBusinessPmsPractices(businessId)}/import` }, { method: 'post', data: body });
-};
-
-/**
- * Import business PMS service
- * @param {String} businessId - Business ID
- * @param {String} body - Request body
- * @param {Object} opts - Additional options
- */
-export const importBusinessPMSService = async (
-  businessId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: `${pathBusinessPmsServices(businessId)}/import` }, { method: 'post', data: body });
-};
-
-/**
- * Import business PMS staff member
- * @param {String} businessId - Business ID
- * @param {String} body - Request body
- * @param {Object} opts - Additional options
- */
-export const importBusinessPMSStaffMember = async (
-  businessId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: `${pathBusinessPmsStaffMembers(businessId)}/import` },
-    { method: 'post', data: body }
-  );
-};

package/lib/resources/practice-profiles.js.flow

@@ -1,51 +0,0 @@
-// @flow
-
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-
-export const pathLinkPracticeProfile = (practiceProfileId: string) => `/practiceprofiles/${practiceProfileId}/link`;
-export const pathOrganisationPracticeProfiles = (organisationId: string) =>
-  `/organisations/${organisationId}/practiceprofiles`;
-export const pathPracticeProfile = (practiceProfileId: string) => `/practiceprofiles/${practiceProfileId}`;
-export const pathUnlinkPracticeProfile = (practiceProfileId: string) => `/practiceprofiles/${practiceProfileId}/unlink`;
-
-type PracticeProfilesQuery = {
-  practiceId?: string,
-  unlinkedOnly?: boolean,
-  from?: string,
-  to?: string,
-  sort?: string,
-  searchText?: string,
-  page?: number,
-  limit?: number
-};
-
-export const getOrganisationPracticeProfiles = (
-  organisationId: string,
-  query?: PracticeProfilesQuery,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ organisationId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathOrganisationPracticeProfiles(organisationId) }, { method: 'get', params: query });
-};
-
-export const getPracticeProfile = (practiceProfileId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ practiceProfileId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathPracticeProfile(practiceProfileId) }, { method: 'get' });
-};
-
-export const linkPracticeProfile = (
-  practiceProfileId: string,
-  practiceId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ practiceProfileId, practiceId }, opts.hyperMediaEndpoint);
-  const body = { practiceId };
-  return request({ ...opts, path: pathLinkPracticeProfile(practiceProfileId) }, { method: 'put', data: body });
-};
-
-export const unlinkPracticeProfile = (practiceProfileId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ practiceProfileId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathUnlinkPracticeProfile(practiceProfileId) }, { method: 'put' });
-};

package/lib/resources/practice-types.js.flow

@@ -1,14 +0,0 @@
-// @flow
-
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-
-const PATH__PRACTICE_TYPES = '/practicetypes';
-
-/**
- * Get practice types
- * @param {Object} opts - Additional options
- */
-export const getPracticeTypes = async (opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: PATH__PRACTICE_TYPES }, { method: 'get' });
-};