@evoke-platform/ui-components 1.8.0-dev.1 → 1.8.0-dev.11

package/dist/published/components/custom/FormV2/tests/FormRenderer.test.js

@@ -0,0 +1,173 @@
+import * as matchers from '@testing-library/jest-dom/matchers';
+import { render, screen, waitFor, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { isEqual, set } from 'lodash';
+import { http, HttpResponse } from 'msw';
+import { setupServer } from 'msw/node';
+import React from 'react';
+import { MemoryRouter } from 'react-router-dom';
+import { expect, it } from 'vitest';
+import FormRenderer from '../FormRenderer';
+import { createSpecialtyForm, jsonLogicDisplayTestSpecialtyForm, licenseObject, npLicense, npSpecialtyType1, npSpecialtyType2, rnLicense, rnSpecialtyType1, rnSpecialtyType2, simpleConditionDisplayTestSpecialtyForm, specialtyObject, specialtyTypeObject, } from './test-data';
+expect.extend(matchers);
+const removePoppers = () => {
+    const portalSelectors = ['.MuiAutocomplete-popper'];
+    portalSelectors.forEach((selector) => {
+        // eslint-disable-next-line testing-library/no-node-access
+        document.querySelectorAll(selector).forEach((el) => el.remove());
+    });
+};
+describe('Form component', () => {
+    let server;
+    beforeAll(() => {
+        server = setupServer(http.get('/api/data/objects/specialtyType/effective', () => HttpResponse.json(specialtyTypeObject)), http.get('/api/data/objects/specialtyType/effective', (req) => {
+            const sanitizedVersion = new URL(req.request.url).searchParams.get('sanitizedVersion');
+            if (sanitizedVersion === 'true') {
+                return HttpResponse.json(specialtyTypeObject);
+            }
+        }), http.get('/api/data/objects/license/effective', (req) => {
+            const sanitizedVersion = new URL(req.request.url).searchParams.get('sanitizedVersion');
+            if (sanitizedVersion === 'true') {
+                return HttpResponse.json(licenseObject);
+            }
+        }), http.get('/api/data/objects/specialty/effective', (req) => {
+            const sanitizedVersion = new URL(req.request.url).searchParams.get('sanitizedVersion');
+            if (sanitizedVersion === 'true') {
+                return HttpResponse.json(specialtyObject);
+            }
+        }), http.get('/data/objects/license/effective', () => HttpResponse.json(licenseObject)), http.get('/api/data/objects/license/instances', () => {
+            return HttpResponse.json([rnLicense, npLicense]);
+        }), http.get('/api/data/objects/specialtyType/instances', (req) => {
+            const filter = new URL(req.request.url).searchParams.get('filter');
+            if (filter) {
+                const whereFilter = JSON.parse(filter).where;
+                // The two objects in the array of conditions in the "where" filter represent the potential filters that can be applied when retrieving "specialty" instances.
+                // The first object is for the the validation criteria, but it is empty if the "license" field, which is referenced in the validation criteria, hasn't been filled out yet.
+                // The second object is for the search criteria which the user enters in the "specialty" field, but it is empty if no search text has been entered.
+                if (isEqual(whereFilter, { and: [{}, {}] }))
+                    return HttpResponse.json([
+                        rnSpecialtyType1,
+                        rnSpecialtyType2,
+                        npSpecialtyType1,
+                        npSpecialtyType2,
+                    ]);
+                else if (isEqual(whereFilter, { and: [{ 'licenseType.id': 'rnLicenseType' }, {}] }))
+                    return HttpResponse.json([rnSpecialtyType1, rnSpecialtyType2]);
+                else if (isEqual(whereFilter, { and: [{ 'licenseType.id': 'npLicenseType' }, {}] }))
+                    return HttpResponse.json([npSpecialtyType1, npSpecialtyType2]);
+            }
+        }));
+        server.listen();
+    });
+    afterAll(() => {
+        server.close();
+    });
+    afterEach(() => {
+        server.resetHandlers();
+        removePoppers();
+    });
+    describe('validation criteria', () => {
+        it(`filters related object field with validation criteria that references a related object's nested data`, async () => {
+            const user = userEvent.setup();
+            server.use(http.get('/data/objects/license/instances/rnLicense', (req) => {
+                const expand = new URL(req.request.url).searchParams.get('expand');
+                if (expand === 'licenseType.id') {
+                    return HttpResponse.json(rnLicense);
+                }
+            }));
+            const FormWithState = () => {
+                const [formData, setFormData] = React.useState({});
+                const handleChange = (id, value) => {
+                    setFormData((prev) => {
+                        const newData = { ...prev };
+                        set(newData, id, value);
+                        return newData;
+                    });
+                };
+                try {
+                    return React.createElement(FormRenderer, { form: createSpecialtyForm, value: formData, onChange: handleChange });
+                }
+                catch (err) {
+                    console.error('Render error:', err);
+                    return React.createElement("div", null, "Render error");
+                }
+            };
+            render(React.createElement(MemoryRouter, null,
+                React.createElement(FormWithState, null)));
+            const license = await screen.findByRole('combobox', { name: 'License' });
+            // Step 1: Open Specialty Type and verify all options
+            await user.click(await screen.findByRole('combobox', { name: 'Specialty Type' }));
+            let openAutocomplete = await screen.findByRole('listbox');
+            await within(openAutocomplete).findByRole('option', { name: 'RN Specialty Type #1' });
+            await within(openAutocomplete).findByRole('option', { name: 'RN Specialty Type #2' });
+            await within(openAutocomplete).findByRole('option', { name: 'NP Specialty Type #1' });
+            await within(openAutocomplete).findByRole('option', { name: 'NP Specialty Type #2' });
+            await user.keyboard('{Escape}');
+            // Step 2: Select a license
+            await user.click(license);
+            await user.keyboard('{ArrowDown}');
+            await user.keyboard('{Enter}');
+            // Step 3: Open Specialty Type again and verify filtered options
+            await user.click(await screen.findByRole('combobox', { name: 'Specialty Type' }));
+            openAutocomplete = await screen.findByRole('listbox');
+            await within(openAutocomplete).findByRole('option', { name: 'RN Specialty Type #1' });
+            await within(openAutocomplete).findByRole('option', { name: 'RN Specialty Type #2' });
+            await waitFor(() => expect(within(openAutocomplete).queryByRole('option', { name: 'NP Specialty Type #1' })).not.toBeInTheDocument());
+            await waitFor(() => expect(within(openAutocomplete).queryByRole('option', { name: 'NP Specialty Type #2' })).not.toBeInTheDocument());
+            await user.keyboard('{Escape}');
+            await waitFor(() => {
+                expect(screen.queryByRole('listbox')).not.toBeInTheDocument();
+            });
+        });
+    });
+    describe('visibility configuration', () => {
+        it('shows fields based on instance data using JsonLogic', async () => {
+            server.use(http.get('/data/objects/license/instances/rnLicense', () => HttpResponse.json(rnLicense)));
+            render(React.createElement(MemoryRouter, null,
+                React.createElement(FormRenderer, { form: jsonLogicDisplayTestSpecialtyForm, onChange: () => { }, instance: {
+                        id: '123',
+                        objectId: 'specialty',
+                        name: 'Test Specialty Object Instance',
+                    } })));
+            // Validate that specialty type dropdown renders
+            await screen.findByRole('combobox', { name: 'Specialty Type' });
+        });
+        it('hides fields based on instance data using JsonLogic', async () => {
+            server.use(http.get('/data/objects/license/instances/rnLicense', () => HttpResponse.json(rnLicense)));
+            render(React.createElement(MemoryRouter, null,
+                React.createElement(FormRenderer, { form: jsonLogicDisplayTestSpecialtyForm, onChange: () => { }, instance: {
+                        id: '123',
+                        objectId: 'specialty',
+                        name: 'Test Specialty Object Instance -- hidden',
+                    } })));
+            // Validate that license dropdown renders
+            await screen.findByRole('combobox', { name: 'License' });
+            // Validate that specialty type dropdown does not render
+            expect(screen.queryByRole('combobox', { name: 'Specialty Type' })).not.toBeInTheDocument();
+        });
+        it('shows fields based on instance data using simple conditions', async () => {
+            server.use(http.get('/data/objects/license/instances/rnLicense', () => HttpResponse.json(rnLicense)));
+            render(React.createElement(MemoryRouter, null,
+                React.createElement(FormRenderer, { form: simpleConditionDisplayTestSpecialtyForm, onChange: () => { }, instance: {
+                        id: '123',
+                        objectId: 'specialty',
+                        name: 'Test Specialty Object Instance',
+                    } })));
+            // Validate that specialty type dropdown renders
+            await screen.findByRole('combobox', { name: 'Specialty Type' });
+        });
+        it('hides fields based on instance data using simple conditions', async () => {
+            server.use(http.get('/data/objects/license/instances/rnLicense', () => HttpResponse.json(rnLicense)));
+            render(React.createElement(MemoryRouter, null,
+                React.createElement(FormRenderer, { form: simpleConditionDisplayTestSpecialtyForm, onChange: () => { }, instance: {
+                        id: '123',
+                        objectId: 'specialty',
+                        name: 'Test Specialty Object Instance -- hidden',
+                    } })));
+            // Validate that license dropdown renders
+            await screen.findByRole('combobox', { name: 'License' });
+            // Validate that specialty type dropdown does not render
+            expect(screen.queryByRole('combobox', { name: 'Specialty Type' })).not.toBeInTheDocument();
+        });
+    });
+});

package/dist/published/components/custom/FormV2/tests/FormRendererContainer.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/published/components/custom/FormV2/tests/FormRendererContainer.test.js

@@ -0,0 +1,96 @@
+import * as matchers from '@testing-library/jest-dom/matchers';
+import { render, screen, waitFor, within } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { isEqual } from 'lodash';
+import { http, HttpResponse } from 'msw';
+import { setupServer } from 'msw/node';
+import React from 'react';
+import { MemoryRouter } from 'react-router-dom';
+import { expect, it } from 'vitest';
+import FormRendererContainer from '../FormRendererContainer';
+import { createSpecialtyForm, licenseObject, npLicense, npSpecialtyType1, npSpecialtyType2, rnLicense, rnSpecialtyType1, rnSpecialtyType2, specialtyObject, specialtyTypeObject, } from './test-data';
+expect.extend(matchers);
+const removePoppers = () => {
+    const portalSelectors = ['.MuiAutocomplete-popper'];
+    portalSelectors.forEach((selector) => {
+        // eslint-disable-next-line testing-library/no-node-access
+        document.querySelectorAll(selector).forEach((el) => el.remove());
+    });
+};
+describe('Form component', () => {
+    let server;
+    beforeAll(() => {
+        server = setupServer(http.get('/api/data/objects/specialtyType/effective', () => HttpResponse.json(specialtyTypeObject)), http.get('/api/data/objects/specialtyType/effective', (req) => {
+            const sanitizedVersion = new URL(req.request.url).searchParams.get('sanitizedVersion');
+            if (sanitizedVersion === 'true') {
+                return HttpResponse.json(specialtyTypeObject);
+            }
+        }), http.get('/api/data/objects/license/effective', (req) => {
+            const sanitizedVersion = new URL(req.request.url).searchParams.get('sanitizedVersion');
+            if (sanitizedVersion === 'true') {
+                return HttpResponse.json(licenseObject);
+            }
+        }), http.get('/api/data/objects/specialty/effective', (req) => {
+            const sanitizedVersion = new URL(req.request.url).searchParams.get('sanitizedVersion');
+            if (sanitizedVersion === 'true') {
+                return HttpResponse.json(specialtyObject);
+            }
+        }), http.get('/data/objects/license/effective', () => HttpResponse.json(licenseObject)), http.get('/api/data/objects/license/instances', () => {
+            return HttpResponse.json([rnLicense, npLicense]);
+        }), http.get('/api/data/objects/specialtyType/instances', (req) => {
+            const filter = new URL(req.request.url).searchParams.get('filter');
+            if (filter) {
+                const whereFilter = JSON.parse(filter).where;
+                // The two objects in the array of conditions in the "where" filter represent the potential filters that can be applied when retrieving "specialty" instances.
+                // The first object is for the the validation criteria, but it is empty if the "license" field, which is referenced in the validation criteria, hasn't been filled out yet.
+                // The second object is for the search criteria which the user enters in the "specialty" field, but it is empty if no search text has been entered.
+                if (isEqual(whereFilter, { and: [{}, {}] }))
+                    return HttpResponse.json([
+                        rnSpecialtyType1,
+                        rnSpecialtyType2,
+                        npSpecialtyType1,
+                        npSpecialtyType2,
+                    ]);
+                else if (isEqual(whereFilter, { and: [{ 'licenseType.id': 'rnLicenseType' }, {}] }))
+                    return HttpResponse.json([rnSpecialtyType1, rnSpecialtyType2]);
+                else if (isEqual(whereFilter, { and: [{ 'licenseType.id': 'npLicenseType' }, {}] }))
+                    return HttpResponse.json([npSpecialtyType1, npSpecialtyType2]);
+            }
+        }));
+        server.listen();
+    });
+    afterAll(() => {
+        server.close();
+    });
+    afterEach(() => {
+        server.resetHandlers();
+        removePoppers();
+    });
+    describe('validation criteria', () => {
+        it(`filters related object field with validation criteria that references a defaulted related object's nested data`, async () => {
+            const user = userEvent.setup();
+            server.use(http.get('/api/data/objects/license/instances/rnLicense', () => {
+                return HttpResponse.json(rnLicense);
+            }), http.get('api/data/forms/specialtyForm', () => {
+                return HttpResponse.json(createSpecialtyForm);
+            }));
+            render(React.createElement(MemoryRouter, null,
+                React.createElement(FormRendererContainer, { objectId: 'specialty', formId: 'specialtyForm', dataType: 'objectInstances', actionId: '_create', associatedObject: { propertyId: 'license', instanceId: 'rnLicense' } })));
+            // Validate that the license field is hidden
+            await waitFor(() => expect(screen.queryByRole('combobox', { name: 'License' })).not.toBeInTheDocument());
+            // Validate that specialty type dropdown is only rendering specialty types that are associated with the selected license.
+            const specialtyType = await screen.findByRole('combobox', { name: 'Specialty Type' });
+            await new Promise((r) => setTimeout(r, 5000));
+            await user.click(specialtyType);
+            const openAutocomplete = await screen.findByRole('listbox');
+            await within(openAutocomplete).findByRole('option', { name: 'RN Specialty Type #1' });
+            await within(openAutocomplete).findByRole('option', { name: 'RN Specialty Type #2' });
+            await waitFor(() => expect(within(openAutocomplete).queryByRole('option', { name: 'NP Specialty Type #1' })).not.toBeInTheDocument());
+            await waitFor(() => expect(within(openAutocomplete).queryByRole('option', { name: 'NP Specialty Type #2' })).not.toBeInTheDocument());
+            await user.keyboard('{Escape}');
+            await waitFor(() => {
+                expect(screen.queryByRole('listbox')).not.toBeInTheDocument();
+            });
+        });
+    });
+});

package/dist/published/components/custom/FormV2/tests/test-data.d.ts

@@ -0,0 +1,16 @@
+import { EvokeForm, Obj, ObjectInstance } from '@evoke-platform/context';
+export declare const createSpecialtyForm: EvokeForm;
+export declare const simpleConditionDisplayTestSpecialtyForm: EvokeForm;
+export declare const jsonLogicDisplayTestSpecialtyForm: EvokeForm;
+export declare const licenseObject: Obj;
+export declare const licenseTypeObject: Obj;
+export declare const specialtyObject: Obj;
+export declare const specialtyTypeObject: Obj;
+export declare const rnLicense: ObjectInstance;
+export declare const npLicense: ObjectInstance;
+export declare const rnLicenseType: ObjectInstance;
+export declare const npLicesneType: ObjectInstance;
+export declare const rnSpecialtyType1: ObjectInstance;
+export declare const rnSpecialtyType2: ObjectInstance;
+export declare const npSpecialtyType1: ObjectInstance;
+export declare const npSpecialtyType2: ObjectInstance;

package/dist/published/components/custom/FormV2/tests/test-data.js

@@ -0,0 +1,394 @@
+//Forms
+export const createSpecialtyForm = {
+    id: 'specialtyForm',
+    name: 'Specialty Form',
+    objectId: 'specialty',
+    actionId: '_create',
+    entries: [
+        {
+            parameterId: 'name',
+            type: 'input',
+            display: {
+                label: 'Name',
+            },
+        },
+        {
+            parameterId: 'specialtyType',
+            type: 'input',
+            display: {
+                label: 'Specialty Type',
+                relatedObjectDisplay: 'dropdown',
+            },
+        },
+        {
+            parameterId: 'license',
+            type: 'input',
+            display: {
+                label: 'License',
+                relatedObjectDisplay: 'dropdown',
+            },
+        },
+    ],
+};
+export const simpleConditionDisplayTestSpecialtyForm = {
+    id: 'specialtyForm',
+    name: 'Specialty Form',
+    objectId: 'specialty',
+    actionId: 'simpleConditionDisplayTest',
+    entries: [
+        {
+            parameterId: 'specialtyType',
+            type: 'input',
+            display: {
+                label: 'Specialty Type',
+                relatedObjectDisplay: 'dropdown',
+                visibility: {
+                    operator: 'all',
+                    conditions: [
+                        {
+                            property: 'name',
+                            operator: 'eq',
+                            value: 'Test Specialty Object Instance',
+                            isInstanceProperty: true,
+                        },
+                    ],
+                },
+            },
+        },
+        {
+            parameterId: 'license',
+            type: 'input',
+            display: {
+                label: 'License',
+                relatedObjectDisplay: 'dropdown',
+            },
+        },
+    ],
+};
+export const jsonLogicDisplayTestSpecialtyForm = {
+    id: 'specialtyForm',
+    name: 'Specialty Form',
+    objectId: 'specialty',
+    actionId: 'jsonLogicDisplayTest',
+    entries: [
+        {
+            parameterId: 'specialtyType',
+            type: 'input',
+            display: {
+                label: 'Specialty Type',
+                relatedObjectDisplay: 'dropdown',
+                visibility: {
+                    '===': [
+                        {
+                            var: 'instance.name',
+                        },
+                        'Test Specialty Object Instance',
+                    ],
+                },
+            },
+        },
+        {
+            parameterId: 'license',
+            type: 'input',
+            display: {
+                label: 'License',
+                relatedObjectDisplay: 'dropdown',
+            },
+        },
+    ],
+};
+// Objects
+export const licenseObject = {
+    id: 'license',
+    name: 'License',
+    properties: [
+        {
+            id: 'name',
+            name: 'License Number',
+            type: 'string',
+        },
+        {
+            id: 'status',
+            name: 'Status',
+            type: 'string',
+            enum: ['Active', 'Inactive'],
+        },
+        {
+            id: 'licenseType',
+            name: 'License Type',
+            type: 'object',
+            objectId: 'licenseType',
+        },
+    ],
+    actions: [
+        {
+            id: '_update',
+            name: 'Update',
+            type: 'update',
+            outputEvent: 'License Updated',
+        },
+        {
+            id: '_delete',
+            name: 'Delete',
+            type: 'delete',
+            outputEvent: 'License Deleted',
+        },
+        {
+            id: '_create',
+            name: 'Create',
+            type: 'create',
+            outputEvent: 'License Created',
+        },
+    ],
+};
+export const licenseTypeObject = {
+    id: 'licenseType',
+    name: 'License Type',
+    properties: [
+        {
+            id: 'name',
+            name: 'Name',
+            type: 'string',
+        },
+        {
+            id: 'licenseNumberPrefix',
+            name: 'License Number Prefix',
+            type: 'string',
+        },
+    ],
+    actions: [
+        {
+            id: '_update',
+            name: 'Update',
+            type: 'update',
+            outputEvent: 'License Type Updated',
+        },
+        {
+            id: '_delete',
+            name: 'Delete',
+            type: 'delete',
+            outputEvent: 'License Type Deleted',
+        },
+        {
+            id: '_create',
+            name: 'Create',
+            type: 'create',
+            outputEvent: 'License Type Created',
+        },
+    ],
+};
+export const specialtyObject = {
+    id: 'specialty',
+    name: 'Specialty',
+    properties: [
+        {
+            id: 'name',
+            name: 'Name',
+            type: 'string',
+        },
+        {
+            id: 'specialtyType',
+            name: 'Specialty Type',
+            type: 'object',
+            objectId: 'specialtyType',
+        },
+        {
+            id: 'license',
+            name: 'License',
+            type: 'object',
+            objectId: 'license',
+        },
+    ],
+    actions: [
+        {
+            id: '_update',
+            name: 'Update',
+            type: 'update',
+            outputEvent: 'Specialty Updated',
+        },
+        {
+            id: '_delete',
+            name: 'Delete',
+            type: 'delete',
+            outputEvent: 'Specialty Deleted',
+        },
+        {
+            id: '_create',
+            name: 'Create',
+            type: 'create',
+            outputEvent: 'Specialty Created',
+            parameters: [
+                {
+                    id: 'name',
+                    name: 'Name',
+                    type: 'string',
+                },
+                {
+                    id: 'specialtyType',
+                    name: 'Specialty Type',
+                    type: 'object',
+                    objectId: 'specialtyType',
+                    validation: {
+                        criteria: {
+                            $and: [{ 'licenseType.id': '{{{input.license.licenseType.id}}}' }],
+                        },
+                    },
+                },
+                {
+                    id: 'license',
+                    name: 'License',
+                    type: 'object',
+                    objectId: 'license',
+                },
+            ],
+        },
+        {
+            id: 'jsonLogicDisplayTest',
+            name: 'JsonLogic Display Test',
+            type: 'update',
+            outputEvent: 'Specialty Updated',
+            parameters: [
+                {
+                    id: 'specialtyType',
+                    name: 'Specialty Type',
+                    type: 'object',
+                    objectId: 'specialtyType',
+                },
+                {
+                    id: 'license',
+                    name: 'License',
+                    type: 'object',
+                    objectId: 'license',
+                },
+            ],
+        },
+        {
+            id: 'simpleConditionDisplayTest',
+            name: 'Simple Condition Display Test',
+            type: 'update',
+            outputEvent: 'Specialty Updated',
+            parameters: [
+                {
+                    id: 'specialtyType',
+                    name: 'Specialty Type',
+                    type: 'object',
+                    objectId: 'specialtyType',
+                },
+                {
+                    id: 'license',
+                    name: 'License',
+                    type: 'object',
+                    objectId: 'license',
+                },
+            ],
+        },
+    ],
+};
+export const specialtyTypeObject = {
+    id: 'specialtyType',
+    name: 'Specialty Type',
+    properties: [
+        {
+            id: 'name',
+            name: 'Name',
+            type: 'string',
+        },
+        {
+            id: 'licenseType',
+            name: 'License Type',
+            type: 'object',
+            objectId: 'licenseType',
+        },
+    ],
+    actions: [
+        {
+            id: '_update',
+            name: 'Update',
+            type: 'update',
+            outputEvent: 'Specialty Type Updated',
+        },
+        {
+            id: '_delete',
+            name: 'Delete',
+            type: 'delete',
+            outputEvent: 'Specialty Type Deleted',
+        },
+        {
+            id: '_create',
+            name: 'Create',
+            type: 'create',
+            outputEvent: 'Specialty Type Created',
+        },
+    ],
+};
+// Instances
+export const rnLicense = {
+    id: 'rnLicense',
+    objectId: 'license',
+    name: 'RN License',
+    licenseType: {
+        id: 'rnLicenseType',
+        name: 'RN License Type',
+    },
+    status: 'Active',
+};
+export const npLicense = {
+    id: 'npLicense',
+    objectId: 'license',
+    name: 'NP License',
+    licenseType: {
+        id: 'npLicenseType',
+        name: 'NP License Type',
+    },
+    status: 'Active',
+};
+export const rnLicenseType = {
+    id: 'rnLicenseType',
+    objectId: 'licenseType',
+    name: 'RN License Type',
+    licenseNumberPrefix: 'RN',
+};
+export const npLicesneType = {
+    id: 'npLicenseType',
+    objectId: 'licenseType',
+    name: 'NP License Type',
+    licenseNumberPrefix: 'NP',
+};
+export const rnSpecialtyType1 = {
+    id: 'specialtyType1',
+    objectId: 'specialtyType',
+    name: 'RN Specialty Type #1',
+    int: 1,
+    licenseType: {
+        id: 'rnLicenseType',
+        name: 'RN License Type',
+    },
+};
+export const rnSpecialtyType2 = {
+    id: 'specialtyType2',
+    objectId: 'specialtyType',
+    name: 'RN Specialty Type #2',
+    int: 1,
+    licenseType: {
+        id: 'rnLicenseType',
+        name: 'RN License Type',
+    },
+};
+export const npSpecialtyType1 = {
+    id: 'specialtyType3',
+    objectId: 'specialtyType',
+    name: 'NP Specialty Type #1',
+    licenseType: {
+        id: 'npLicenseType',
+        name: 'NP License Type',
+    },
+};
+export const npSpecialtyType2 = {
+    id: 'specialtyType4',
+    objectId: 'specialtyType',
+    name: 'NP Specialty Type #2',
+    licenseType: {
+        id: 'npLicenseType',
+        name: 'NP License Type',
+    },
+};