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

package/lib/resources/members.js.flow

@@ -1,196 +0,0 @@
-// @flow
-import _get from 'lodash/get';
-
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-import sdk from '../index';
-
-const PATH__MEMBERS = '/members';
-const PATH__DISCOVER_MEMBERS = '/discovery/members';
-const pathAccountMembers = accountId => `/accounts/${accountId}/members`;
-const pathBusinessMember = (businessId, memberId) => `/businesses/${businessId}/members/${memberId}`;
-const pathBusinessMembers = businessId => `/businesses/${businessId}/members`;
-const pathMember = memberId => `/members/${memberId}`;
-const pathMembersForHealthFund = healthFundId => `/healthfunds/${healthFundId}/members`;
-const pathHealthFundMemberByMemberId = (healthFundId, memberId) => `/healthfunds/${healthFundId}/members/${memberId}`;
-
-/**
- * Check for duplicate member
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const checkDupe = async (body: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: `${PATH__MEMBERS}/checkdupe` }, { method: 'post', data: body });
-};
-
-/**
- * Create member for an account
- * @param {string} accountId - Account ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const createAccountMember = async (
-  accountId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  return request({ ...opts, path: pathAccountMembers(accountId) }, { method: 'post', data: body });
-};
-
-/**
- * Delete a members
- * @param {Object} memberId - Member ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const deleteMember = async (memberId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ memberId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathMember(memberId) }, { method: 'delete' });
-};
-
-/**
- * Discover a member
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const discoverMember = async (query: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: PATH__DISCOVER_MEMBERS }, { method: 'get', params: query });
-};
-
-/**
- * Invite someone to become a Medipass member
- * @param {String} businessId - Member ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const inviteAnyone = async (
-  businessId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: `${pathBusinessMembers(businessId)}/invites` }, { method: 'post', data: body });
-};
-
-/**
- * Send an SMS to member with link to download app
- * @param {String} memberId - Member ID
- * @param {Object} opts - Additional options
- */
-export const inviteMember = async (memberId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ memberId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: `${pathMember(memberId)}/invites` }, { method: 'post' });
-};
-
-/**
- * Get members for an account
- * @param {string} accountId - Account ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getAccountMembers = async (
-  accountId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  return request({ ...opts, path: pathAccountMembers(accountId) }, { method: 'get', params: query });
-};
-
-/**
- * Get members by health fund
- * @param {String} healthFundId - Health fund ID
- * @param {Object} opts - Additional options
- */
-export const getMembersForHealthFund = async (
-  healthFundId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  return request({ ...opts, path: pathMembersForHealthFund(healthFundId) }, { method: 'get', params: query });
-};
-
-/**
- * Get health fund member by member ID.
- * @param {String} healthFundId - Health Fund ID
- * @param {String} memberId - Member ID
- * @param {Object} opts - Additional options
- */
-export const getHealthFundMemberByMemberId = async (
-  healthFundId: string,
-  memberId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  return request({ ...opts, path: pathHealthFundMemberByMemberId(healthFundId, memberId) }, { method: 'get' });
-};
-
-/**
- * Get business members
- * @param {String} businessId - Business ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusinessMembers = async (
-  businessId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessMembers(businessId) }, { method: 'get', params: query });
-};
-
-/**
- * Get business member
- * @param {String} businessId - Business ID
- * @param {String} memberId - Member ID
- * @param {Object} opts - Additional options
- */
-export const getBusinessMember = async (
-  businessId: string,
-  memberId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessMember(businessId, memberId) }, { method: 'get' });
-};
-
-/**
- * Get members
- * @param {Object} opts - Additional options
- */
-export const getMembers = async (query?: Object = {}, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: PATH__MEMBERS }, { method: 'get', params: query });
-};
-
-/**
- * Get member
- * @param {String} memberId - Member ID
- * @param {Object} opts - Additional options
- */
-export const getMember = async (memberId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ memberId }, opts.hyperMediaEndpoint);
-  const member = await request({ ...opts, path: pathMember(memberId) }, { method: 'get' });
-  if (memberId === _get(sdk, 'member._id')) {
-    sdk.setMember(member);
-  }
-  return member;
-};
-
-/**
- * Update a members
- * @param {Object} memberId - Member ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const updateMember = async (
-  memberId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ memberId }, opts.hyperMediaEndpoint);
-  const member = await request({ ...opts, path: pathMember(memberId) }, { method: 'put', data: body });
-  if (memberId === _get(sdk, 'member._id')) {
-    sdk.setMember(member);
-  }
-  return member;
-};

package/lib/resources/message-mappings.js.flow

@@ -1,25 +0,0 @@
-// @flow
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type {
-  GetBusinessMessageMappingsQuery,
-  GetBusinessMessageMappingsResponse,
-  MedipassRequestOpts
-} from '../_types';
-
-export const pathBusinessMessageMappings = (businessId: string) => `/businesses/${businessId}/messagemappings`;
-
-/**
- * Get business message mappings
- * @param {String} businessId - Health fund ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusinessMessageMappings = (
-  businessId: string,
-  query: GetBusinessMessageMappingsQuery,
-  opts?: MedipassRequestOpts = {}
-): Promise<GetBusinessMessageMappingsResponse> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessMessageMappings(businessId) }, { method: 'get', params: query });
-};

package/lib/resources/minions.js.flow

@@ -1,96 +0,0 @@
-// @flow
-
-import request from '../utils/request';
-import doesParamExist from '../utils/does-param-exist';
-import type { MedipassRequestOpts } from '../_types';
-
-const pathMinionsForHealthFund = healthFundId => `/healthfunds/${healthFundId}/minions`;
-const pathMinionForHealthFund = (healthFundId, minionId) => `${pathMinionsForHealthFund(healthFundId)}/${minionId}`;
-
-/**
- * Create minion for health fund
- * @param {String} healthFundId - Health fund ID
- * @param {String} name - Minion name
- * @param {String} triggerId - Minion trigger ID
- * @param {String} actionId - Minion action ID
- * @param {Object} body - Additional body
- * @param {Object} opts - Additional options
- */
-export const createMinionForHealthFund = async (
-  healthFundId: string,
-  name: string,
-  triggerId: string,
-  actionId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, name, triggerId, actionId }, opts.hyperMediaEndpoint);
-  const data = {
-    name,
-    triggerId,
-    actionId,
-    ...body
-  };
-  return request({ ...opts, path: pathMinionsForHealthFund(healthFundId) }, { method: 'post', data });
-};
-
-/**
- * Get minions for health fund
- * @param {String} healthFundId - Health fund ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getMinionsForHealthFund = async (
-  healthFundId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  return request({ ...opts, path: pathMinionsForHealthFund(healthFundId) }, { method: 'get', params: query });
-};
-
-/**
- * Get minion for health fund
- * @param {String} healthFundId - Health fund ID
- * @param {String} minionId - Minion ID
- * @param {Object} opts - Additional options
- */
-export const getMinionForHealthFund = async (
-  healthFundId: string,
-  minionId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, minionId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathMinionForHealthFund(healthFundId, minionId) }, { method: 'get' });
-};
-
-/**
- * Update minion for health fund
- * @param {String} healthFundId - Health fund ID
- * @param {String} minionId - Minion ID
- * @param {String} body
- * @param {Object} opts - Additional options
- */
-export const updateMinionForHealthFund = async (
-  healthFundId: string,
-  minionId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, minionId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathMinionForHealthFund(healthFundId, minionId) }, { method: 'put', data: body });
-};
-
-/**
- * Delete a health fund's minionId
- * @param {String} healthFundId - Health fund ID
- * @param {String} minionId - Minion ID
- * @param {Object} opts - Additional options
- */
-export const deleteMinionForHealthFund = async (
-  healthFundId: string,
-  minionId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, minionId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathMinionForHealthFund(healthFundId, minionId) }, { method: 'delete' });
-};

package/lib/resources/modalities.js.flow

@@ -1,46 +0,0 @@
-// @flow
-import medipassWebSdk from '../index';
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-
-const PATH__MODALITIES = '/modalities';
-const pathModality = modalityId => `/modalities/${modalityId}`;
-const pathBusinessModalities = businessId => `/businesses/${businessId}/modalities`;
-
-/**
- * Get business's available modalities
- * @param {Object} businessId - Business ID
- * @param {Object} opts - Additional options
- */
-export const getBusinessModalities = async (
-  businessId: string,
-  opts?: MedipassRequestOpts = { ver: medipassWebSdk.defaultVersion }
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessModalities(businessId) }, { method: 'get' });
-};
-
-/**
- * Get modalities
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getModalities = async (
-  query?: Object = {},
-  opts?: MedipassRequestOpts = { ver: medipassWebSdk.defaultVersion }
-): Promise<Object | Array<Object>> => {
-  return request({ ...opts, path: PATH__MODALITIES }, { method: 'get', params: query });
-};
-
-/**
- * Get modality
- * @param {String} modalityId - Modality ID
- * @param {Object} opts - Additional options
- */
-export const getModality = async (
-  modalityId: string,
-  opts?: MedipassRequestOpts = { ver: medipassWebSdk.defaultVersion }
-): Promise<Object> => {
-  return request({ ...opts, path: pathModality(modalityId) }, { method: 'get' });
-};

package/lib/resources/notes.js.flow

@@ -1,112 +0,0 @@
-// @flow
-
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { CreateNoteRequestBody, MedipassRequestOpts, PaginatedQuery } from '../_types';
-
-export const pathHealthFundDocumentNotes = (healthFundId: string, documentId: string) =>
-  `/healthfunds/${healthFundId}/documents/${documentId}/notes`;
-export const pathHealthFundTransactionNote = (healthFundId: string, transactionId: string) =>
-  `/healthfunds/${healthFundId}/transactions/${transactionId}/notes`;
-export const pathHealthFundNote = (healthFundId: string, noteId: string) =>
-  `/healthfunds/${healthFundId}/notes/${noteId}`;
-export const pathTransactionNotes = (transactionId: string) => `/transactions/${transactionId}/notes`;
-export const pathTransactionNote = (transactionId: string, transactionNoteId: string) =>
-  `/transactions/${transactionId}/notes/${transactionNoteId}`;
-export const pathGetTransactionNote = (businessId: string, transactionId: string) =>
-  `/businesses/${businessId}/transactions/${transactionId}/notes`;
-
-export const createHealthFundDocumentNote = (
-  healthFundId: string,
-  documentId: string,
-  body: CreateNoteRequestBody,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, documentId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathHealthFundDocumentNotes(healthFundId, documentId) },
-    { method: 'post', data: body }
-  );
-};
-
-export const getHealthFundDocumentNotes = (
-  healthFundId: string,
-  documentId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, documentId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundDocumentNotes(healthFundId, documentId) }, { method: 'get' });
-};
-
-export const getHealthFundTransactionNote = (
-  healthFundId: string,
-  transactionId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, transactionId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundTransactionNote(healthFundId, transactionId) }, { method: 'get' });
-};
-
-export const getHealthFundNote = (
-  healthFundId: string,
-  noteId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, noteId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundNote(healthFundId, noteId) }, { method: 'get' });
-};
-
-export const getTransactionNotes = (
-  transactionId: string,
-  query?: ?PaginatedQuery,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ transactionId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathTransactionNotes(transactionId) }, { method: 'get', params: query });
-};
-
-export const getTransactionNote = (
-  businessId: string,
-  transactionId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, transactionId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathGetTransactionNote(businessId, transactionId) }, { method: 'get' });
-};
-
-export const addTransactionNote = (
-  transactionId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ transactionId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathTransactionNotes(transactionId) }, { method: 'post', data: body });
-};
-
-export const deleteTransactionNote = (
-  transactionId: string,
-  transactionNoteId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ transactionId, transactionNoteId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathTransactionNote(transactionId, transactionNoteId) }, { method: 'delete' });
-};
-
-export const updateHealthFundNote = (
-  healthFundId: string,
-  noteId: string,
-  body: CreateNoteRequestBody,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, noteId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundNote(healthFundId, noteId) }, { method: 'put', data: body });
-};
-
-export const deleteHealthFundNote = (
-  healthFundId: string,
-  noteId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ healthFundId, noteId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathHealthFundNote(healthFundId, noteId) }, { method: 'delete' });
-};

package/lib/resources/onboarding-applications.js.flow

@@ -1,142 +0,0 @@
-// @flow
-
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-
-export const pathPracticeOnboardingApplications = (practiceId: string) =>
-  `/practices/${practiceId}/onboardingapplications`;
-
-export const pathBusinessPracticeOnboardingApplications = (businessId: string, practiceId: string) =>
-  `/businesses/${businessId}/practices/${practiceId}/onboardingapplications`;
-
-export const pathBusinessOnboardingApplications = (businessId: string) =>
-  `/businesses/${businessId}/onboardingapplications`;
-
-export const pathProviderSetItemOnboardingApplications = (
-  businessId: string,
-  staffId: string,
-  providerSetItemId: string
-) => `/businesses/${businessId}/staff/${staffId}/providersetitems/${providerSetItemId}/onboardingapplications`;
-
-export const pathProviderSetItemOnboardingApplication = (
-  businessId: string,
-  staffId: string,
-  providerSetItemId: string
-) => `/businesses/${businessId}/staff/${staffId}/providersetitems/${providerSetItemId}/onboardingapplication`;
-
-/**
- * Get submitPracticeOnboardingApplication
- * @param {string} practiceId - Practice ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const submitPracticeOnboardingApplication = (
-  practiceId: string,
-  body?: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ practiceId });
-  return request({ ...opts, path: pathPracticeOnboardingApplications(practiceId) }, { method: 'post', data: body });
-};
-
-/**
- * Get a list of practice's onboarding applications
- * @param {String} businessId - Business ID
- * @param {string} practiceId - Practice ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusinessPracticeOnboardingApplications = async (
-  businessId: string,
-  practiceId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, practiceId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathBusinessPracticeOnboardingApplications(businessId, practiceId) },
-    { method: 'get', params: query }
-  );
-};
-
-/**
- * Get onboarding applications for business
- * @param {string} businessId - Business ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusinessOnboardingApplications = (
-  businessId: string,
-  query?: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId });
-  return request({ ...opts, path: pathBusinessOnboardingApplications(businessId) }, { method: 'get', params: query });
-};
-
-/**
- * Create onboarding application for business
- * @param {String} businessId - Business ID
- */
-export const createBusinessOnboardingApplication = (
-  businessId: string,
-  body?: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId });
-  return request({ ...opts, path: pathBusinessOnboardingApplications(businessId) }, { method: 'post', data: body });
-};
-
-/**
- * Update onboarding application for business
- * @param {String} businessId - Business ID
- */
-export const updateBusinessOnboardingApplication = (
-  businessId: string,
-  body?: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId });
-  return request({ ...opts, path: pathBusinessOnboardingApplications(businessId) }, { method: 'put', data: body });
-};
-
-/**
- * Create onboarding application for provider set item
- * @param {String} businessId - Business ID
- * @param {String} staffID - Staff ID
- * @param {String} providerSetItemId - Provider set item ID
- */
-export const createProviderSetItemOnboardingApplication = (
-  businessId: string,
-  staffId: string,
-  providerSetItemId: string,
-  body?: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, staffId, providerSetItemId });
-  return request(
-    { ...opts, path: pathProviderSetItemOnboardingApplications(businessId, staffId, providerSetItemId) },
-    { method: 'post', data: body }
-  );
-};
-
-/**
- * Get onboarding applications for provider set item
- * @param {string} businessId - Business ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getProviderSetItemOnboardingApplication = (
-  businessId: string,
-  staffId: string,
-  providerSetItemId: string,
-  query?: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId });
-  return request(
-    { ...opts, path: pathProviderSetItemOnboardingApplication(businessId, staffId, providerSetItemId) },
-    { method: 'get', params: query }
-  );
-};