@medipass/web-sdk 11.38.1-feature-eclipse-reporting.0 → 11.38.1-feature-typescript-claudia.2

package/lib/resources/accounts.js.flow

@@ -1,445 +0,0 @@
-// @flow
-import _get from 'lodash/get';
-import sdk from '../index';
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-
-const PATH__ACCOUNTS = '/accounts';
-const pathAccountsByAccountId = accountId => `/accounts/${accountId}`;
-const pathAccountExists = () => `/accounts/exists`;
-const pathAccountRolesByAccountId = accountId => `/accounts/${accountId}/roles`;
-const pathAccountSecretKeysByAccountId = accountId => `/accounts/${accountId}/secretkeys`;
-const pathAccountSecretKey = (accountId, secretKey) => `/accounts/${accountId}/secretkeys/${secretKey}`;
-const pathAccountTransactions = accountId => `/accounts/${accountId}/transactions`;
-const pathBusinessStaffAccount = (businessId, staffId) => `/businesses/${businessId}/staff/${staffId}/account`;
-const pathChangePassword = () => `/accounts/changepassword`;
-const pathEnableAccount = accountId => `/accounts/${accountId}/enable`;
-const pathDisableAccount = accountId => `/accounts/${accountId}/disable`;
-const pathRequestVerifyAccount = accountId => `/accounts/${accountId}/verify/request`;
-const pathHealthFundAccounts = healthFundId => `/healthfunds/${healthFundId}/accounts`;
-const pathHealthFundAccount = (healthFundId, accountId) => `/healthfunds/${healthFundId}/accounts/${accountId}`;
-const pathOrganisationAccounts = organisationId => `/organisations/${organisationId}/accounts`;
-const pathAccountPractices = accountId => `/accounts/${accountId}/practices`;
-const PATH__ACCEPT_ACCOUNT_INVITE = '/accounts/invites/accept';
-const PATH__REQUEST_ACCOUNT_RESET = '/accounts/reset/request';
-const PATH__REQUEST_PASSWORD_RESET = '/accounts/reset/password/request';
-const PATH__REQUEST_MOBILE_RESET = '/accounts/reset/mobile/request';
-const PATH__ACCOUNT_RESET = '/accounts/reset';
-const PATH__ACCOUNT_PASSWORD_RESET = '/accounts/reset/password';
-const PATH__ACCOUNT_MOBILE_RESET = '/accounts/reset/mobile';
-const PATH__ACCOUNT_VERIFY = '/accounts/verify';
-const PATH__SIGN_UP = '/signup';
-
-/**
- * Create account secret key
- * @param {String} accountId - Account ID
- * @param {Object} opts - Additional options
- */
-export const createAccountSecretKey = async (accountId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ accountId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathAccountSecretKeysByAccountId(accountId) }, { method: 'post' });
-};
-
-/**
- * Create organisation account
- * @param {String} organisationId - Organisation ID
- * @param {Object} body - Response body
- * @param {Object} opts - Additional options
- */
-export const createOrganisationAccount = async (
-  organisationId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ organisationId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathOrganisationAccounts(organisationId) }, { method: 'post', data: body });
-};
-
-/**
- * Delete account secret key
- * @param {String} accountId - Account ID
- * @param {String} secretKey - Secret Key
- * @param {Object} opts - Additional options
- */
-export const deleteAccountSecretKey = async (
-  accountId: string,
-  secretKey: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ accountId, secretKey }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathAccountSecretKey(accountId, secretKey) }, { method: 'delete' });
-};
-
-/**
- * Delete account
- * @param {String} accountId - Account ID
- * @param {Object} opts - Additional options
- */
-export const deleteAccount = async (accountId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ accountId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathAccountsByAccountId(accountId) }, { method: 'delete' });
-};
-
-/**
- * Disable account
- * @param {String} accountId - Account ID
- * @param {Object} opts - Additional options
- */
-export const disableAccount = async (accountId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ accountId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathDisableAccount(accountId) }, { method: 'put' });
-};
-
-/**
- * Enable account
- * @param {String} accountId - Account ID
- * @param {Object} opts - Additional options
- */
-export const enableAccount = async (accountId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ accountId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathEnableAccount(accountId) }, { method: 'put' });
-};
-
-/**
- * Request reset for account # DEPRECATED
- * @param {String} email - Account email address
- * @param {String} accountType - Account type (business, consumer, healthfund)
- * @param {Object} opts - Additional options
- */
-export const requestAccountReset = async (
-  email: string,
-  accountType: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  return request({ ...opts, path: PATH__REQUEST_ACCOUNT_RESET }, { method: 'post', data: { email, accountType } });
-};
-
-/**
- * Request password reset for username-based Medipass accounts
- * @param {Object} opts - Account ID or email
- * @param {String} accountType - Account type (business, consumer, healthfund). Will fail for consumer account.
- * @param {Object} opts - Additional options
- */
-export const requestPasswordReset = async (
-  { accountId, email }: { accountId?: ?string, email?: ?string },
-  accountType: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  let data = { accountType };
-  if (email) {
-    data = { ...data, email };
-  } else if (accountId) {
-    data = { ...data, accountId };
-  }
-  return request({ ...opts, path: PATH__REQUEST_PASSWORD_RESET }, { method: 'post', data });
-};
-
-/**
- * Request mobile reset for mobile-based Medipass accounts
- * @param {Object} opts - Account ID or mobile
- * @param {String} accountType - Account type (business, consumer, healthfund). Will fail for non consumer accounts.
- * @param {Object} opts - Additional options
- */
-export const requestMobileReset = async (
-  { accountId, email }: { accountId?: ?string, email?: ?string },
-  accountType: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  let data = { accountType };
-  if (email) {
-    data = { ...data, email };
-  } else if (accountId) {
-    data = { ...data, accountId };
-  }
-  return request({ ...opts, path: PATH__REQUEST_MOBILE_RESET }, { method: 'post', data });
-};
-
-/**
- * Reset an account # DEPRECATED
- * @param {Object} body - Object body
- * @param {Object} opts - Additional options
- */
-export const resetAccount = async (body: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: PATH__ACCOUNT_RESET }, { method: 'post', data: body });
-};
-
-/**
- * Reset a password for username-based Medipass accounts
- * @param {Object} body - Object body
- * @param {Object} opts - Additional options
- */
-export const resetPassword = async (body: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: PATH__ACCOUNT_PASSWORD_RESET }, { method: 'post', data: body });
-};
-
-/**
- * Reset a mobile number for mobile-based Medipass accounts
- * @param {Object} body - Object body
- * @param {Object} opts - Additional options
- */
-export const resetMobile = async (body: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: PATH__ACCOUNT_MOBILE_RESET }, { method: 'post', data: body });
-};
-
-/**
- * Verify an account
- * @param {Object} body - Object body
- * @param {Object} opts - Additional options
- */
-export const verifyAccount = async (body: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: PATH__ACCOUNT_VERIFY }, { method: 'post', data: body });
-};
-
-/**
- * Get accounts
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getAccounts = async (query?: Object = {}, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: PATH__ACCOUNTS }, { method: 'get', params: query });
-};
-
-/**
- * Get health fund account
- * @param {String} healthFundId - The health fund ID
- * @param {String} accountId - The account ID
- * @param {Object} opts - Additional options
- */
-export const getHealthFundAccount = async (
-  healthFundId: string,
-  accountId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ accountId, healthFundId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundAccount(healthFundId, accountId) }, { method: 'get' });
-};
-
-/**
- * Get health fund accounts
- * @param {String} healthFundId - The health fund ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getHealthFundAccounts = async (
-  healthFundId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundAccounts(healthFundId) }, { method: 'get', params: query });
-};
-
-/**
- * Get organisation accounts
- * @param {String} organisationId - The organisation ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getOrganisationAccounts = async (
-  organisationId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ organisationId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathOrganisationAccounts(organisationId) }, { method: 'get', params: query });
-};
-
-/**
- * Get account
- * @param {String} accountId - Account ID
- * @param {Object} opts - Additional options
- */
-export const getAccount = async (accountId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ accountId }, opts.hyperMediaEndpoint);
-  const account: Object = await request({ ...opts, path: pathAccountsByAccountId(accountId) }, { method: 'get' });
-  if (accountId === _get(sdk, 'account._id')) {
-    sdk.setAccount(account);
-  }
-  return account;
-};
-
-/**
- * Get business staff account
- * @param {String} businessId - Business ID
- * @param {String} staffId - Staff ID
- * @param {Object} opts - Additional options
- */
-export const getBusinessStaffAccount = async (
-  businessId: string,
-  staffId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, staffId }, opts.hyperMediaEndpoint);
-  return await request({ ...opts, path: pathBusinessStaffAccount(businessId, staffId) }, { method: 'get' });
-};
-
-/**
- * Check if account exists
- * @param {String} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getAccountExists = async (query?: Object = {}, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: pathAccountExists() }, { method: 'get', params: query });
-};
-
-/**
- * Get account roles
- * @param {String} accountId - Account ID
- * @param {Object} opts - Additional options
- */
-export const getAccountRoles = async (accountId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ accountId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathAccountRolesByAccountId(accountId) }, { method: 'get' });
-};
-
-/**
- * Get account secret keys
- * @param {String} accountId - Account ID
- * @param {Object} opts - Additional options
- */
-export const getAccountSecretKeys = async (
-  accountId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Array<Object>> => {
-  doesParamExist({ accountId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathAccountSecretKeysByAccountId(accountId) }, { method: 'get' });
-};
-
-/**
- * Get account transactions
- * @param {String} accountId - Account ID
- * @param {Object} query - query parameters
- * @param {Object} opts - Additional options
- */
-export const getAccountTransactions = async (
-  accountId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ accountId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathAccountTransactions(accountId) }, { method: 'get', params: query });
-};
-
-/**
- * Invite health fund account
- * @param {String} healthFundId - The health fund ID
- * @param {Object} requestBody - Request body
- * @param {Object} opts - Additional options
- */
-export const inviteHealthFundAccount = async (
-  healthFundId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: `${pathHealthFundAccounts(healthFundId)}/invites` }, { method: 'post', data: body });
-};
-
-/**
- * Remove health fund from account
- * @param {String} healthFundId - Health fund ID
- * @param {String} accountId - Account ID
- * @param {Object} opts - Additional options
- */
-export const removeHealthFundFromAccount = async (
-  healthFundId: string,
-  accountId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ accountId, healthFundId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundAccount(healthFundId, accountId) }, { method: 'delete' });
-};
-
-/**
- * Request to verify an account
- * @param {String} accountId - Account ID
- * @param {Object} opts - Additional options
- */
-export const requestToVerifyAccount = async (accountId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ accountId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathRequestVerifyAccount(accountId) }, { method: 'post' });
-};
-
-/**
- * Sign up for an account
- * @param {String} email - Account email address
- * @param {String} mobile - Mobile number
- * @param {Object} body - Object body
- * @param {Object} opts - Additional options
- */
-export const signUp = async (
-  email: string,
-  mobile: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ email, mobile }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: PATH__SIGN_UP }, { method: 'post', data: { email, mobile, ...body } });
-};
-
-/**
- * Accept an invite
- * @param {Object} body - Object body
- * @param {Object} opts - Additional options
- */
-export const acceptInvite = async (body: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: PATH__ACCEPT_ACCOUNT_INVITE }, { method: 'post', data: body });
-};
-
-/**
- * Update account
- * @param {String} accountId - Account ID
- * @param {Object} body - Object body
- * @param {Object} opts - Additional options
- */
-export const updateAccount = async (
-  accountId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ accountId }, opts.hyperMediaEndpoint);
-  const account = await request({ ...opts, path: pathAccountsByAccountId(accountId) }, { method: 'put', data: body });
-  if (accountId === _get(sdk, 'account._id')) {
-    sdk.setAccount(account);
-  }
-  return account;
-};
-
-/**
- * Update account roles
- * @param {String} accountId - Account ID
- * @param {Object} opts - Additional options
- */
-export const updateAccountRoles = async (
-  accountId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ accountId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathAccountRolesByAccountId(accountId) }, { method: 'put', data: body });
-};
-
-/**
- * Get account practices
- * @param {String} accountId - Account ID
- * @param {Object} query - query parameters
- * @param {Object} opts - Additional options
- */
-export const getAccountPractices = async (
-  accountId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ accountId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathAccountPractices(accountId) }, { method: 'get', params: query });
-};
-
-/**
- * Change password
- * @param {Object} body - Object body
- * @param {Object} opts - Additional options
- */
-export const changePassword = async (body: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: pathChangePassword() }, { method: 'post', data: body });
-};

package/lib/resources/actions.js.flow

@@ -1,25 +0,0 @@
-// @flow
-
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-
-const PATH__ACTIONS = '/actions';
-const pathAction = actionId => `${PATH__ACTIONS}/${actionId}`;
-
-/**
- * Get actions
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getActions = async (query?: Object = {}, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: PATH__ACTIONS }, { method: 'get', params: query });
-};
-
-/**
- * Get action
- * @param {String} actionId - Action ID
- * @param {Object} opts - Additional options
- */
-export const getAction = async (actionId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: pathAction(actionId) }, { method: 'get' });
-};

package/lib/resources/api-keys.js.flow

@@ -1,54 +0,0 @@
-// @flow
-
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-
-export const pathApiKeysByBusinessId = (businessId: string) => `/businesses/${businessId}/apikeys`;
-export const pathApiKeyByApiKeyId = (businessId: string, apiKeyId: string) =>
-  `/businesses/${businessId}/apikeys/${apiKeyId}`;
-
-/**
- * Create an Api Key
- * @param {String} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const createApiKey = async (
-  businessId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathApiKeysByBusinessId(businessId) }, { method: 'post', data: body });
-};
-
-/**
- * Get Api Keys for a business
- * @param {String} businessId - Business ID
- * @param {Object} query - query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusinessApiKeys = async (
-  businessId: string,
-  query: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathApiKeysByBusinessId(businessId) }, { method: 'get', params: query });
-};
-
-/**
- * Delete Api Key by apiKeyId
- * @param {String} businessId - Business ID
- * @param {String} apiKeyId - Api Key ID
- * @param {Object} opts - Additional options
- */
-export const deleteApiKey = async (
-  businessId: string,
-  apiKeyId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, apiKeyId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathApiKeyByApiKeyId(businessId, apiKeyId) }, { method: 'delete' });
-};

package/lib/resources/applications.js.flow

@@ -1,60 +0,0 @@
-// @flow
-
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-import doesParamExist from '../utils/does-param-exist';
-
-const PATH__APPLICATIONS = '/applications';
-const PATH__SELF_APPLICATION = '/applications/me';
-const pathApplication = applicationId => `/applications/${applicationId}`;
-
-/**
- * Get self application
- * @param {Object} opts - Additional options
- */
-export const getSelfApplication = (opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: PATH__SELF_APPLICATION }, { method: 'get' });
-};
-
-/**
- * Get applications
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getApplications = (query?: Object = {}, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: PATH__APPLICATIONS }, { method: 'get', params: query });
-};
-
-/**
- * Get application
- * @param {String} applicationId - Application ID
- * @param {Object} opts - Additional options
- */
-export const getApplication = (applicationId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ applicationId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathApplication(applicationId) }, { method: 'get' });
-};
-
-/**
- * Update application
- * @param {String} applicationId - Application ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const updateApplication = (
-  applicationId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ applicationId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathApplication(applicationId) }, { method: 'put', data: body });
-};
-
-/**
- * Create application
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const createApplication = (body: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: PATH__APPLICATIONS }, { method: 'post', data: body });
-};

package/lib/resources/attachments.js.flow

@@ -1,75 +0,0 @@
-// @flow
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-export const pathGetClaimAttachmentUrl = (businessId: string, practiceId: string, staffId: string) =>
-  `/businesses/${businessId}/practices/${practiceId}/staff/${staffId}/attachments/uploadurl`;
-export const pathGetS3SignedUrl = (businessId: string, practiceId: string, staffId: string, s3SignedUrlId: string) =>
-  `/businesses/${businessId}/practices/${practiceId}/staff/${staffId}/attachments/s3signedurls/${s3SignedUrlId}`;
-export const pathScanClaimFile = (businessId: string, practiceId: string, staffId: string) =>
-  `/businesses/${businessId}/practices/${practiceId}/staff/${staffId}/attachments/virusscan`;
-
-/**
- * Get url to upload a file associated to a claim
- * @param {String} businessId - Business ID
- * @param {String} practiceId - Practice ID
- * @param {String} staffId - Staff ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const getClaimAttachmentUrl = (
-  businessId: string,
-  practiceId: string,
-  staffId: string,
-  query: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, practiceId, staffId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathGetClaimAttachmentUrl(businessId, practiceId, staffId) },
-    { method: 'get', params: query }
-  );
-};
-
-/**
- * Scan a file associated to a claim
- * @param {String} businessId - Business ID
- * @param {String} practiceId - Practice ID
- * @param {String} staffId - Staff ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const scanClaimFile = (
-  businessId: string,
-  practiceId: string,
-  staffId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, practiceId, staffId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathScanClaimFile(businessId, practiceId, staffId) }, { method: 'post', data: body });
-};
-
-/**
- * Get s3 signed url
- * @param {String} businessId - Business ID
- * @param {String} practiceId - Practice ID
- * @param {String} staffId - Staff ID
- * @param {String} s3SignedUrlId - Internal s3 signed url ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const getS3SignedUrl = (
-  businessId: string,
-  practiceId: string,
-  staffId: string,
-  s3SignedUrlId: string,
-  query: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, practiceId, staffId, s3SignedUrlId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathGetS3SignedUrl(businessId, practiceId, staffId, s3SignedUrlId) },
-    { method: 'get', params: query }
-  );
-};