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

package/lib/resources/auth.js.flow

@@ -1,185 +0,0 @@
-// @flow
-import _omitBy from 'lodash/omitBy';
-import _isEmpty from 'lodash/isEmpty';
-
-import type { MedipassRequestOpts } from '../_types';
-import medipassWebSdk from '../index';
-import storage from '../services/storage';
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import * as members from './members';
-
-const PATH__AUTH = '/auth';
-const PATH__OTK = '/otk';
-const PATH__AUTH_TOKEN = '/auth/token';
-const pathImpersonateAccount = accountId => `/auth/impersonate/${accountId}`;
-const pathAuthy = (accountId: string) => `/accounts/${accountId}/authy`;
-const pathAuthyVerify = (accountId: string) => `/accounts/${accountId}/authy/verify`;
-
-const HEADER__SUPER_ADMIN = 'x-super-admin';
-
-const setupAccountResources = async (account: Object) => {
-  storage.onboardingStatus.remove();
-
-  medipassWebSdk.setAccount(account);
-
-  // Check if the account has a member attached to it.
-  const ownerMemberId = account.ownerMemberId;
-  if (ownerMemberId) {
-    const member = await members.getMember(ownerMemberId);
-    medipassWebSdk.setMember(member);
-    return { ...account, _member: member };
-  }
-
-  return account;
-};
-
-/**
- * Log in a user
- * @param {String} email - Email
- * @param {String} password - Password
- * @param {{ otkCode: ?String, accountType: String }} body - The request body
- * @param {{ ver: ?String }} opts - Additional options
- */
-export const login = async (
-  email?: ?string,
-  password?: ?string,
-  body?: Object = {},
-  opts?: MedipassRequestOpts = { asSuperAdmin: false }
-): Promise<Object> => {
-  const data = {
-    email,
-    ...body
-  };
-  if (password) {
-    data.password = password;
-  }
-
-  // $FlowFixMe
-  const res = await request({ ...opts, path: PATH__AUTH, getFullResponse: true }, { method: 'post', data });
-  const isSuperAdmin = res.headers[HEADER__SUPER_ADMIN];
-
-  if (opts.asSuperAdmin && !isSuperAdmin) {
-    medipassWebSdk.clearTokens();
-    throw { response: 'You need to be a super admin to log in!' }; // eslint-disable-line no-throw-literal
-  }
-
-  if (isSuperAdmin) {
-    medipassWebSdk.isSuperAdmin = isSuperAdmin;
-    storage.set('isSuperAdmin', isSuperAdmin);
-  }
-
-  const account = await setupAccountResources(res.data);
-  return account;
-};
-
-/**
- * Login with token
- * @param {String} accountId - Account ID
- * @param {String} token - JWT
- */
-export const loginWithToken = async (token: string, accountId: string) => {
-  medipassWebSdk.setToken(token);
-  const account = await medipassWebSdk.accounts.getAccount(accountId);
-  const newAccount = await setupAccountResources(account);
-  return newAccount;
-};
-
-/**
- * Impersonate a user
- * @param {String} accountId - Account ID
- * @param {Object} opts - Additional options
- */
-export const impersonate = async (accountId: string, opts?: MedipassRequestOpts = {}) => {
-  doesParamExist({ accountId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, getFullResponse: true, path: pathImpersonateAccount(accountId) }, { method: 'post' });
-};
-
-/**
- * Log out a user
- * @param {Object} opts - Additional options
- */
-export const logout = async (opts?: MedipassRequestOpts): Promise<Object> => {
-  const res = await request({ ...opts, getFullResponse: true, path: PATH__AUTH }, { method: 'delete' });
-  medipassWebSdk.removeStorage();
-  return res;
-};
-
-/**
- * Object OTK
- * @param {String} email - Email address
- * @param {String} accountId - Account ID
- * @param {Object} opts - Additional options
- */
-export const requestOtk = async (
-  email?: ?string,
-  accountId?: ?string,
-  requestBody?: ?Object,
-  opts?: MedipassRequestOpts
-): Promise<Object> => {
-  const body = _omitBy(
-    {
-      email,
-      accountId,
-      ...requestBody
-    },
-    _isEmpty
-  );
-
-  const res = await request({ ...opts, getFullResponse: true, path: PATH__OTK }, { method: 'post', data: body });
-  return res;
-};
-
-/**
- * Generate Authy
- * @param {String} accountId - Account ID
- * @param {Object} opts - Additional options
- */
-export const generateAuthy = async (accountId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ accountId }, opts.hyperMediaEndpoint);
-  const res = await request({ ...opts, path: pathAuthy(accountId), getFullResponse: true }, { method: 'post' });
-  return res;
-};
-
-/**
- * Remove Authy
- * @param {String} accountId - Account ID
- * @param {Object} opts - Additional options
- */
-export const removeAuthy = async (accountId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ accountId }, opts.hyperMediaEndpoint);
-  const res = await request({ ...opts, path: pathAuthy(accountId), getFullResponse: true }, { method: 'delete' });
-  return res;
-};
-
-/**
- * Verify Authy
- * @param {String} accountId - Account ID
- * @param {String} token - Authy Token
- * @param {Object} opts - Additional options
- */
-export const verifyAuthy = async (
-  accountId: string,
-  token: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ accountId }, opts.hyperMediaEndpoint);
-  const res = await request(
-    { ...opts, path: pathAuthyVerify(accountId), getFullResponse: true },
-    { method: 'post', data: { token } }
-  );
-  return res;
-};
-
-/**
- * Create a short lived token
- * @param {String} apiKey - API Key
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const createShortLivedToken = async (apiKey: string, body: Object, opts?: MedipassRequestOpts = {}) => {
-  doesParamExist({ apiKey }, opts.hyperMediaEndpoint);
-  medipassWebSdk.setToken(`Bearer ${apiKey}`);
-  const res = await request({ ...opts, path: PATH__AUTH_TOKEN }, { method: 'post', data: body });
-  return res;
-};

package/lib/resources/bulk-submits.js.flow

@@ -1,43 +0,0 @@
-// @flow
-
-import request from '../utils/request';
-import doesParamExist from '../utils/does-param-exist';
-import type { MedipassRequestOpts } from '../_types';
-
-export const pathSubmitDraftInvoices = (businessId: string) => `/businesses/${businessId}/bulksubmits`;
-export const pathGetDraftProgressStatus = (businessId: string, bulkSubmitId: string) =>
-  `/businesses/${businessId}/bulksubmits/${bulkSubmitId}`;
-
-/**
- * Bulk submission of one or more draft invoices.
- * @param {String} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const submitDraftInvoices = async (
-  businessId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathSubmitDraftInvoices(businessId) }, { method: 'post', data: body });
-};
-
-/**
- * Get draft invocies progress status
- * @param {String} businessId - Business ID
- * @param {String} bulkSubmitId - Bulk Submit ID
- * @param {Object} opts - Additional options
- */
-export const getDraftProgressStatus = async (
-  businessId: string,
-  bulkSubmitId: string,
-  query: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, bulkSubmitId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathGetDraftProgressStatus(businessId, bulkSubmitId) },
-    { method: 'get', params: query }
-  );
-};

package/lib/resources/bulk-uploads.js.flow

@@ -1,56 +0,0 @@
-// @flow
-
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-
-export const pathBusinessBulkUploads = (businessId: string) => `/businesses/${businessId}/bulkuploads`;
-export const pathBusinessBulkUpload = (businessId: string, bulkUploadId: string) =>
-  `/businesses/${businessId}/bulkuploads/${bulkUploadId}`;
-export const pathBusinessBulkUploadUrl = (businessId: string) => `/businesses/${businessId}/bulkuploads/uploadurl`;
-
-/**
- * Create a bulk upload from file
- * @param {string} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const createBulkUpload = (
-  businessId: string,
-  body?: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId });
-  return request({ ...opts, path: pathBusinessBulkUploads(businessId) }, { method: 'post', data: body });
-};
-
-/**
- * Get a bulk upload
- * @param {string} businessId - Business ID
- * @param {string} bulkUploadId - Bulk upload ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const getBulkUpload = (
-  businessId: string,
-  bulkUploadId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, bulkUploadId });
-  return request({ ...opts, path: pathBusinessBulkUpload(businessId, bulkUploadId) }, { method: 'get' });
-};
-
-/**
- * Get a bulk upload url
- * @param {string} businessId - Business ID
- * @param {Object} query - Query params
- * @param {Object} opts - Additional options
- */
-export const getBulkUploadUrl = (
-  businessId: string,
-  query?: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId });
-  return request({ ...opts, path: pathBusinessBulkUploadUrl(businessId) }, { method: 'get', params: query });
-};

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

@@ -1,45 +0,0 @@
-// @flow
-
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-
-export const pathLinkBusinessProfile = (businessProfileId: string) => `/businessprofiles/${businessProfileId}/link`;
-export const pathUnlinkBusinessProfile = (businessProfileId: string) => `/businessprofiles/${businessProfileId}/unlink`;
-export const pathOrganisationBusinessProfiles = (organisationId: string) =>
-  `/organisations/${organisationId}/businessprofiles`;
-
-type BusinessProfilesQuery = {
-  businessId?: string,
-  unlinkedOnly?: boolean,
-  from?: string,
-  to?: string,
-  sort?: string,
-  searchText?: string,
-  page?: number,
-  limit?: number
-};
-
-export const getOrganisationBusinessProfiles = (
-  organisationId: string,
-  query?: BusinessProfilesQuery,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ organisationId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathOrganisationBusinessProfiles(organisationId) }, { method: 'get', params: query });
-};
-
-export const linkBusinessProfile = (
-  businessProfileId: string,
-  businessId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessProfileId, businessId }, opts.hyperMediaEndpoint);
-  const body = { businessId };
-  return request({ ...opts, path: pathLinkBusinessProfile(businessProfileId) }, { method: 'put', data: body });
-};
-
-export const unlinkBusinessProfile = (businessProfileId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ businessProfileId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathUnlinkBusinessProfile(businessProfileId) }, { method: 'put' });
-};

package/lib/resources/businesses.js.flow

@@ -1,267 +0,0 @@
-// @flow
-
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-
-const PATH__BUSINESSES = '/businesses';
-const PATH__MY_BUSINESSES = '/businesses/me';
-const pathBusiness = businessId => `/businesses/${businessId}`;
-
-const pathAccountsBusinesses = accountId => `/accounts/${accountId}/businesses`;
-const pathBusinessOnboardingQuestions = businessId => `/businesses/${businessId}/onboarding/emailquestions`;
-const pathBusinessSendEmails = businessId => `/businesses/${businessId}/sendemail`;
-const pathOrganisationBusiness = organisationId => `/organisations/${organisationId}/businesses`;
-const pathVerifyMedicare = businessId => `/businesses/${businessId}/medicare/verify`;
-// This can be removed once we migrate to the new medicare service
-const oldPathVerifyDVA = businessId => `/businesses/${businessId}/dva/pvv/verify`;
-const pathVerifyDVA = businessId => `/businesses/${businessId}/dva/verify`;
-const pathVerifyIcare = businessId => `/businesses/${businessId}/icare/verify`;
-const pathVerifyComcare = (businessId, staffId, providerSetItemId) =>
-  `/businesses/${businessId}/staff/${staffId}/providersetitems/${providerSetItemId}/comcare/verify`;
-const pathCreateSupportNote = businessId => `/businesses/${businessId}/supportnotes`;
-const pathBsbDetails = businessId => `/businesses/${businessId}/bsbs`;
-
-/**
- * Create businesses
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const createBusiness = (body: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: PATH__BUSINESSES }, { method: 'post', data: body });
-};
-
-/**
- * Create organisation businesses
- * @param {String} organisationId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const createOrganisationBusiness = (
-  organisationId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ organisationId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathOrganisationBusiness(organisationId) }, { method: 'post', data: body });
-};
-
-/**
- * Delete business
- * @param {String} businessId - Business ID
- * @param {Object} opts - Additional options
- */
-export const deleteBusiness = (businessId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusiness(businessId) }, { method: 'delete' });
-};
-
-/**
- * Email business setup questions to support
- * @param {Object} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const emailBusinessOnboardingQuestions = (
-  businessId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessOnboardingQuestions(businessId) }, { method: 'post', data: body });
-};
-
-/**
- * Get business
- * @param {String} businessId - Business ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusiness = (
-  businessId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusiness(businessId) }, { method: 'get', params: query });
-};
-
-/**
- * Get businesses
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusinesses = (query?: Object = {}, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: PATH__BUSINESSES }, { method: 'get', params: query });
-};
-
-/**
- * Get businesses
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getMyBusinesses = (query?: Object = {}, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: PATH__MY_BUSINESSES }, { method: 'get', params: query });
-};
-
-/**
- * Get business PDFs
- * @param {String} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const getBusinessPDFs = (businessId: string, body: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: `${pathBusiness(businessId)}/pdfs` },
-    { method: 'post', data: body, responseType: 'arraybuffer' }
-  );
-};
-
-/**
- * Get accounts businesses
- * @param {String} accountId - Organisation ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getAccountsBusinesses = (
-  accountId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ accountId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathAccountsBusinesses(accountId) }, { method: 'get', params: query });
-};
-
-/**
- * Get organisation businesses
- * @param {String} organisationId - Organisation ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getOrganisationBusinesses = (
-  organisationId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ organisationId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathOrganisationBusiness(organisationId) }, { method: 'get', params: query });
-};
-
-/**
- * Update businesses
- * @param {String} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const updateBusiness = (businessId: string, body: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusiness(businessId) }, { method: 'put', data: body });
-};
-
-/**
- * Verify Medicare
- * @param {String} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const verifyMedicare = (businessId: string, body: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathVerifyMedicare(businessId) }, { method: 'post', data: body });
-};
-
-/**
- * Old verify DVA - This can be removed once we migrate to the new medicare service
- * @param {String} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const oldVerifyDVA = (businessId: string, body: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: oldPathVerifyDVA(businessId) }, { method: 'post', data: body });
-};
-
-/**
- * Verify DVA
- * @param {String} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const verifyDVA = (businessId: string, body: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathVerifyDVA(businessId) }, { method: 'post', data: body });
-};
-
-/**
- * Verify icare
- * @param {String} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const verifyIcare = (businessId: string, body: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathVerifyIcare(businessId) }, { method: 'post', data: body });
-};
-
-/**
- * Verify Comcare claim number
- * @param {String} businessId - Business ID
- * @param {String} staffId - Staff ID
- * @param {String} providerSetItemId - Provider set item ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const verifyComcare = (
-  businessId: string,
-  staffId: string,
-  providerSetItemId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, staffId, providerSetItemId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathVerifyComcare(businessId, staffId, providerSetItemId) },
-    { method: 'post', data: body }
-  );
-};
-
-/**
- * Create business support note
- * @param {String} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const createSupportNote = (
-  businessId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathCreateSupportNote(businessId) }, { method: 'post', data: body });
-};
-
-/**
- * Get bank state branch (BSB) details
- * @param {String} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const getBsbDetails = (businessId: string, query: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBsbDetails(businessId) }, { method: 'get', params: query });
-};
-
-/**
- * Send email to business
- * @param {Object} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const sendBusinessEmail = (
-  businessId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessSendEmails(businessId) }, { method: 'post', data: body });
-};

package/lib/resources/claim-items.js.flow

@@ -1,76 +0,0 @@
-// @flow
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-
-const pathBusinessClaimItems = businessId => `/businesses/${businessId}/claimitems`;
-const pathBusinessClaimItem = (businessId, claimItemId) => `/businesses/${businessId}/claimitems/${claimItemId}`;
-const pathHealthFundClaimItems = healthFundId => `/healthfunds/${healthFundId}/claimitems`;
-const pathHealthFundClaimItem = (healthFundId, claimItemId) => `/healthfunds/${healthFundId}/claimitems/${claimItemId}`;
-
-/**
- * Get business claim items
- * @param {String} businessId - Business ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusinessClaimItems = async (
-  businessId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessClaimItems(businessId) }, { method: 'get', params: query });
-};
-
-/**
- * Get business claim item
- * @param {String} businessId - Business ID
- * @param {String} claimItemId - Claim item ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusinessClaimItem = async (
-  businessId: string,
-  claimItemId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, claimItemId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessClaimItem(businessId, claimItemId) }, { method: 'get', params: query });
-};
-
-/**
- * Get health fund claim items
- * @param {String} healthFundId - Health fund ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getHealthFundClaimItems = async (
-  healthFundId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundClaimItems(healthFundId) }, { method: 'get', params: query });
-};
-
-/**
- * Get health fund claim item
- * @param {String} healthFundId - Health fund ID
- * @param {String} claimItemId - Health fund ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getHealthFundClaimItem = async (
-  healthFundId: string,
-  claimItemId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, claimItemId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathHealthFundClaimItem(healthFundId, claimItemId) },
-    { method: 'get', params: query }
-  );
-};