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

package/lib/resources/health-fund-settings.js.flow

@@ -1,104 +0,0 @@
-// @flow
-
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-
-const pathBusinessPracticeStaffMemberHealthFundSettings = (businessId, practiceId, staffId) =>
-  `/businesses/${businessId}/practices/${practiceId}/staff/${staffId}/healthfundsettings`;
-const pathHealthFundSettings = healthFundId => `/healthfunds/${healthFundId}/healthfundsettings`;
-const pathHealthFundSetting = (healthFundId, healthFundSettingId) =>
-  `/healthfunds/${healthFundId}/healthfundsettings/${healthFundSettingId}`;
-
-/**
- * Create a health fund setting
- * @param {String} healthFundId - Health fund ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const createHealthFundSetting = async (
-  healthFundId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = { trustedProviders: true }
-): Promise<Object> => {
-  doesParamExist({ healthFundId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: `${pathHealthFundSettings(healthFundId)}` },
-    {
-      method: 'post',
-      data: { enabled: true, ...body }
-    }
-  );
-};
-
-/**
- * Delete a health fund setting
- * @param {String} healthFundId - Health fund ID
- * @param {String} healthFundSettingId - Health fund setting ID
- * @param {Object} opts - Additional options
- */
-export const deleteHealthFundSetting = async (
-  healthFundId: string,
-  healthFundSettingId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundSetting(healthFundId, healthFundSettingId) }, { method: 'delete' });
-};
-
-/**
- * Get health fund settings
- * @param {String} healthFundId - Health fund ID
- * @param {Object} query - Query params
- * @param {Object} opts - Additional options
- */
-export const getHealthFundSettings = async (
-  healthFundId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = { trustedProviders: true }
-): Promise<Object> => {
-  doesParamExist({ healthFundId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundSettings(healthFundId) }, { method: 'get', params: query });
-};
-
-/**
- * Get business practice staff member health fund settings
- * @param {String} businessId - Business ID
- * @param {String} practiceId - Practice ID
- * @param {String} staffId - Staff ID
- * @param {Object} query - Query params
- * @param {Object} opts - Additional options
- */
-export const getBusinessPracticeStaffMemberHealthFundSettings = async (
-  businessId: string,
-  practiceId: string,
-  staffId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = { trustedProviders: true }
-): Promise<Object> => {
-  doesParamExist({ businessId, practiceId, staffId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathBusinessPracticeStaffMemberHealthFundSettings(businessId, practiceId, staffId) },
-    { method: 'get', params: query }
-  );
-};
-
-/**
- * Update a health fund setting
- * @param {String} memberId - Member ID
- * @param {String} healthFundAccountId - healthFundAccountId
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const updateHealthFundSetting = async (
-  healthFundId: string,
-  healthFundSettingId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, healthFundSettingId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathHealthFundSetting(healthFundId, healthFundSettingId) },
-    { method: 'put', data: body }
-  );
-};

package/lib/resources/healthfunds.js.flow

@@ -1,139 +0,0 @@
-// @flow
-
-import { FUNDERS } from '@medipass/utils/constants';
-
-import type { MedipassRequestOpts } from '../_types';
-import medipassWebSdk from '../index';
-import request from '../utils/request';
-import doesParamExist from '../utils/does-param-exist';
-
-const PATH__HEALTH_FUNDS = '/healthfunds';
-const pathHealthFund = healthFundId => `/healthfunds/${healthFundId}`;
-const pathHealthFundVerifyMember = healthFundId => `/healthfunds/${healthFundId}/verifymember`;
-const pathOrganisationHealthFunds = organisationId => `/organisations/${organisationId}/healthfunds`;
-const pathHealthFundsByAccountId = accountId => `/accounts/${accountId}/healthfunds`;
-const pathBusinessHealthFunds = businessId => `/businesses/${businessId}/healthfunds`;
-
-/**
- * Get health funds for account
- * @param {Object} opts - Additional options
- */
-export const getHealthFundsForAccount = async (opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  const accountId = medipassWebSdk.accountId || '';
-  doesParamExist({ accountId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundsByAccountId(accountId) }, { method: 'get' });
-};
-
-/**
- * Get health funds for business
- * @param {String} businessId - Business ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusinessHealthFunds = async (
-  businessId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessHealthFunds(businessId) }, { method: 'get', params: query });
-};
-
-/**
- * Get health funds
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getHealthFunds = async (query?: Object, opts?: MedipassRequestOpts = {}): Promise<Array<Object>> => {
-  return request({ ...opts, path: PATH__HEALTH_FUNDS }, { method: 'get', params: query, tokenType: opts.tokenType });
-};
-
-/**
- * Get health funds by organisation
- * @param {String} organisationId - Organisation ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getOrganisationHealthFunds = async (
-  organisationId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ organisationId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathOrganisationHealthFunds(organisationId) }, { method: 'get', params: query });
-};
-
-/**
- * Create health fund
- *
- * @param {Object} body - Health fund details
- * @param {Object} opts - Additional options
- */
-export const createHealthFund = async (body: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: PATH__HEALTH_FUNDS }, { method: 'post', data: body });
-};
-
-/**
- * Get health fund
- * @param {String} healthFundId - Health fund ID
- * @param {Object} opts - Additional options
- */
-export const getHealthFund = async (healthFundId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ healthFundId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFund(healthFundId) }, { method: 'get' });
-};
-
-/**
- * Update health fund
- * @param {Object} healthFundId - Health fund ID
- * @param {Object} body - Health fund details
- * @param {Object} opts - Additional options
- */
-export const updateHealthFund = async (
-  healthFundId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFund(healthFundId) }, { method: 'put', data: body });
-};
-
-/**
- * Delete health fund
- * @param {Object} healthFundId - Health fund ID
- * @param {Object} opts - Additional options
- */
-export const deleteHealthFund = async (healthFundId: string, opts?: MedipassRequestOpts = {}): Promise<boolean> => {
-  doesParamExist({ healthFundId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFund(healthFundId) }, { method: 'delete' });
-};
-
-/**
- * Get Medicare health fund
- * @param {Object} opts - Additional options
- */
-export const getMedicareHealthFund = async (opts?: MedipassRequestOpts = {}): Promise<?Object> => {
-  const funders: Array<Object> = await medipassWebSdk.funders.getFunders(opts);
-  const medicareFunder = funders.find(funder => funder.code === FUNDERS.MEDICARE);
-  if (!medicareFunder) return null;
-  const healthFunds = await getHealthFunds({ funderId: medicareFunder._id }, opts);
-  return healthFunds[0];
-};
-
-/**
- * Verify member by health fund
- * @param {String} healthFundId - Health fund ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const verifyMember = async (
-  healthFundId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, body }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: `${pathHealthFundVerifyMember(healthFundId)}` },
-    { method: 'post', data: body, tokenType: opts.tokenType }
-  );
-};

package/lib/resources/icditems.js.flow

@@ -1,36 +0,0 @@
-// @flow
-
-import type { MedipassRequestOpts } from '../_types';
-import medipassWebSdk from '../index';
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-
-const pathICDItems = '/icditems';
-const pathModalityICDItems = modalityId => `/modalities/${modalityId}/icditems`;
-
-/**
- * Get ICD items
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getICDItems = async (
-  query?: Object = {},
-  opts?: MedipassRequestOpts = { ver: medipassWebSdk.defaultVersion }
-): Promise<Object> => {
-  return request({ ...opts, path: pathICDItems }, { method: 'get', params: query });
-};
-
-/**
- * Get modality ICD items
- * @param {Object} modalityId - Modality ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getModalityICDItems = async (
-  modalityId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = { ver: medipassWebSdk.defaultVersion }
-): Promise<Object> => {
-  doesParamExist({ modalityId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathModalityICDItems(modalityId) }, { method: 'get', params: query });
-};

package/lib/resources/invoice-scans.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 pathInvoiceScansByBusinessId = (businessId: string) => `/businesses/${businessId}/invoicescans`;
-export const pathUploadUrlByBusinessId = (businessId: string) => `/businesses/${businessId}/invoicescans/uploadurl`;
-export const pathInvoiceScanByInvoiceScanId = (businessId: string, invoiceScanId: string) =>
-  `/businesses/${businessId}/invoicescans/${invoiceScanId}`;
-
-/**
- * Create an invoice scan
- * @param {String} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const createInvoiceScan = async (
-  businessId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathInvoiceScansByBusinessId(businessId) }, { method: 'post', data: body });
-};
-
-/**
- * Get invoice scan by invoice scan id
- * @param {String} businessId - Business ID
- * @param {String} invoiceScanId - Invoice Scan ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const getInvoiceScan = async (
-  businessId: string,
-  invoiceScanId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, invoiceScanId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathInvoiceScanByInvoiceScanId(businessId, invoiceScanId) }, { method: 'get' });
-};
-
-/**
- * Get url to upload a file associated to a invoice scan
- * @param {String} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const getInvoiceScanUploadUrl = (
-  businessId: string,
-  query: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathUploadUrlByBusinessId(businessId) }, { method: 'get', params: query });
-};

package/lib/resources/jhcs.js.flow

@@ -1,20 +0,0 @@
-// @flow
-
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { MedipassRequestOpts, PaginatedQuery } from '../_types';
-
-export const PATH__JHCS = `/jointhealthcentres`;
-export const pathJHC = (jhcId: string) => `/jointhealthcentres/${jhcId}`;
-
-export const getJHC = (jhcId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ jhcId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathJHC(jhcId) }, { method: 'get' });
-};
-
-export const getJHCs = (
-  query?: ?{ ...PaginatedQuery, searchText?: string },
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  return request({ ...opts, path: PATH__JHCS }, { method: 'get', params: query });
-};

package/lib/resources/kyc.js.flow

@@ -1,216 +0,0 @@
-// @flow
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-
-export const pathBusinessKyc = (businessId: string) => `/businesses/${businessId}/kyc`;
-export const pathPracticeKyc = (businessId: string, practiceId: string) =>
-  `/businesses/${businessId}/practices/${practiceId}/kyc`;
-export const pathBusinessCbo = (businessId: string) => `/businesses/${businessId}/cbo`;
-export const pathBusinessKycVerify = (businessId: string) => `/businesses/${businessId}/kycverify`;
-export const pathBusinessKycUnverify = (businessId: string) => `/businesses/${businessId}/kycunverify`;
-export const pathPracticeKycVerify = (businessId: string, practiceId: string) =>
-  `/businesses/${businessId}/practices/${practiceId}/kycverify`;
-export const pathPracticeKycUnverify = (businessId: string, practiceId: string) =>
-  `/businesses/${businessId}/practices/${practiceId}/kycunverify`;
-export const pathBusinessVerifyBeneficialOwner = (businessId: string) =>
-  `/businesses/${businessId}/verifybeneficialowner`;
-export const pathRequestVerificationSupport = (businessId: string) =>
-  `/businesses/${businessId}/kycrequestverificationsupport`;
-export const pathBusinessAddBeneficialOwner = (businessId: string) => `/businesses/${businessId}/beneficialowners`;
-export const pathBusinessRemoveBeneficialOwner = (businessId: string, beneficialOwnerId: string) =>
-  `/businesses/${businessId}/beneficialowners/${beneficialOwnerId}`;
-export const pathResumeComplexVerification = (businessId: string) =>
-  `/businesses/${businessId}/resumecomplexverification`;
-export const pathGetTrustDocumentUploadUrl = (businessId: string) => `/businesses/${businessId}/uploadurl`;
-
-/**
- * Get business kyc
- * @param {String} businessId - Business ID
- * @param {Object} opts - Additional options
- */
-export const getBusinessKyc = (businessId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessKyc(businessId) }, { method: 'get' });
-};
-
-/**
- * Get practice kyc
- * @param {String} businessId - Business ID
- * @param {String} practiceId - Practice ID
- * @param {Object} opts - Additional options
- */
-export const getPracticeKyc = (
-  businessId: string,
-  practiceId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, practiceId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathPracticeKyc(businessId, practiceId) }, { method: 'get' });
-};
-
-/**
- * Update business kyc
- * @param {String} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const updateBusinessKyc = (
-  businessId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessKyc(businessId) }, { method: 'put', data: body });
-};
-
-/**
- * Get business cbo
- * @param {String} businessId - Business ID
- * @param {Object} query - query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusinessCbo = (businessId: string, query: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessCbo(businessId) }, { method: 'get', params: query });
-};
-
-/**
- * Verify business kyc
- * @param {String} businessId - Business ID
- * @param {Object} opts - Additional options
- */
-export const verifyBusinessKyc = (businessId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessKycVerify(businessId) }, { method: 'post' });
-};
-
-/**
- * Verify practice kyc
- * @param {String} businessId - Business ID
- * @param {String} practiceId - Practice ID
- * @param {Object} opts - Additional options
- */
-export const verifyPracticeKyc = (
-  businessId: string,
-  practiceId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, practiceId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathPracticeKycVerify(businessId, practiceId) }, { method: 'post', data: body });
-};
-
-/**
- * Unverify business kyc
- * @param {String} businessId - Business ID
- * @param {Object} opts - Additional options
- */
-export const unverifyBusinessKyc = (businessId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessKycUnverify(businessId) }, { method: 'post' });
-};
-
-/**
- * Unverify practice kyc
- * @param {String} businessId - Business ID
- * @param {String} practiceId - Practice ID
- * @param {Object} opts - Additional options
- */
-export const unverifyPracticeKyc = (
-  businessId: string,
-  practiceId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, practiceId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathPracticeKycUnverify(businessId, practiceId) }, { method: 'post' });
-};
-
-/**
- * Verify business beneficial owner
- * @param {String} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const verifyBusinessBeneficialOwner = (
-  businessId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessVerifyBeneficialOwner(businessId) }, { method: 'post', data: body });
-};
-
-/**
- * Send support email for help on Medipass's KYC process
- * @param {String} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const requestVerificationSupport = (
-  businessId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathRequestVerificationSupport(businessId) }, { method: 'post', data: body });
-};
-
-/**
- * Add beneficial owner to a business
- * @param {String} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const addBeneficialOwner = (
-  businessId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessAddBeneficialOwner(businessId) }, { method: 'post', data: body });
-};
-
-/**
- * Remove beneficial owner to a business
- * @param {String} businessId - Business ID
- * @param {String} beneficialOwnerId - Beneficial Owner ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const removeBeneficialOwner = (
-  businessId: string,
-  beneficialOwnerId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathBusinessRemoveBeneficialOwner(businessId, beneficialOwnerId) },
-    { method: 'delete' }
-  );
-};
-
-/**
- * Enable Connect user to resume a complex KYC process
- * @param {String} businessId - Business ID
- * @param {Object} opts - Additional options
- */
-export const resumeComplexVerification = (businessId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathResumeComplexVerification(businessId) }, { method: 'post' });
-};
-
-/**
- * Get url to upload a trust document associated to a kyc
- * @param {String} businessId - business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const getTrustDocumentUploadUrl = (
-  businessId: string,
-  query: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathGetTrustDocumentUploadUrl(businessId) }, { method: 'get', params: query });
-};

package/lib/resources/logs.js.flow

@@ -1,32 +0,0 @@
-// @flow
-
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-
-export const pathLog = () => `/logs`;
-export const pathBusinessLog = (businessId: string) => `/businesses/${businessId}/logs`;
-
-/**
- * Create a log
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const createLog = (body?: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: pathLog() }, { method: 'post', data: body });
-};
-
-/**
- * Create a business log
- * @param {string} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const createBusinessLog = (
-  businessId: string,
-  body?: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId });
-  return request({ ...opts, path: pathBusinessLog(businessId) }, { method: 'post', data: body });
-};