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

package/lib/resources/practices.js.flow

@@ -1,314 +0,0 @@
-// @flow
-
-import request from '../utils/request';
-import doesParamExist from '../utils/does-param-exist';
-import type { MedipassRequestOpts } from '../_types';
-
-const pathBusinessFormPractices = (businessId, formId) => `/businesses/${businessId}/forms/${formId}/practices`;
-const pathBusinessPractices = businessId => `/businesses/${businessId}/practices`;
-const pathBusinessPractice = (businessId, practiceId) => `/businesses/${businessId}/practices/${practiceId}`;
-const pathBusinessPracticeUploadUrl = (businessId, practiceId) =>
-  `/businesses/${businessId}/practices/${practiceId}/uploadurlv2`;
-const pathOnboardingPractices = () => '/practices/onboarding/search';
-const pathOrganisationPractices = organisationId => `/organisations/${organisationId}/practices`;
-const pathOrganisationPractice = (organisationId, practiceId) =>
-  `/organisations/${organisationId}/practices/${practiceId}`;
-const pathPractice = practiceId => `/practices/${practiceId}`;
-const pathGetPracticesWithApprovedApplications = (businessId, formId) =>
-  `/businesses/${businessId}/forms/${formId}/practices/approved`;
-const pathBusinessStaffPractices = (businessId, staffId) => `/businesses/${businessId}/staff/${staffId}/practices`;
-
-/**
- * Create business practice
- * @param {String} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const createBusinessPractice = async (
-  businessId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessPractices(businessId) }, { method: 'post', data: body });
-};
-
-/**
- * Create organisation practice
- * @param {String} organisationId - Organisation ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const createOrganisationPractice = async (
-  organisationId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ organisationId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathOrganisationPractices(organisationId) }, { method: 'post', data: body });
-};
-
-/**
- * Delete business practice
- * @param {String} businessId - Business ID
- * @param {String} practiceId - Practice ID
- * @param {Object} opts - Additional options
- */
-export const deleteBusinessPractice = async (
-  businessId: string,
-  practiceId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, practiceId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessPractice(businessId, practiceId) }, { method: 'delete' });
-};
-
-/**
- * Delete organisation practice
- * @param {String} organisationId - Organisation ID
- * @param {String} practiceId - Practice ID
- * @param {Object} opts - Additional options
- */
-export const deleteOrganisationPractice = async (
-  organisationId: string,
-  practiceId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ organisationId, practiceId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathOrganisationPractice(organisationId, practiceId) }, { method: 'delete' });
-};
-
-/**
- * Get business practice
- * @param {String} businessId - Business ID
- * @param {String} practiceId - Practice ID
- * @param {Object} opts - Additional options
- */
-export const getBusinessPractice = async (
-  businessId: string,
-  practiceId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, practiceId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessPractice(businessId, practiceId) }, { method: 'get' });
-};
-
-/**
- * Get business practices
- * @param {String} businessId - Business ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusinessPractices = async (
-  businessId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessPractices(businessId) }, { method: 'get', params: query });
-};
-
-/**
- * Get business form practices
- * @param {String} businessId - Business ID
- * @param {String} formId - Form ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusinessFormPractices = async (
-  businessId: string,
-  formId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, formId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessFormPractices(businessId, formId) }, { method: 'get', params: query });
-};
-
-/**
- * Get business practice upload urls
- * @param {String} businessId - Business ID
- * @param {String} practiceId - Practice ID
- * @param {String} contentType - Mime type
- * @param {Object} opts - Additional options
- */
-export const getBusinessPracticeUploadUrl = async (
-  businessId: string,
-  practiceId: string,
-  query: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, practiceId, query }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathBusinessPracticeUploadUrl(businessId, practiceId) },
-    { method: 'get', params: query }
-  );
-};
-
-/**
- * Get business staff practices
- * @param {String} businessId - Business ID
- * @param {String} staffId - Staff ID
- * @param {Object} opts - Additional options
- */
-export const getBusinessStaffPractices = async (
-  businessId: string,
-  staffId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, staffId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessStaffPractices(businessId, staffId) }, { method: 'get', params: query });
-};
-
-/**
- * Get organisation practices
- * @param {String} organisationId - Organisation ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getOrganisationPractices = async (
-  organisationId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ organisationId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathOrganisationPractices(organisationId) }, { method: 'get', params: query });
-};
-
-// DEPRECATED: Use getBusinessPractice instead.
-/**
- * Get practice
- * @param {String} practiceId - Practice ID
- * @param {Object} opts - Additional options
- */
-export const getPractice = async (practiceId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  doesParamExist({ practiceId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathPractice(practiceId) }, { method: 'get' });
-};
-
-/**
- * Request to claim a practice
- * @param {String} practiceId - Practice ID
- * @param {Object} opts - Additional options
- */
-export const requestClaimPractice = (practiceId: string, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: `${pathPractice(practiceId)}/verify/request` }, { method: 'post' });
-};
-
-/**
- * Request to add provider to practice
- * @param {String} practiceId - Practice ID
- * @param {String} providerNumber - Provider number
- * @param {Object} opts - Additional options
- */
-export const requestToAddProviderToPractice = (
-  practiceId: string,
-  providerNumber: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  return request(
-    { ...opts, path: `${pathPractice(practiceId)}/access/request` },
-    { method: 'post', data: { providerNumber } }
-  );
-};
-
-/**
- * Search practices for onboarding
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const searchOnboardingPractices = (query?: Object = {}, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: pathOnboardingPractices() }, { method: 'get', params: query });
-};
-
-/**
- * Update business practice
- * @param {String} businessId - Business ID
- * @param {String} practiceId - Practice ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const updateBusinessPractice = async (
-  businessId: string,
-  practiceId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, practiceId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessPractice(businessId, practiceId) }, { method: 'put', data: body });
-};
-
-/**
- * Update organisation practice
- * @param {String} organisationId - Organisation ID
- * @param {String} practiceId - Practice ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const updateOrganisationPractice = async (
-  organisationId: string,
-  practiceId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ organisationId, practiceId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathOrganisationPractice(organisationId, practiceId) },
-    { method: 'put', data: body }
-  );
-};
-
-/**
- * Verify a claim to a practice
- * @param {String} practiceId - Practice ID
- * @param {String} otkCode - One time token
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const verifyClaimPractice = (
-  practiceId: string,
-  otkCode: string,
-  body?: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  return request(
-    { ...opts, path: `${pathPractice(practiceId)}/verify` },
-    { method: 'post', data: { ...body, otkCode } }
-  );
-};
-
-/**
- * Clone practice into another business
- * @param {String} practiceId - Practice ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const clonePracticeIntoBusiness = async (
-  practiceId: string,
-  body?: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ practiceId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: `${pathPractice(practiceId)}/clone` }, { method: 'post', data: body });
-};
-
-/**
- * Get practices with approved applications
- * @param {String} businessId - business ID
- * @param {String} formId - Form ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getPracticesWithApprovedApplications = async (
-  businessId: string,
-  formId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId, formId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathGetPracticesWithApprovedApplications(businessId, formId) },
-    { method: 'get', params: query }
-  );
-};

package/lib/resources/products.js.flow

@@ -1,48 +0,0 @@
-// @flow
-
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type { MedipassRequestOpts, GetBusinessProductsQuery, ProductResponse, ProductsResponse } from '../_types';
-
-export const pathBusinessProducts = (businessId: string) => `/businesses/${businessId}/products`;
-export const pathBusinessProduct = (businessId: string, productId: string) =>
-  `/businesses/${businessId}/products/${productId}`;
-
-/**
- * Get products
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getProducts = (query?: Object, opts?: MedipassRequestOpts = {}): Promise<ProductsResponse> => {
-  return request({ ...opts, path: '/products' }, { method: 'get', params: query });
-};
-
-/**
- * Get business products
- * @param {String} businessId - Business ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusinessProducts = (
-  businessId: string,
-  query?: GetBusinessProductsQuery,
-  opts?: MedipassRequestOpts = {}
-): Promise<ProductsResponse> => {
-  doesParamExist({ businessId });
-  return request({ ...opts, path: pathBusinessProducts(businessId) }, { method: 'get', params: query });
-};
-
-/**
- * Get business product
- * @param {String} businessId - Business ID
- * @param {String} productId - Product ID
- * @param {Object} opts - Additional options
- */
-export const getBusinessProduct = (
-  businessId: string,
-  productId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<ProductResponse> => {
-  doesParamExist({ businessId, productId });
-  return request({ ...opts, path: pathBusinessProduct(businessId, productId) }, { method: 'get' });
-};

package/lib/resources/professional-categories.js.flow

@@ -1,56 +0,0 @@
-// @flow
-
-import doesParamExist from '../utils/does-param-exist';
-import request from '../utils/request';
-import type {
-  MedipassRequestOpts,
-  GetProfessionalCategoriesQuery,
-  ProfessionalCategoryResponse,
-  ProfessionalCategoriesResponse
-} from '../_types';
-
-export const pathBusinessProfessionalCategories = (businessId: string) =>
-  `/businesses/${businessId}/professionalcategories`;
-export const pathProfessionalCategories = '/professionalcategories';
-export const pathProfessionalCategory = (professionalCategoryId: string) =>
-  `/professionalcategories/${professionalCategoryId}`;
-
-/**
- * Get professional categories
- * @param {Object} opts - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getProfessionalCategories = (
-  query?: GetProfessionalCategoriesQuery,
-  opts?: MedipassRequestOpts = {}
-): Promise<ProfessionalCategoriesResponse> => {
-  return request({ ...opts, path: pathProfessionalCategories }, { method: 'get', params: query });
-};
-
-/**
- * Get business professional categories
- * @param {Object} businessId - Business ID
- * @param {Object} opts - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getBusinessProfessionalCategories = (
-  businessId: string,
-  query?: GetProfessionalCategoriesQuery,
-  opts?: MedipassRequestOpts = {}
-): Promise<ProfessionalCategoriesResponse> => {
-  doesParamExist({ businessId });
-  return request({ ...opts, path: pathBusinessProfessionalCategories(businessId) }, { method: 'get', params: query });
-};
-
-/**
- * Get professional category
- * @param {Object} professionalCategoryId - Professional category ID
- * @param {Object} opts - Additional options
- */
-export const getProfessionalCategory = (
-  professionalCategoryId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<ProfessionalCategoryResponse> => {
-  doesParamExist({ professionalCategoryId });
-  return request({ ...opts, path: pathProfessionalCategory(professionalCategoryId) }, { method: 'get' });
-};

package/lib/resources/provider-number-types.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 pathProviderNumberTypes = () => `/providernumbertypes`;
-export const pathProviderNumberType = (providerNumberTypeId: string) => `/providernumbertypes/${providerNumberTypeId}`;
-
-/**
- * Get provider number types
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getProviderNumberTypes = async (query?: Object = {}, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, path: pathProviderNumberTypes() }, { method: 'get', params: query });
-};
-
-/**
- * Get provider number type
- * @param {String} providerNumberTypeId - Provider number type ID
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getProviderNumberType = (
-  providerNumberTypeId: string,
-  query?: Object = {},
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ providerNumberTypeId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathProviderNumberType(providerNumberTypeId) }, { method: 'get', params: query });
-};

package/lib/resources/provider-registration-types.js.flow

@@ -1,32 +0,0 @@
-// @flow
-
-import request from '../utils/request';
-import type { MedipassRequestOpts, PaginatedQuery } from '../_types';
-
-export const pathGetProviderRegistrationTypes = '/providerregistrationtypes';
-export const pathGetProviderRegistrationType = (providerRegistrationTypeId: string) =>
-  `/providerregistrationtypes/${providerRegistrationTypeId}`;
-
-/**
- * Get provider registration types
- * @param {Object} query - Query parameters
- * @param {Object} opts - Additional options
- */
-export const getProviderRegistrationTypes = async (
-  query?: PaginatedQuery,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  return request({ ...opts, path: pathGetProviderRegistrationTypes }, { method: 'get', params: query });
-};
-
-/**
- * Get a provider registration type
- * @param {String} providerRegistrationTypeId - Provider registration type ID
- * @param {Object} opts - Additional options
- */
-export const getProviderRegistrationType = async (
-  providerRegistrationTypeId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  return request({ ...opts, path: pathGetProviderRegistrationType(providerRegistrationTypeId) }, { method: 'get' });
-};

package/lib/resources/provider-requests.js.flow

@@ -1,46 +0,0 @@
-// @flow
-
-import request from '../utils/request';
-import doesParamExist from '../utils/does-param-exist';
-import type { MedipassRequestOpts } from '../_types';
-
-const pathBusinessProviderRequests = businessId => `/businesses/${businessId}/providerrequests`;
-const pathBusinessPracticeStaffMemberProviderRequest = (businessId, practiceId, staffId) =>
-  `/businesses/${businessId}/practices/${practiceId}/staff/${staffId}/providerrequests`;
-
-/**
- * Create providerRequest
- * @param {string} businessId - Business ID
- * @param {Object} body - Request body
- * @param {Object} opts - Additional options
- */
-export const createProviderRequest = async (
-  businessId: string,
-  body: Object,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, path: pathBusinessProviderRequests(businessId) }, { method: 'post', data: body });
-};
-
-/**
- * Request a staff member provider number to be enabled
- * @param {string} businessId - Business ID
- * @param {string} practiceId - Practice ID
- * @param {string} staffId - Staff ID
- * @param {string} providerNumber - ProviderNumber
- * @param {Object} opts - Additional options
- */
-export const requestBusinessPracticeStaffMemberProviderNumberToBeEnabled = async (
-  businessId: string,
-  practiceId: string,
-  staffId: string,
-  providerNumber: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ businessId }, opts.hyperMediaEndpoint);
-  return request(
-    { ...opts, path: pathBusinessPracticeStaffMemberProviderRequest(businessId, practiceId, staffId) },
-    { method: 'post', data: { providerNumber } }
-  );
-};

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

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

package/lib/resources/ref-sources.js.flow

@@ -1,16 +0,0 @@
-// @flow
-
-import request from '../utils/request';
-import type { MedipassRequestOpts } from '../_types';
-
-export const PATH__REF_SOURCES = '/refsources';
-
-export const getRefSources = (
-  query?: {
-    page?: number,
-    limit?: number
-  },
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  return request({ ...opts, path: PATH__REF_SOURCES }, { method: 'get', params: query });
-};

package/lib/resources/risk.js.flow

@@ -1,29 +0,0 @@
-// @flow
-
-import request from '../utils/request';
-import doesParamExist from '../utils/does-param-exist';
-import type { MedipassRequestOpts } from '../_types';
-
-const PATH__TRANSACTIONS = '/transaction';
-
-/**
- * Get risk score
- * @param {String} transactionId - Get a transaction risk score
- * @param {Object} opts - Additional options
- */
-export const getTransactionRiskScore = async (
-  transactionId: string,
-  opts?: MedipassRequestOpts = {}
-): Promise<Object> => {
-  doesParamExist({ transactionId }, opts.hyperMediaEndpoint);
-  return request({ ...opts, apiName: 'risk', path: `${PATH__TRANSACTIONS}/risk/${transactionId}` }, { method: 'get' });
-};
-
-/**
- * Score and save a transaction
- * @param {String} body - Request body
- * @param {Object} opts - Additional options
- */
-export const scoreAndSaveTransaction = async (body: Object, opts?: MedipassRequestOpts = {}): Promise<Object> => {
-  return request({ ...opts, apiName: 'risk', path: PATH__TRANSACTIONS }, { method: 'post', data: body });
-};