@tellescope/sdk 1.256.16 → 2.0.0-beta.1

package/src/tests/setup.ts

@@ -9,19 +9,55 @@ import {
   assert,
 } from "@tellescope/testing"
 
+import { test_support_request } from "./setup_isolated"
+
 const host = process.env.API_URL || 'http://localhost:8080' as const
 const [email, password] = [process.env.TEST_EMAIL, process.env.TEST_PASSWORD]
 const [nonAdminEmail, nonAdminPassword] = [process.env.NON_ADMIN_EMAIL, process.env.NON_ADMIN_PASSWORD]
-const businessId = '60398b1131a295e64f084ff6'
 
+/** The hand-seeded shared fixture this suite was written against; still the default. */
+export const LEGACY_TEST_BUSINESS_ID = '60398b1131a295e64f084ff6'
+const businessId = process.env.TEST_BUSINESS_ID || LEGACY_TEST_BUSINESS_ID
+// The legacy fixture's local API key. `npm run bootstrap` writes a provisioned tenant's key to
+// TEST_API_KEY, so a fresh checkout does not need a copy of anyone's database.
+const apiKey = process.env.TEST_API_KEY || '3n5q0SCBT_iUvZz-b9BJtX7o7HQUVJ9v132PgHJNJsg.'
+
+// exit 1, not 0: a bare process.exit() reports success, which turns "nobody configured the
+// credentials" into a silently passing test run
 if (!(email && password)) {
   console.error("Set TEST_EMAIL and TEST_PASSWORD")
-  process.exit()
+  process.exit(1)
 }
 
 if (!(nonAdminEmail && nonAdminPassword)) {
   console.error("Set NON_ADMIN_EMAIL and NON_ADMIN_PASSWORD")
-  process.exit()
+  process.exit(1)
+}
+
+/**
+ * Per-run database reset for whichever tenant the fixture is pointed at.
+ *
+ * The legacy path is `sdk.reset_db()` (POST /reset-demo): it deletes a HARDCODED businessId's records
+ * plus six global throttle namespaces, and requires a session whose email is in the API's
+ * ADMIN_EMAILS allowlist — so it does nothing useful for, and is not even authorized for, a tenant
+ * provisioned by /test-support. That tenant resets through /test-support/reset-tenant instead, which
+ * is scoped to its own businessId and keeps the org, users, API keys and roles the caller is holding.
+ *
+ * `clearGlobalThrottles` is requested here (and honored only under LOCAL) because this is the shared
+ * fixture: setup_tests deliberately exhausts login throttles and must clear them, exactly as
+ * reset_db did. Isolated tests use `reset_isolated_tenant`, which never touches global state.
+ */
+export const reset_test_tenant = async (sdk: Session) => {
+  const id = sdk.userInfo?.businessId || businessId
+  const provisioned = process.env.TEST_TENANT_PROVISIONED === 'true' || id !== LEGACY_TEST_BUSINESS_ID
+  if (!provisioned) { await sdk.reset_db(); return }
+
+  const { status, body } = await test_support_request('/reset-tenant', {
+    businessId: id, clearGlobalThrottles: true,
+  })
+  if (status !== 200) {
+    throw new Error(`test-support /reset-tenant failed (${status}): ${JSON.stringify(body)}`)
+  }
 }
 
 const passOnAnyResult = { shouldError: false, onResult: () => true }
@@ -49,7 +85,7 @@ export const setup_tests = async (sdk: Session, sdkNonAdmin: Session) => {
 
   await async_test(
     'test_authenticated (with API Key)', 
-    (new Session({ host, apiKey: '3n5q0SCBT_iUvZz-b9BJtX7o7HQUVJ9v132PgHJNJsg.' /* local test key */  })).test_authenticated, 
+    (new Session({ host, apiKey })).test_authenticated, 
     { expectedResult: 'Authenticated!' }
   )
 
@@ -71,7 +107,7 @@ export const setup_tests = async (sdk: Session, sdkNonAdmin: Session) => {
     passOnAnyResult
   )
 
-  const badEnduserSDK = new EnduserSession({ host, businessId });
+  const badEnduserSDK = new EnduserSession({ host, businessId: sdk.userInfo.businessId });
   await badEnduserSDK.authenticate('bademail@tellescope.com', 'badpassword').catch(console.error)
   await badEnduserSDK.authenticate('bademail@tellescope.com', 'badpassword').catch(console.error)
   await badEnduserSDK.authenticate('bademail@tellescope.com', 'badpassword').catch(console.error)
@@ -89,7 +125,7 @@ export const setup_tests = async (sdk: Session, sdkNonAdmin: Session) => {
   )
 
   // prevent additional login throttling
-  await async_test('reset_db', () => sdk.reset_db(), passOnVoid)
+  await async_test('reset_test_tenant', () => reset_test_tenant(sdk), passOnVoid)
 
   await sdk.logout()
   await async_test<string, string>('test_authenticated - (logout invalidates jwt)', sdk.test_authenticated, { shouldError: true, onError: e => e === 'Unauthenticated' })
@@ -148,7 +184,7 @@ export const setup_tests = async (sdk: Session, sdkNonAdmin: Session) => {
   await sdkNonAdmin.authenticate(nonAdminEmail, nonAdminPassword)
 
   // may do some stuff in background after returning
-  await async_test('reset_db', () => sdk.reset_db(), passOnVoid)
+  await async_test('reset_test_tenant', () => reset_test_tenant(sdk), passOnVoid)
   await wait(undefined, 250)
 
   // Prevent test-triggered notifications (e.g. timeTrackRejected, inbound-message

package/src/tests/setup_isolated.ts

@@ -103,6 +103,16 @@ export const set_email_verification_code = async (email: string, code: string) =
   post('/set-email-verification-code', { email, code })
 )
 
+/**
+ * Empties a provisioned tenant's records while keeping the tenant, its users, API keys and roles —
+ * for a test that wants a clean slate between phases without re-provisioning.
+ *
+ * Records only: the shared login/IP throttle namespaces are NOT cleared, so this stays safe to call
+ * while another suite is running. (setup.ts's `reset_test_tenant` does ask for those, because the
+ * shared fixture deliberately exhausts login throttles.)
+ */
+export const reset_isolated_tenant = async (businessId: string) => post('/reset-tenant', { businessId })
+
 /** Raw access, for tests that need to assert on the response of a rejected call. */
 export const test_support_request = async (path: string, body: object) => {
   const r = await axios.request({

package/src/tests/socket_tests.ts

@@ -16,6 +16,7 @@ import {
 } from "@tellescope/types-utilities"
 import { EnduserSession } from "../enduser"
 import { Session, /* APIQuery */ } from "../sdk"
+import { reset_test_tenant } from "./setup"
 import { PLACEHOLDER_ID } from "@tellescope/constants"
 import { UserSession } from "@tellescope/types-models"
 
@@ -29,7 +30,7 @@ const host = process.env.API_URL || 'http://localhost:8080'
 const [email, password] = [process.env.TEST_EMAIL, process.env.TEST_PASSWORD]
 const [email2, password2] = [process.env.TEST_EMAIL_2, process.env.TEST_PASSWORD_2]
 const [nonAdminEmail, nonAdminPassword] = [process.env.NON_ADMIN_EMAIL, process.env.NON_ADMIN_PASSWORD]
-const businessId = '60398b1131a295e64f084ff6'
+const businessId = process.env.TEST_BUSINESS_ID || '60398b1131a295e64f084ff6'
 
 const subUserEmail = process.env.SUB_EMAIL
 const otherSubUserEmail = process.env.OTHER_SUB_EMAIL
@@ -487,7 +488,7 @@ const cleanup_cache = () => {
 
   try {
     await user1.authenticate(email, password)
-    await user1.reset_db()
+    await reset_test_tenant(user1)
 
     await Promise.all([
       user2.authenticate(email2, password2), // generate authToken + socket connection for API keyj

package/src/tests/tests.ts

@@ -123,6 +123,9 @@ import { register_business_id_injection_tests } from "./api_tests/security/regis
 import { handle_incoming_communication_cross_tenant_tests } from "./api_tests/security/handle-incoming-communication-cross-tenant.test";
 import { sanitize_user_html_xss_tests } from "./api_tests/security/sanitize-user-html.test";
 import { sanitize_user_html_with_iframes_tests } from "./api_tests/security/sanitize-user-html-with-iframes.test";
+import { validation_behavior_lock_tests } from "./api_tests/validation_behavior_locks.test";
+import { templated_message_date_field_tests } from "./api_tests/templated_message_date_fields.test";
+import { templated_message_link_tests } from "./api_tests/templated_message_links.test";
 import { prototype_pollution_tests } from "./api_tests/security/prototype-pollution.test";
 import { enduser_cross_create_tests } from "./api_tests/security/enduser-cross-create.test";
 import { globalunique_leak_tests } from "./api_tests/security/globalunique-conflict-redaction.test";
@@ -140,6 +143,7 @@ import { automated_actions_process_gate_tests } from "./api_tests/security/autom
 import { schema_adminonly_enforcement_tests } from "./api_tests/security/schema-adminonly-enforcement.test";
 import { startlinktoken_escalation_tests } from "./api_tests/security/startlinktoken-enduser-staff-escalation.test";
 import { form_logic_js_execution_checks } from "./api_tests/security/form-logic-js-execution.test";
+import { rich_text_answer_sanitized_on_write_checks } from "./api_tests/security/rich-text-answer-sanitized-on-write.test";
 import { bulk_assignment_tests } from "./api_tests/bulk_assignment.test";
 import { tickets_bulk_assign_care_team_tests } from "./api_tests/tickets_bulk_assign_care_team.test";
 import { managed_content_enduser_access_tests } from "./api_tests/managed_content_enduser_access.test";
@@ -159,12 +163,18 @@ import { conditional_logic_medication_unit_tests } from "./unit_tests/conditiona
 import { phone_validation_unit_tests } from "./unit_tests/phone_validation.test";
 import { openapi_spec_freshness_unit_tests } from "./unit_tests/openapi_spec_freshness.test";
 import { do_not_send_address_unit_tests } from "./unit_tests/do_not_send_address.test";
+import { trigger_title_partials_unit_tests } from "./unit_tests/trigger_title_partials.test";
+import { trigger_contains_matching_checks } from "./api_tests/trigger_contains_matching.test";
 import { organization_signup_checks } from "./api_tests/organization_signup.test";
 import { add_to_journey_foreign_enduserid_checks } from "./api_tests/security/add-to-journey-foreign-enduserid.test";
 import { tickets_bulk_assign_from_queue_checks } from "./api_tests/tickets_bulk_assign_from_queue.test";
 import { enduser_observations_auto_review_checks } from "./api_tests/enduser_observations_auto_review.test";
 import { file_link_session_confinement_checks } from "./api_tests/security/file-link-session-confinement.test";
+import { appointment_reschedule_ownership_checks } from "./api_tests/security/appointment-reschedule-ownership.test";
+import { load_threads_care_team_checks } from "./api_tests/load_threads_care_team.test";
 import { run_isolated_in_parallel } from "./setup_isolated";
+import { enduser_fields_sync_checks } from "./api_tests/enduser_fields_sync.test";
+import { user_logs_restore_deleted_checks } from "./api_tests/user_logs_restore_deleted.test";
 import { elation_user_id_tests } from "./api_tests/elation_user_id.test";
 import { organization_settings_duplicates_tests } from "./api_tests/organization_settings_duplicates.test";
 import { stedi_approval_tests } from "./api_tests/stedi_approval.test";
@@ -205,7 +215,7 @@ const otherSubUserEmail = process.env.OTHER_SUB_EMAIL
 const subSubUserEmail = process.env.SUB_SUB_EMAIL
 
 const userId = '60398b0231a295e64f084fd9'
-const businessId = '60398b1131a295e64f084ff6'
+const businessId = process.env.TEST_BUSINESS_ID || '60398b1131a295e64f084ff6'
 
 // const example_SDK_usage = async () => {
 //   // initialize SDK and authenticate a user
@@ -256,7 +266,7 @@ const enduserSDKDifferentBusinessId = new EnduserSession({ host, businessId: '80
 
 if (!(email && mfaEmail && mfaPassword && subUserEmail && otherSubUserEmail && subSubUserEmail && password && email2 && password2 && nonAdminEmail && nonAdminPassword)) {
   console.error("Set TEST_EMAIL and TEST_PASSWORD")
-  process.exit()
+  process.exit(1) // 1, not 0: an unconfigured run must not report success
 }
 
 const recordNotFound =  { shouldError: true, onError: (e: { message: string }) => e.message === 'Could not find a record for the given id' } 
@@ -15391,6 +15401,7 @@ const ip_address_form_tests = async () => {
     await phone_validation_unit_tests()
     await openapi_spec_freshness_unit_tests()
     await do_not_send_address_unit_tests()
+    await trigger_title_partials_unit_tests()
     await replace_enduser_template_values_tests()
     await safe_json_parse_template_tests()
     await replace_form_field_template_values_tests()
@@ -15406,7 +15417,13 @@ const ip_address_form_tests = async () => {
       { name: 'Tickets bulk assign from queue', run: tickets_bulk_assign_from_queue_checks },
       { name: 'Vital auto-review on create', run: enduser_observations_auto_review_checks },
       { name: '$JS in stored conditional logic', run: form_logic_js_execution_checks },
+      { name: 'Rich Text answers sanitized on write', run: rich_text_answer_sanitized_on_write_checks },
       { name: 'Shared file link session confinement', run: file_link_session_confinement_checks },
+      { name: 'book_appointment reschedule ownership', run: appointment_reschedule_ownership_checks },
+      { name: 'Enduser fields sync schema round-trip', run: enduser_fields_sync_checks },
+      { name: 'Trigger contains title matching', run: trigger_contains_matching_checks },
+      { name: 'user_logs restore_deleted', run: user_logs_restore_deleted_checks },
+      { name: 'Load threads care team', run: load_threads_care_team_checks },
     ])
     await embeddables_auth_token_tests({ sdk, sdkNonAdmin })
     await proxy_image_ssrf_tests({ sdk, sdkNonAdmin })
@@ -15452,6 +15469,9 @@ const ip_address_form_tests = async () => {
     await self_admin_role_assignment_tests({ sdk, sdkNonAdmin })
     await sanitize_user_html_xss_tests()
     await sanitize_user_html_with_iframes_tests()
+    await validation_behavior_lock_tests()
+    await templated_message_date_field_tests()
+    await templated_message_link_tests()
     await prototype_pollution_tests()
     await account_switcher_tests({ sdk, sdkNonAdmin })
     await totp_mfa_tests({ sdk, sdkNonAdmin })

package/src/tests/unit_tests/trigger_title_partials.test.ts

@@ -0,0 +1,174 @@
+import { title_matches_partials } from "@tellescope/utilities"
+
+/**
+ * Unit coverage for the shared "contains" matcher behind the Problem Created / Order Created title
+ * filters. The backend call sites (enduser_problems.ts, enduser_orders.ts, handle_order_created)
+ * all delegate here, so the semantics are pinned in one place:
+ *
+ *  - each list is OR internally, the two lists AND together
+ *  - the case-sensitive list is `titlePartials`, the case-insensitive one `titlePartialsIgnoreCase`
+ *  - entries are trimmed, and blank-after-trim entries are dropped rather than matching everything
+ *  - no list set (or every entry blank) means "leave blank for all"
+ *  - a missing/empty title never satisfies a non-empty list
+ */
+
+let failures = 0
+let passed = 0
+
+const assert = (name: string, actual: boolean, expected: boolean) => {
+  if (actual === expected) {
+    passed++
+    console.log(`  ✓ ${name}`)
+  } else {
+    failures++
+    console.error(`  ✗ ${name} — expected ${expected}, got ${actual}`)
+  }
+}
+
+const run_unset_tests = () => {
+  console.log("\n[title_matches_partials — unset lists mean no filter]")
+
+  assert("both lists undefined", title_matches_partials('Endometriosis, unspecified'), true)
+  assert("both lists empty arrays", title_matches_partials('Endometriosis', [], []), true)
+  assert("undefined title with no lists set", title_matches_partials(undefined), true)
+  assert("empty title with no lists set", title_matches_partials(''), true)
+  assert("null title with no lists set", title_matches_partials(null), true)
+  assert("all-blank case-sensitive list counts as unset", title_matches_partials('Common cold', ['   ']), true)
+  assert("all-blank case-insensitive list counts as unset", title_matches_partials('Common cold', [], ['', '  ']), true)
+  assert("all-blank lists on an empty title", title_matches_partials('', ['  '], ['\t']), true)
+}
+
+const run_case_sensitive_tests = () => {
+  console.log("\n[title_matches_partials — case sensitive list]")
+
+  assert("substring match", title_matches_partials('Endometriosis, unspecified', ['Endometriosis']), true)
+  assert("prefix fragment match", title_matches_partials('Endometriosis, unspecified', ['Endo']), true)
+  assert("mid-string fragment match", title_matches_partials('Chronic Endometriosis pain', ['metrios']), true)
+  assert("case mismatch does not match", title_matches_partials('Chronic endometriosis pain', ['Endometriosis']), false)
+  assert("uppercase entry does not match lowercase title", title_matches_partials('endometriosis', ['ENDO']), false)
+  assert("exact-equal title matches", title_matches_partials('Endometriosis', ['Endometriosis']), true)
+  assert("unrelated title does not match", title_matches_partials('Common cold', ['Endo']), false)
+
+  // OR within the list
+  assert("OR within list — second entry matches", title_matches_partials('Type 2 Diabetes', ['Endo', 'Diabetes']), true)
+  assert("OR within list — no entry matches", title_matches_partials('Common cold', ['Endo', 'Diabetes']), false)
+}
+
+const run_case_insensitive_tests = () => {
+  console.log("\n[title_matches_partials — case insensitive list]")
+
+  assert("lowercase entry matches capitalized title", title_matches_partials('Semaglutide 0.25mg', [], ['semaglutide']), true)
+  assert("lowercase entry matches uppercase title", title_matches_partials('SEMAGLUTIDE injection', [], ['semaglutide']), true)
+  assert("uppercase entry matches lowercase title", title_matches_partials('semaglutide injection', [], ['SEMAGLUTIDE']), true)
+  assert("mixed-case entry matches", title_matches_partials('Chronic endometriosis pain', [], ['EnDoMeTrIoSiS']), true)
+  assert("unrelated title does not match", title_matches_partials('Tirzepatide 5mg', [], ['semaglutide']), false)
+  assert("OR within list — second entry matches", title_matches_partials('Tirzepatide 5mg', [], ['sema', 'TIRZ']), true)
+}
+
+const run_trimming_tests = () => {
+  console.log("\n[title_matches_partials — trimming and blank entries]")
+
+  assert("padded entry is trimmed before matching", title_matches_partials('Endometriosis, unspecified', ['  Endo  ']), true)
+  assert("padded case-insensitive entry is trimmed", title_matches_partials('SEMAGLUTIDE injection', [], ['  semaglutide  ']), true)
+  assert(
+    "blank sibling entry is ignored, real entry still matches",
+    title_matches_partials('Endometriosis', ['Endo', '   ']),
+    true,
+  )
+  assert(
+    "blank sibling entry does not make a non-matching title match",
+    title_matches_partials('Common cold', ['Endo', '   ']),
+    false,
+  )
+  assert(
+    "a list of only blanks counts as unset rather than as a match-everything entry",
+    title_matches_partials('Common cold', ['', ' ', '\t']),
+    true, // unset — and per the next check it cannot rescue a failing sibling list either
+  )
+  assert(
+    "blank case-sensitive list does not rescue a failing case-insensitive list",
+    title_matches_partials('Common cold', ['  '], ['semaglutide']),
+    false,
+  )
+  assert(
+    "whitespace-only title against a real entry",
+    title_matches_partials('   ', ['Endo']),
+    false,
+  )
+}
+
+const run_both_lists_tests = () => {
+  console.log("\n[title_matches_partials — the two lists AND together]")
+
+  assert(
+    "both lists match",
+    title_matches_partials('Endometriosis, unspecified', ['Endo'], ['unspecified']),
+    true,
+  )
+  assert(
+    "case-sensitive list matches, case-insensitive does not",
+    title_matches_partials('Endometriosis, unspecified', ['Endo'], ['diabetes']),
+    false,
+  )
+  assert(
+    "case-insensitive list matches, case-sensitive does not",
+    title_matches_partials('Endometriosis, unspecified', ['ENDO'], ['endometriosis']),
+    false,
+  )
+  assert(
+    "neither list matches",
+    title_matches_partials('Common cold', ['Endo'], ['semaglutide']),
+    false,
+  )
+  assert(
+    "same fragment in both lists, case differing — case-sensitive one decides",
+    title_matches_partials('chronic endometriosis', ['Endometriosis'], ['endometriosis']),
+    false,
+  )
+}
+
+const run_missing_title_tests = () => {
+  console.log("\n[title_matches_partials — absent or empty title with a filter set]")
+
+  assert("undefined title vs case-sensitive list", title_matches_partials(undefined, ['Endo']), false)
+  assert("undefined title vs case-insensitive list", title_matches_partials(undefined, [], ['endo']), false)
+  assert("null title vs a set list", title_matches_partials(null, ['Endo']), false)
+  assert("empty-string title vs a set list", title_matches_partials('', ['Endo']), false)
+  assert("empty-string title vs both lists set", title_matches_partials('', ['Endo'], ['endo']), false)
+}
+
+const run_literal_matching_tests = () => {
+  console.log("\n[title_matches_partials — entries are literal, never regex]")
+
+  assert("hyphenated fragment matches literally", title_matches_partials('Diabetes Type-2', ['Type-2']), true)
+  assert("dosage fragment matches literally", title_matches_partials('Semaglutide 10mg', ['10mg']), true)
+  assert("dot is not a wildcard", title_matches_partials('Semaglutide 0x25mg', ['0.25']), false)
+  assert("dot matches itself", title_matches_partials('Semaglutide 0.25mg', ['0.25']), true)
+  assert("regex metacharacters are literal", title_matches_partials('Order (urgent)', ['(urgent)']), true)
+  assert("regex alternation is literal, not alternation", title_matches_partials('Endometriosis', ['Endo|Diabetes']), false)
+  assert("star is literal", title_matches_partials('a*b', ['a*b']), true)
+  assert("very long entry simply does not match", title_matches_partials('Endometriosis', ['E'.repeat(250)]), false)
+
+  // non-string entries from bad stored data must not throw
+  assert("non-string entries are ignored, not crashed on", title_matches_partials('Endometriosis', [null as any, 'Endo']), true)
+  assert("only non-string entries counts as unset", title_matches_partials('Common cold', [undefined as any]), true)
+}
+
+const run_all = () => {
+  console.log("Running trigger_title_partials unit tests")
+  run_unset_tests()
+  run_case_sensitive_tests()
+  run_case_insensitive_tests()
+  run_trimming_tests()
+  run_both_lists_tests()
+  run_missing_title_tests()
+  run_literal_matching_tests()
+  console.log(`\nResults: ${passed} passed, ${failures} failed`)
+  if (failures > 0) process.exit(1)
+}
+
+if (require.main === module) {
+  run_all()
+}
+
+export { run_all as trigger_title_partials_unit_tests }

package/src/tests/webhooks_tests.ts

@@ -31,7 +31,9 @@ const [nonAdminEmail, nonAdminPassword] = [process.env.NON_ADMIN_EMAIL, process.
 const subUserEmail = process.env.SUB_EMAIL
 
 const host = process.env.API_URL || 'http://localhost:8080'
-const businessId = '60398b1131a295e64f084ff6'
+import { reset_test_tenant } from "./setup"
+
+const businessId = process.env.TEST_BUSINESS_ID || '60398b1131a295e64f084ff6'
 const enduserSDK = new EnduserSession({ host, businessId })
 
 if (!(email && subUserEmail && password && email2 && password2 && nonAdminEmail && nonAdminPassword)) {
@@ -754,7 +756,7 @@ const run_tests = async () => {
   log_header("Webhooks Tests")
   await sdk.authenticate(email, password)
   await sdkSub.authenticate(subUserEmail, password)
-  await sdk.reset_db() 
+  await reset_test_tenant(sdk) 
   await nonAdminSdk.authenticate(nonAdminEmail, nonAdminPassword)
 
   await async_test(

package/tsconfig.cjs.json

@@ -0,0 +1,17 @@
+{
+  // CommonJS build (lib/cjs, also where the runnable tests land); see constants/tsconfig.cjs.json.
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "outDir": "lib/cjs",
+    "tsBuildInfoFile": "lib/cjs/tsconfig.cjs.tsbuildinfo"
+  },
+  "references": [
+    { "path": "../constants/tsconfig.cjs.json" },
+    { "path": "../schema/tsconfig.cjs.json" },
+    { "path": "../testing/tsconfig.cjs.json" },
+    { "path": "../types-client/tsconfig.cjs.json" },
+    { "path": "../utilities/tsconfig.cjs.json" },
+    { "path": "../validation/tsconfig.cjs.json" }
+  ]
+}