@openhi/constructs 0.0.185 → 0.0.187

package/lib/rest-api-lambda.handler.js

@@ -11614,6 +11614,9 @@ var CLAIM_SEARCH_PARAMETERS = [
   { code: "use", type: "token", jsonbPath: "$.use" }
 ];
 
+// src/data/search/registry/clinicalimpression-search-parameters.ts
+var CLINICALIMPRESSION_SEARCH_PARAMETERS = [{ code: "encounter", type: "reference", jsonbPath: "$.encounter" }];
+
 // src/data/search/registry/composition-search-parameters.ts
 var COMPOSITION_SEARCH_PARAMETERS = [
   { code: "status", type: "token", jsonbPath: "$.status" },
@@ -12275,6 +12278,12 @@ var RELATEDPERSON_SEARCH_PARAMETERS = [
   }
 ];
 
+// src/data/search/registry/riskassessment-search-parameters.ts
+var RISKASSESSMENT_SEARCH_PARAMETERS = [
+  { code: "subject", type: "reference", jsonbPath: "$.subject" },
+  { code: "patient", type: "reference", jsonbPath: "$.subject" }
+];
+
 // src/data/search/registry/schedule-search-parameters.ts
 var SCHEDULE_SEARCH_PARAMETERS = [
   { code: "active", type: "token", jsonbPath: "$.active" },
@@ -12290,6 +12299,9 @@ var SCHEDULE_SEARCH_PARAMETERS = [
   { code: "specialty", type: "token", jsonbPath: "$.specialty[*]" }
 ];
 
+// src/data/search/registry/servicerequest-search-parameters.ts
+var SERVICEREQUEST_SEARCH_PARAMETERS = [{ code: "encounter", type: "reference", jsonbPath: "$.encounter" }];
+
 // src/data/search/registry/slot-search-parameters.ts
 var SLOT_SEARCH_PARAMETERS = [
   { code: "status", type: "token", jsonbPath: "$.status" },
@@ -12366,6 +12378,7 @@ var STATIC_SEARCH_PARAMETER_MAP = {
   Appointment: APPOINTMENT_SEARCH_PARAMETERS,
   ChargeItem: CHARGEITEM_SEARCH_PARAMETERS,
   Claim: CLAIM_SEARCH_PARAMETERS,
+  ClinicalImpression: CLINICALIMPRESSION_SEARCH_PARAMETERS,
   Composition: COMPOSITION_SEARCH_PARAMETERS,
   Condition: CONDITION_SEARCH_PARAMETERS,
   Coverage: COVERAGE_SEARCH_PARAMETERS,
@@ -12390,7 +12403,9 @@ var STATIC_SEARCH_PARAMETER_MAP = {
   PractitionerRole: PRACTITIONERROLE_SEARCH_PARAMETERS,
   Procedure: PROCEDURE_SEARCH_PARAMETERS,
   RelatedPerson: RELATEDPERSON_SEARCH_PARAMETERS,
+  RiskAssessment: RISKASSESSMENT_SEARCH_PARAMETERS,
   Schedule: SCHEDULE_SEARCH_PARAMETERS,
+  ServiceRequest: SERVICEREQUEST_SEARCH_PARAMETERS,
   Slot: SLOT_SEARCH_PARAMETERS,
   Specimen: SPECIMEN_SEARCH_PARAMETERS,
   Task: TASK_SEARCH_PARAMETERS
@@ -20433,15 +20448,122 @@ async function listClinicalImpressionsOperation(params) {
 }
 
 // src/data/rest-api/routes/data/clinicalimpression/clinicalimpression-list-route.ts
-async function listClinicalImpressionsRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.CLINICALIMPRESSION,
-    listOperation: listClinicalImpressionsOperation,
-    errorLogContext: "GET /ClinicalImpression list error:"
+var CLINICALIMPRESSION_RESOURCE_TYPE = "ClinicalImpression";
+function stripModifier5(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter5(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch4005(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys5(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter5(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier5(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics5(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(
+    CLINICALIMPRESSION_RESOURCE_TYPE
+  ).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for ClinicalImpression: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference5(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(CLINICALIMPRESSION_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
+  );
+  if (referenceCodes.size === 0) {
+    return void 0;
+  }
+  for (const { rawKey, code } of searchParamKeys) {
+    if (!referenceCodes.has(code)) {
+      continue;
+    }
+    const raw = query[rawKey];
+    const values = typeof raw === "string" ? raw.split(",") : Array.isArray(raw) ? raw.flatMap((v) => v.split(",")) : [];
+    for (const v of values) {
+      const trimmed = v.trim();
+      if (trimmed.length === 0) {
+        continue;
+      }
+      if (parseTypedReference(trimmed) === void 0) {
+        return { rawKey, value: trimmed };
+      }
+    }
+  }
+  return void 0;
+}
+async function listClinicalImpressionsRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys5(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.CLINICALIMPRESSION,
+      listOperation: listClinicalImpressionsOperation,
+      errorLogContext: "GET /ClinicalImpression list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(
+    CLINICALIMPRESSION_RESOURCE_TYPE
+  );
+  const validCodes = new Set(registered.map((p) => p.code));
+  const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
+  if (unknownCodes.length > 0) {
+    return sendInvalidSearch4005(
+      res,
+      buildUnknownParamDiagnostics5([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference5(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch4005(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Encounter/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: CLINICALIMPRESSION_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(
+      BASE_PATH.CLINICALIMPRESSION,
+      result.entries
+    );
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(
+      res,
+      err,
+      "GET /ClinicalImpression search error:"
+    );
+  }
+}
 
 // src/data/operations/data/clinicalimpression/clinicalimpression-update-operation.ts
 async function updateClinicalImpressionOperation(params) {
@@ -21289,30 +21411,30 @@ async function listCompositionsOperation(params) {
 
 // src/data/rest-api/routes/data/composition/composition-list-route.ts
 var COMPOSITION_RESOURCE_TYPE = "Composition";
-function stripModifier5(key) {
+function stripModifier6(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter5(key) {
+function isResultParameter6(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch4005(res, diagnostics) {
+function sendInvalidSearch4006(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys5(query) {
+function extractSearchParamKeys6(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter5(rawKey)) {
+    if (isResultParameter6(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier5(rawKey) });
+    out.push({ rawKey, code: stripModifier6(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics5(unknownCodes) {
+function buildUnknownParamDiagnostics6(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(COMPOSITION_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -21321,7 +21443,7 @@ function buildUnknownParamDiagnostics5(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference5(query, searchParamKeys) {
+function findMalformedReference6(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(COMPOSITION_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -21347,7 +21469,7 @@ function findMalformedReference5(query, searchParamKeys) {
   return void 0;
 }
 async function listCompositionsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys5(
+  const searchParamKeys = extractSearchParamKeys6(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -21363,17 +21485,17 @@ async function listCompositionsRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch4005(
+    return sendInvalidSearch4006(
       res,
-      buildUnknownParamDiagnostics5([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics6([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference5(
+  const malformedRef = findMalformedReference6(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch4005(
+    return sendInvalidSearch4006(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
     );
@@ -21715,30 +21837,30 @@ async function listConditionsOperation(params) {
 
 // src/data/rest-api/routes/data/condition/condition-list-route.ts
 var CONDITION_RESOURCE_TYPE = "Condition";
-function stripModifier6(key) {
+function stripModifier7(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter6(key) {
+function isResultParameter7(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch4006(res, diagnostics) {
+function sendInvalidSearch4007(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys6(query) {
+function extractSearchParamKeys7(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter6(rawKey)) {
+    if (isResultParameter7(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier6(rawKey) });
+    out.push({ rawKey, code: stripModifier7(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics6(unknownCodes) {
+function buildUnknownParamDiagnostics7(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(CONDITION_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -21747,7 +21869,7 @@ function buildUnknownParamDiagnostics6(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference6(query, searchParamKeys) {
+function findMalformedReference7(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(CONDITION_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -21770,7 +21892,7 @@ function findMalformedReference6(query, searchParamKeys) {
   return void 0;
 }
 async function listConditionsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys6(
+  const searchParamKeys = extractSearchParamKeys7(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -21786,17 +21908,17 @@ async function listConditionsRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch4006(
+    return sendInvalidSearch4007(
       res,
-      buildUnknownParamDiagnostics6([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics7([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference6(
+  const malformedRef = findMalformedReference7(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch4006(
+    return sendInvalidSearch4007(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -22306,30 +22428,30 @@ async function listCoveragesOperation(params) {
 
 // src/data/rest-api/routes/data/coverage/coverage-list-route.ts
 var COVERAGE_RESOURCE_TYPE = "Coverage";
-function stripModifier7(key) {
+function stripModifier8(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter7(key) {
+function isResultParameter8(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch4007(res, diagnostics) {
+function sendInvalidSearch4008(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys7(query) {
+function extractSearchParamKeys8(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter7(rawKey)) {
+    if (isResultParameter8(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier7(rawKey) });
+    out.push({ rawKey, code: stripModifier8(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics7(unknownCodes) {
+function buildUnknownParamDiagnostics8(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(COVERAGE_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -22338,7 +22460,7 @@ function buildUnknownParamDiagnostics7(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference7(query, searchParamKeys) {
+function findMalformedReference8(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(COVERAGE_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -22364,7 +22486,7 @@ function findMalformedReference7(query, searchParamKeys) {
   return void 0;
 }
 async function listCoveragesRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys7(
+  const searchParamKeys = extractSearchParamKeys8(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -22382,17 +22504,17 @@ async function listCoveragesRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch4007(
+    return sendInvalidSearch4008(
       res,
-      buildUnknownParamDiagnostics7([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics8([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference7(
+  const malformedRef = findMalformedReference8(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch4007(
+    return sendInvalidSearch4008(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
     );
@@ -23941,30 +24063,30 @@ async function listDiagnosticReportsOperation(params) {
 
 // src/data/rest-api/routes/data/diagnosticreport/diagnosticreport-list-route.ts
 var DIAGNOSTICREPORT_RESOURCE_TYPE = "DiagnosticReport";
-function stripModifier8(key) {
+function stripModifier9(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter8(key) {
+function isResultParameter9(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch4008(res, diagnostics) {
+function sendInvalidSearch4009(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys8(query) {
+function extractSearchParamKeys9(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter8(rawKey)) {
+    if (isResultParameter9(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier8(rawKey) });
+    out.push({ rawKey, code: stripModifier9(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics8(unknownCodes) {
+function buildUnknownParamDiagnostics9(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(
     DIAGNOSTICREPORT_RESOURCE_TYPE
   ).map((p) => p.code).sort().join(", ");
@@ -23975,7 +24097,7 @@ function buildUnknownParamDiagnostics8(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference8(query, searchParamKeys) {
+function findMalformedReference9(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(DIAGNOSTICREPORT_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -24001,7 +24123,7 @@ function findMalformedReference8(query, searchParamKeys) {
   return void 0;
 }
 async function listDiagnosticReportsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys8(
+  const searchParamKeys = extractSearchParamKeys9(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -24019,17 +24141,17 @@ async function listDiagnosticReportsRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch4008(
+    return sendInvalidSearch4009(
       res,
-      buildUnknownParamDiagnostics8([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics9([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference8(
+  const malformedRef = findMalformedReference9(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch4008(
+    return sendInvalidSearch4009(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
     );
@@ -24213,30 +24335,30 @@ async function listDocumentManifestsOperation(params) {
 
 // src/data/rest-api/routes/data/documentmanifest/documentmanifest-list-route.ts
 var DOCUMENTMANIFEST_RESOURCE_TYPE = "DocumentManifest";
-function stripModifier9(key) {
+function stripModifier10(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter9(key) {
+function isResultParameter10(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch4009(res, diagnostics) {
+function sendInvalidSearch40010(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys9(query) {
+function extractSearchParamKeys10(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter9(rawKey)) {
+    if (isResultParameter10(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier9(rawKey) });
+    out.push({ rawKey, code: stripModifier10(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics9(unknownCodes) {
+function buildUnknownParamDiagnostics10(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(
     DOCUMENTMANIFEST_RESOURCE_TYPE
   ).map((p) => p.code).sort().join(", ");
@@ -24247,7 +24369,7 @@ function buildUnknownParamDiagnostics9(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference9(query, searchParamKeys) {
+function findMalformedReference10(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(DOCUMENTMANIFEST_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -24273,7 +24395,7 @@ function findMalformedReference9(query, searchParamKeys) {
   return void 0;
 }
 async function listDocumentManifestsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys9(
+  const searchParamKeys = extractSearchParamKeys10(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -24291,17 +24413,17 @@ async function listDocumentManifestsRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch4009(
+    return sendInvalidSearch40010(
       res,
-      buildUnknownParamDiagnostics9([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics10([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference9(
+  const malformedRef = findMalformedReference10(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch4009(
+    return sendInvalidSearch40010(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
     );
@@ -24488,30 +24610,30 @@ async function listDocumentReferencesOperation(params) {
 
 // src/data/rest-api/routes/data/documentreference/documentreference-list-route.ts
 var DOCUMENTREFERENCE_RESOURCE_TYPE = "DocumentReference";
-function stripModifier10(key) {
+function stripModifier11(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter10(key) {
+function isResultParameter11(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40010(res, diagnostics) {
+function sendInvalidSearch40011(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys10(query) {
+function extractSearchParamKeys11(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter10(rawKey)) {
+    if (isResultParameter11(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier10(rawKey) });
+    out.push({ rawKey, code: stripModifier11(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics10(unknownCodes) {
+function buildUnknownParamDiagnostics11(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(
     DOCUMENTREFERENCE_RESOURCE_TYPE
   ).map((p) => p.code).sort().join(", ");
@@ -24522,7 +24644,7 @@ function buildUnknownParamDiagnostics10(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference10(query, searchParamKeys) {
+function findMalformedReference11(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(DOCUMENTREFERENCE_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -24548,7 +24670,7 @@ function findMalformedReference10(query, searchParamKeys) {
   return void 0;
 }
 async function listDocumentReferencesRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys10(
+  const searchParamKeys = extractSearchParamKeys11(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -24566,17 +24688,17 @@ async function listDocumentReferencesRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40010(
+    return sendInvalidSearch40011(
       res,
-      buildUnknownParamDiagnostics10([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics11([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference10(
+  const malformedRef = findMalformedReference11(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40010(
+    return sendInvalidSearch40011(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
     );
@@ -24944,30 +25066,30 @@ async function listEncountersOperation(params) {
 
 // src/data/rest-api/routes/data/encounter/encounter-list-route.ts
 var ENCOUNTER_RESOURCE_TYPE = "Encounter";
-function stripModifier11(key) {
+function stripModifier12(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter11(key) {
+function isResultParameter12(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40011(res, diagnostics) {
+function sendInvalidSearch40012(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys11(query) {
+function extractSearchParamKeys12(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter11(rawKey)) {
+    if (isResultParameter12(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier11(rawKey) });
+    out.push({ rawKey, code: stripModifier12(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics11(unknownCodes) {
+function buildUnknownParamDiagnostics12(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(ENCOUNTER_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -24976,7 +25098,7 @@ function buildUnknownParamDiagnostics11(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference11(query, searchParamKeys) {
+function findMalformedReference12(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(ENCOUNTER_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -24999,7 +25121,7 @@ function findMalformedReference11(query, searchParamKeys) {
   return void 0;
 }
 async function listEncountersRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys11(
+  const searchParamKeys = extractSearchParamKeys12(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -25015,17 +25137,17 @@ async function listEncountersRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40011(
+    return sendInvalidSearch40012(
       res,
-      buildUnknownParamDiagnostics11([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics12([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference11(
+  const malformedRef = findMalformedReference12(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40011(
+    return sendInvalidSearch40012(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -25207,30 +25329,30 @@ async function listEndpointsOperation(params) {
 
 // src/data/rest-api/routes/data/endpoint/endpoint-list-route.ts
 var ENDPOINT_RESOURCE_TYPE = "Endpoint";
-function stripModifier12(key) {
+function stripModifier13(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter12(key) {
+function isResultParameter13(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40012(res, diagnostics) {
+function sendInvalidSearch40013(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys12(query) {
+function extractSearchParamKeys13(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter12(rawKey)) {
+    if (isResultParameter13(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier12(rawKey) });
+    out.push({ rawKey, code: stripModifier13(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics12(unknownCodes) {
+function buildUnknownParamDiagnostics13(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(ENDPOINT_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -25239,7 +25361,7 @@ function buildUnknownParamDiagnostics12(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference12(query, searchParamKeys) {
+function findMalformedReference13(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(ENDPOINT_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -25265,7 +25387,7 @@ function findMalformedReference12(query, searchParamKeys) {
   return void 0;
 }
 async function listEndpointsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys12(
+  const searchParamKeys = extractSearchParamKeys13(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -25281,17 +25403,17 @@ async function listEndpointsRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40012(
+    return sendInvalidSearch40013(
       res,
-      buildUnknownParamDiagnostics12([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics13([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference12(
+  const malformedRef = findMalformedReference13(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40012(
+    return sendInvalidSearch40013(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
     );
@@ -26644,30 +26766,30 @@ async function listExplanationOfBenefitsOperation(params) {
 
 // src/data/rest-api/routes/data/explanationofbenefit/explanationofbenefit-list-route.ts
 var EXPLANATIONOFBENEFIT_RESOURCE_TYPE = "ExplanationOfBenefit";
-function stripModifier13(key) {
+function stripModifier14(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter13(key) {
+function isResultParameter14(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40013(res, diagnostics) {
+function sendInvalidSearch40014(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys13(query) {
+function extractSearchParamKeys14(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter13(rawKey)) {
+    if (isResultParameter14(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier13(rawKey) });
+    out.push({ rawKey, code: stripModifier14(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics13(unknownCodes) {
+function buildUnknownParamDiagnostics14(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(
     EXPLANATIONOFBENEFIT_RESOURCE_TYPE
   ).map((p) => p.code).sort().join(", ");
@@ -26678,7 +26800,7 @@ function buildUnknownParamDiagnostics13(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference13(query, searchParamKeys) {
+function findMalformedReference14(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(EXPLANATIONOFBENEFIT_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -26704,7 +26826,7 @@ function findMalformedReference13(query, searchParamKeys) {
   return void 0;
 }
 async function listExplanationOfBenefitsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys13(
+  const searchParamKeys = extractSearchParamKeys14(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -26722,17 +26844,17 @@ async function listExplanationOfBenefitsRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40013(
+    return sendInvalidSearch40014(
       res,
-      buildUnknownParamDiagnostics13([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics14([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference13(
+  const malformedRef = findMalformedReference14(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40013(
+    return sendInvalidSearch40014(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
     );
@@ -26923,30 +27045,30 @@ async function listFamilyMemberHistorysOperation(params) {
 
 // src/data/rest-api/routes/data/familymemberhistory/familymemberhistory-list-route.ts
 var FAMILYMEMBERHISTORY_RESOURCE_TYPE = "FamilyMemberHistory";
-function stripModifier14(key) {
+function stripModifier15(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter14(key) {
+function isResultParameter15(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40014(res, diagnostics) {
+function sendInvalidSearch40015(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys14(query) {
+function extractSearchParamKeys15(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter14(rawKey)) {
+    if (isResultParameter15(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier14(rawKey) });
+    out.push({ rawKey, code: stripModifier15(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics14(unknownCodes) {
+function buildUnknownParamDiagnostics15(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(
     FAMILYMEMBERHISTORY_RESOURCE_TYPE
   ).map((p) => p.code).sort().join(", ");
@@ -26957,7 +27079,7 @@ function buildUnknownParamDiagnostics14(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference14(query, searchParamKeys) {
+function findMalformedReference15(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(FAMILYMEMBERHISTORY_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -26980,7 +27102,7 @@ function findMalformedReference14(query, searchParamKeys) {
   return void 0;
 }
 async function listFamilyMemberHistorysRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys14(
+  const searchParamKeys = extractSearchParamKeys15(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -26998,17 +27120,17 @@ async function listFamilyMemberHistorysRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40014(
+    return sendInvalidSearch40015(
       res,
-      buildUnknownParamDiagnostics14([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics15([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference14(
+  const malformedRef = findMalformedReference15(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40014(
+    return sendInvalidSearch40015(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
     );
@@ -28185,30 +28307,30 @@ async function listImagingStudysOperation(params) {
 
 // src/data/rest-api/routes/data/imagingstudy/imagingstudy-list-route.ts
 var IMAGINGSTUDY_RESOURCE_TYPE = "ImagingStudy";
-function stripModifier15(key) {
+function stripModifier16(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter15(key) {
+function isResultParameter16(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40015(res, diagnostics) {
+function sendInvalidSearch40016(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys15(query) {
+function extractSearchParamKeys16(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter15(rawKey)) {
+    if (isResultParameter16(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier15(rawKey) });
+    out.push({ rawKey, code: stripModifier16(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics15(unknownCodes) {
+function buildUnknownParamDiagnostics16(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(IMAGINGSTUDY_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -28217,7 +28339,7 @@ function buildUnknownParamDiagnostics15(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference15(query, searchParamKeys) {
+function findMalformedReference16(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(IMAGINGSTUDY_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -28243,7 +28365,7 @@ function findMalformedReference15(query, searchParamKeys) {
   return void 0;
 }
 async function listImagingStudysRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys15(
+  const searchParamKeys = extractSearchParamKeys16(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -28259,17 +28381,17 @@ async function listImagingStudysRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40015(
+    return sendInvalidSearch40016(
       res,
-      buildUnknownParamDiagnostics15([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics16([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference15(
+  const malformedRef = findMalformedReference16(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40015(
+    return sendInvalidSearch40016(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
     );
@@ -28446,30 +28568,30 @@ async function listImmunizationsOperation(params) {
 
 // src/data/rest-api/routes/data/immunization/immunization-list-route.ts
 var IMMUNIZATION_RESOURCE_TYPE = "Immunization";
-function stripModifier16(key) {
+function stripModifier17(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter16(key) {
+function isResultParameter17(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40016(res, diagnostics) {
+function sendInvalidSearch40017(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys16(query) {
+function extractSearchParamKeys17(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter16(rawKey)) {
+    if (isResultParameter17(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier16(rawKey) });
+    out.push({ rawKey, code: stripModifier17(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics16(unknownCodes) {
+function buildUnknownParamDiagnostics17(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(IMMUNIZATION_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -28478,7 +28600,7 @@ function buildUnknownParamDiagnostics16(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference16(query, searchParamKeys) {
+function findMalformedReference17(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(IMMUNIZATION_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -28501,7 +28623,7 @@ function findMalformedReference16(query, searchParamKeys) {
   return void 0;
 }
 async function listImmunizationsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys16(
+  const searchParamKeys = extractSearchParamKeys17(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -28517,17 +28639,17 @@ async function listImmunizationsRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40016(
+    return sendInvalidSearch40017(
       res,
-      buildUnknownParamDiagnostics16([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics17([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference16(
+  const malformedRef = findMalformedReference17(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40016(
+    return sendInvalidSearch40017(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -29409,30 +29531,30 @@ async function listInvoicesOperation(params) {
 
 // src/data/rest-api/routes/data/invoice/invoice-list-route.ts
 var INVOICE_RESOURCE_TYPE = "Invoice";
-function stripModifier17(key) {
+function stripModifier18(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter17(key) {
+function isResultParameter18(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40017(res, diagnostics) {
+function sendInvalidSearch40018(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys17(query) {
+function extractSearchParamKeys18(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter17(rawKey)) {
+    if (isResultParameter18(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier17(rawKey) });
+    out.push({ rawKey, code: stripModifier18(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics17(unknownCodes) {
+function buildUnknownParamDiagnostics18(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(INVOICE_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -29441,7 +29563,7 @@ function buildUnknownParamDiagnostics17(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference17(query, searchParamKeys) {
+function findMalformedReference18(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(INVOICE_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -29467,7 +29589,7 @@ function findMalformedReference17(query, searchParamKeys) {
   return void 0;
 }
 async function listInvoicesRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys17(
+  const searchParamKeys = extractSearchParamKeys18(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -29483,17 +29605,17 @@ async function listInvoicesRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40017(
+    return sendInvalidSearch40018(
       res,
-      buildUnknownParamDiagnostics17([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics18([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference17(
+  const malformedRef = findMalformedReference18(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40017(
+    return sendInvalidSearch40018(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
     );
@@ -30165,30 +30287,30 @@ async function listLocationsOperation(params) {
 
 // src/data/rest-api/routes/data/location/location-list-route.ts
 var LOCATION_RESOURCE_TYPE = "Location";
-function stripModifier18(key) {
+function stripModifier19(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter18(key) {
+function isResultParameter19(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40018(res, diagnostics) {
+function sendInvalidSearch40019(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys18(query) {
+function extractSearchParamKeys19(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter18(rawKey)) {
+    if (isResultParameter19(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier18(rawKey) });
+    out.push({ rawKey, code: stripModifier19(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics18(unknownCodes) {
+function buildUnknownParamDiagnostics19(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(LOCATION_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -30197,7 +30319,7 @@ function buildUnknownParamDiagnostics18(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference18(query, searchParamKeys) {
+function findMalformedReference19(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(LOCATION_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -30223,7 +30345,7 @@ function findMalformedReference18(query, searchParamKeys) {
   return void 0;
 }
 async function listLocationsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys18(
+  const searchParamKeys = extractSearchParamKeys19(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -30239,17 +30361,17 @@ async function listLocationsRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40018(
+    return sendInvalidSearch40019(
       res,
-      buildUnknownParamDiagnostics18([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics19([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference18(
+  const malformedRef = findMalformedReference19(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40018(
+    return sendInvalidSearch40019(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
     );
@@ -31617,30 +31739,30 @@ async function listMedicationRequestsOperation(params) {
 
 // src/data/rest-api/routes/data/medicationrequest/medicationrequest-list-route.ts
 var MEDICATIONREQUEST_RESOURCE_TYPE = "MedicationRequest";
-function stripModifier19(key) {
+function stripModifier20(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter19(key) {
+function isResultParameter20(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40019(res, diagnostics) {
+function sendInvalidSearch40020(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys19(query) {
+function extractSearchParamKeys20(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter19(rawKey)) {
+    if (isResultParameter20(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier19(rawKey) });
+    out.push({ rawKey, code: stripModifier20(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics19(unknownCodes) {
+function buildUnknownParamDiagnostics20(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(
     MEDICATIONREQUEST_RESOURCE_TYPE
   ).map((p) => p.code).sort().join(", ");
@@ -31651,7 +31773,7 @@ function buildUnknownParamDiagnostics19(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference19(query, searchParamKeys) {
+function findMalformedReference20(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(MEDICATIONREQUEST_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -31674,7 +31796,7 @@ function findMalformedReference19(query, searchParamKeys) {
   return void 0;
 }
 async function listMedicationRequestsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys19(
+  const searchParamKeys = extractSearchParamKeys20(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -31692,17 +31814,17 @@ async function listMedicationRequestsRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40019(
+    return sendInvalidSearch40020(
       res,
-      buildUnknownParamDiagnostics19([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics20([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference19(
+  const malformedRef = findMalformedReference20(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40019(
+    return sendInvalidSearch40020(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -31893,30 +32015,30 @@ async function listMedicationStatementsOperation(params) {
 
 // src/data/rest-api/routes/data/medicationstatement/medicationstatement-list-route.ts
 var MEDICATIONSTATEMENT_RESOURCE_TYPE = "MedicationStatement";
-function stripModifier20(key) {
+function stripModifier21(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter20(key) {
+function isResultParameter21(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40020(res, diagnostics) {
+function sendInvalidSearch40021(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys20(query) {
+function extractSearchParamKeys21(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter20(rawKey)) {
+    if (isResultParameter21(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier20(rawKey) });
+    out.push({ rawKey, code: stripModifier21(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics20(unknownCodes) {
+function buildUnknownParamDiagnostics21(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(
     MEDICATIONSTATEMENT_RESOURCE_TYPE
   ).map((p) => p.code).sort().join(", ");
@@ -31927,7 +32049,7 @@ function buildUnknownParamDiagnostics20(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference20(query, searchParamKeys) {
+function findMalformedReference21(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(MEDICATIONSTATEMENT_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -31950,7 +32072,7 @@ function findMalformedReference20(query, searchParamKeys) {
   return void 0;
 }
 async function listMedicationStatementsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys20(
+  const searchParamKeys = extractSearchParamKeys21(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -31968,17 +32090,17 @@ async function listMedicationStatementsRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40020(
+    return sendInvalidSearch40021(
       res,
-      buildUnknownParamDiagnostics20([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics21([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference20(
+  const malformedRef = findMalformedReference21(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40020(
+    return sendInvalidSearch40021(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -34835,30 +34957,30 @@ async function listObservationsOperation(params) {
 
 // src/data/rest-api/routes/data/observation/observation-list-route.ts
 var OBSERVATION_RESOURCE_TYPE = "Observation";
-function stripModifier21(key) {
+function stripModifier22(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter21(key) {
+function isResultParameter22(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40021(res, diagnostics) {
+function sendInvalidSearch40022(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys21(query) {
+function extractSearchParamKeys22(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter21(rawKey)) {
+    if (isResultParameter22(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier21(rawKey) });
+    out.push({ rawKey, code: stripModifier22(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics21(unknownCodes) {
+function buildUnknownParamDiagnostics22(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(OBSERVATION_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -34867,7 +34989,7 @@ function buildUnknownParamDiagnostics21(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference21(query, searchParamKeys) {
+function findMalformedReference22(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(OBSERVATION_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -34890,7 +35012,7 @@ function findMalformedReference21(query, searchParamKeys) {
   return void 0;
 }
 async function listObservationsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys21(
+  const searchParamKeys = extractSearchParamKeys22(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -34906,17 +35028,17 @@ async function listObservationsRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40021(
+    return sendInvalidSearch40022(
       res,
-      buildUnknownParamDiagnostics21([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics22([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference21(
+  const malformedRef = findMalformedReference22(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40021(
+    return sendInvalidSearch40022(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -35422,30 +35544,30 @@ async function listOrganizationsOperation(params) {
 
 // src/data/rest-api/routes/data/organization/organization-list-route.ts
 var ORGANIZATION_RESOURCE_TYPE = "Organization";
-function stripModifier22(key) {
+function stripModifier23(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter22(key) {
+function isResultParameter23(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40022(res, diagnostics) {
+function sendInvalidSearch40023(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys22(query) {
+function extractSearchParamKeys23(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter22(rawKey)) {
+    if (isResultParameter23(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier22(rawKey) });
+    out.push({ rawKey, code: stripModifier23(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics22(unknownCodes) {
+function buildUnknownParamDiagnostics23(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(ORGANIZATION_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -35454,7 +35576,7 @@ function buildUnknownParamDiagnostics22(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference22(query, searchParamKeys) {
+function findMalformedReference23(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(ORGANIZATION_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -35480,7 +35602,7 @@ function findMalformedReference22(query, searchParamKeys) {
   return void 0;
 }
 async function listOrganizationsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys22(
+  const searchParamKeys = extractSearchParamKeys23(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -35496,17 +35618,17 @@ async function listOrganizationsRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40022(
+    return sendInvalidSearch40023(
       res,
-      buildUnknownParamDiagnostics22([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics23([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference22(
+  const malformedRef = findMalformedReference23(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40022(
+    return sendInvalidSearch40023(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
     );
@@ -35867,30 +35989,30 @@ async function listPatientsOperation(params) {
 
 // src/data/rest-api/routes/data/patient/patient-list-route.ts
 var PATIENT_RESOURCE_TYPE = "Patient";
-function stripModifier23(key) {
+function stripModifier24(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter23(key) {
+function isResultParameter24(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40023(res, diagnostics) {
+function sendInvalidSearch40024(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys23(query) {
+function extractSearchParamKeys24(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter23(rawKey)) {
+    if (isResultParameter24(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier23(rawKey) });
+    out.push({ rawKey, code: stripModifier24(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics23(unknownCodes) {
+function buildUnknownParamDiagnostics24(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(PATIENT_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -35899,7 +36021,7 @@ function buildUnknownParamDiagnostics23(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference23(query, searchParamKeys) {
+function findMalformedReference24(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(PATIENT_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -35922,7 +36044,7 @@ function findMalformedReference23(query, searchParamKeys) {
   return void 0;
 }
 async function listPatientsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys23(
+  const searchParamKeys = extractSearchParamKeys24(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -35938,17 +36060,17 @@ async function listPatientsRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40023(
+    return sendInvalidSearch40024(
       res,
-      buildUnknownParamDiagnostics23([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics24([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference23(
+  const malformedRef = findMalformedReference24(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40023(
+    return sendInvalidSearch40024(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -36125,30 +36247,30 @@ async function listPaymentNoticesOperation(params) {
 
 // src/data/rest-api/routes/data/paymentnotice/paymentnotice-list-route.ts
 var PAYMENTNOTICE_RESOURCE_TYPE = "PaymentNotice";
-function stripModifier24(key) {
+function stripModifier25(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter24(key) {
+function isResultParameter25(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40024(res, diagnostics) {
+function sendInvalidSearch40025(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys24(query) {
+function extractSearchParamKeys25(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter24(rawKey)) {
+    if (isResultParameter25(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier24(rawKey) });
+    out.push({ rawKey, code: stripModifier25(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics24(unknownCodes) {
+function buildUnknownParamDiagnostics25(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(PAYMENTNOTICE_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -36157,7 +36279,7 @@ function buildUnknownParamDiagnostics24(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference24(query, searchParamKeys) {
+function findMalformedReference25(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(PAYMENTNOTICE_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -36183,7 +36305,7 @@ function findMalformedReference24(query, searchParamKeys) {
   return void 0;
 }
 async function listPaymentNoticesRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys24(
+  const searchParamKeys = extractSearchParamKeys25(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -36199,17 +36321,17 @@ async function listPaymentNoticesRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40024(
+    return sendInvalidSearch40025(
       res,
-      buildUnknownParamDiagnostics24([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics25([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference24(
+  const malformedRef = findMalformedReference25(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40024(
+    return sendInvalidSearch40025(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -36907,30 +37029,30 @@ async function listPractitionersOperation(params) {
 
 // src/data/rest-api/routes/data/practitioner/practitioner-list-route.ts
 var PRACTITIONER_RESOURCE_TYPE = "Practitioner";
-function stripModifier25(key) {
+function stripModifier26(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter25(key) {
+function isResultParameter26(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40025(res, diagnostics) {
+function sendInvalidSearch40026(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys25(query) {
+function extractSearchParamKeys26(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter25(rawKey)) {
+    if (isResultParameter26(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier25(rawKey) });
+    out.push({ rawKey, code: stripModifier26(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics25(unknownCodes) {
+function buildUnknownParamDiagnostics26(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(PRACTITIONER_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -36939,7 +37061,7 @@ function buildUnknownParamDiagnostics25(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference25(query, searchParamKeys) {
+function findMalformedReference26(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(PRACTITIONER_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -36965,7 +37087,7 @@ function findMalformedReference25(query, searchParamKeys) {
   return void 0;
 }
 async function listPractitionersRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys25(
+  const searchParamKeys = extractSearchParamKeys26(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -36981,17 +37103,17 @@ async function listPractitionersRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40025(
+    return sendInvalidSearch40026(
       res,
-      buildUnknownParamDiagnostics25([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics26([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference25(
+  const malformedRef = findMalformedReference26(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40025(
+    return sendInvalidSearch40026(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -37147,30 +37269,30 @@ async function getPractitionerRoleByIdRoute(req, res) {
 
 // src/data/rest-api/routes/data/practitionerrole/practitionerrole-list-route.ts
 var PRACTITIONERROLE_RESOURCE_TYPE = "PractitionerRole";
-function stripModifier26(key) {
+function stripModifier27(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter26(key) {
+function isResultParameter27(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40026(res, diagnostics) {
+function sendInvalidSearch40027(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys26(query) {
+function extractSearchParamKeys27(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter26(rawKey)) {
+    if (isResultParameter27(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier26(rawKey) });
+    out.push({ rawKey, code: stripModifier27(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics26(unknownCodes) {
+function buildUnknownParamDiagnostics27(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(
     PRACTITIONERROLE_RESOURCE_TYPE
   ).map((p) => p.code).sort().join(", ");
@@ -37181,7 +37303,7 @@ function buildUnknownParamDiagnostics26(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference26(query, searchParamKeys) {
+function findMalformedReference27(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(PRACTITIONERROLE_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -37204,7 +37326,7 @@ function findMalformedReference26(query, searchParamKeys) {
   return void 0;
 }
 async function listPractitionerRolesRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys26(
+  const searchParamKeys = extractSearchParamKeys27(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -37222,17 +37344,17 @@ async function listPractitionerRolesRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40026(
+    return sendInvalidSearch40027(
       res,
-      buildUnknownParamDiagnostics26([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics27([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference26(
+  const malformedRef = findMalformedReference27(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40026(
+    return sendInvalidSearch40027(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -37416,30 +37538,30 @@ async function listProceduresOperation(params) {
 
 // src/data/rest-api/routes/data/procedure/procedure-list-route.ts
 var PROCEDURE_RESOURCE_TYPE = "Procedure";
-function stripModifier27(key) {
+function stripModifier28(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter27(key) {
+function isResultParameter28(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40027(res, diagnostics) {
+function sendInvalidSearch40028(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys27(query) {
+function extractSearchParamKeys28(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter27(rawKey)) {
+    if (isResultParameter28(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier27(rawKey) });
+    out.push({ rawKey, code: stripModifier28(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics27(unknownCodes) {
+function buildUnknownParamDiagnostics28(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(PROCEDURE_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -37448,7 +37570,7 @@ function buildUnknownParamDiagnostics27(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference27(query, searchParamKeys) {
+function findMalformedReference28(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(PROCEDURE_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -37471,7 +37593,7 @@ function findMalformedReference27(query, searchParamKeys) {
   return void 0;
 }
 async function listProceduresRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys27(
+  const searchParamKeys = extractSearchParamKeys28(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -37487,17 +37609,17 @@ async function listProceduresRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40027(
+    return sendInvalidSearch40028(
       res,
-      buildUnknownParamDiagnostics27([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics28([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference27(
+  const malformedRef = findMalformedReference28(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40027(
+    return sendInvalidSearch40028(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -38188,30 +38310,30 @@ async function listRelatedPersonsOperation(params) {
 
 // src/data/rest-api/routes/data/relatedperson/relatedperson-list-route.ts
 var RELATEDPERSON_RESOURCE_TYPE = "RelatedPerson";
-function stripModifier28(key) {
+function stripModifier29(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter28(key) {
+function isResultParameter29(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40028(res, diagnostics) {
+function sendInvalidSearch40029(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys28(query) {
+function extractSearchParamKeys29(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter28(rawKey)) {
+    if (isResultParameter29(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier28(rawKey) });
+    out.push({ rawKey, code: stripModifier29(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics28(unknownCodes) {
+function buildUnknownParamDiagnostics29(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(RELATEDPERSON_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -38220,7 +38342,7 @@ function buildUnknownParamDiagnostics28(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference28(query, searchParamKeys) {
+function findMalformedReference29(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(RELATEDPERSON_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -38243,7 +38365,7 @@ function findMalformedReference28(query, searchParamKeys) {
   return void 0;
 }
 async function listRelatedPersonsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys28(
+  const searchParamKeys = extractSearchParamKeys29(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -38259,17 +38381,17 @@ async function listRelatedPersonsRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40028(
+    return sendInvalidSearch40029(
       res,
-      buildUnknownParamDiagnostics28([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics29([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference28(
+  const malformedRef = findMalformedReference29(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40028(
+    return sendInvalidSearch40029(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -39303,15 +39425,120 @@ async function listRiskAssessmentsOperation(params) {
 }
 
 // src/data/rest-api/routes/data/riskassessment/riskassessment-list-route.ts
-async function listRiskAssessmentsRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.RISKASSESSMENT,
-    listOperation: listRiskAssessmentsOperation,
-    errorLogContext: "GET /RiskAssessment list error:"
+var RISKASSESSMENT_RESOURCE_TYPE = "RiskAssessment";
+function stripModifier30(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter30(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch40030(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys30(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter30(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier30(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics30(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(RISKASSESSMENT_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for RiskAssessment: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference30(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(RISKASSESSMENT_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
+  );
+  if (referenceCodes.size === 0) {
+    return void 0;
+  }
+  for (const { rawKey, code } of searchParamKeys) {
+    if (!referenceCodes.has(code)) {
+      continue;
+    }
+    const raw = query[rawKey];
+    const values = typeof raw === "string" ? raw.split(",") : Array.isArray(raw) ? raw.flatMap((v) => v.split(",")) : [];
+    for (const v of values) {
+      const trimmed = v.trim();
+      if (trimmed.length === 0) {
+        continue;
+      }
+      if (parseTypedReference(trimmed) === void 0) {
+        return { rawKey, value: trimmed };
+      }
+    }
+  }
+  return void 0;
+}
+async function listRiskAssessmentsRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys30(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.RISKASSESSMENT,
+      listOperation: listRiskAssessmentsOperation,
+      errorLogContext: "GET /RiskAssessment list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(
+    RISKASSESSMENT_RESOURCE_TYPE
+  );
+  const validCodes = new Set(registered.map((p) => p.code));
+  const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
+  if (unknownCodes.length > 0) {
+    return sendInvalidSearch40030(
+      res,
+      buildUnknownParamDiagnostics30([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference30(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch40030(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: RISKASSESSMENT_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(
+      BASE_PATH.RISKASSESSMENT,
+      result.entries
+    );
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(
+      res,
+      err,
+      "GET /RiskAssessment search error:"
+    );
+  }
+}
 
 // src/data/operations/data/riskassessment/riskassessment-update-operation.ts
 async function updateRiskAssessmentOperation(params) {
@@ -39653,30 +39880,30 @@ async function listSchedulesOperation(params) {
 
 // src/data/rest-api/routes/data/schedule/schedule-list-route.ts
 var SCHEDULE_RESOURCE_TYPE = "Schedule";
-function stripModifier29(key) {
+function stripModifier31(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter29(key) {
+function isResultParameter31(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40029(res, diagnostics) {
+function sendInvalidSearch40031(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys29(query) {
+function extractSearchParamKeys31(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter29(rawKey)) {
+    if (isResultParameter31(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier29(rawKey) });
+    out.push({ rawKey, code: stripModifier31(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics29(unknownCodes) {
+function buildUnknownParamDiagnostics31(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(SCHEDULE_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -39685,7 +39912,7 @@ function buildUnknownParamDiagnostics29(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference29(query, searchParamKeys) {
+function findMalformedReference31(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(SCHEDULE_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -39708,7 +39935,7 @@ function findMalformedReference29(query, searchParamKeys) {
   return void 0;
 }
 async function listSchedulesRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys29(
+  const searchParamKeys = extractSearchParamKeys31(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -39724,17 +39951,17 @@ async function listSchedulesRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40029(
+    return sendInvalidSearch40031(
       res,
-      buildUnknownParamDiagnostics29([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics31([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference29(
+  const malformedRef = findMalformedReference31(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40029(
+    return sendInvalidSearch40031(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -40075,15 +40302,120 @@ async function listServiceRequestsOperation(params) {
 }
 
 // src/data/rest-api/routes/data/servicerequest/servicerequest-list-route.ts
-async function listServiceRequestsRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.SERVICEREQUEST,
-    listOperation: listServiceRequestsOperation,
-    errorLogContext: "GET /ServiceRequest list error:"
+var SERVICEREQUEST_RESOURCE_TYPE = "ServiceRequest";
+function stripModifier32(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter32(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch40032(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys32(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter32(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier32(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics32(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(SERVICEREQUEST_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for ServiceRequest: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference32(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(SERVICEREQUEST_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
+  );
+  if (referenceCodes.size === 0) {
+    return void 0;
+  }
+  for (const { rawKey, code } of searchParamKeys) {
+    if (!referenceCodes.has(code)) {
+      continue;
+    }
+    const raw = query[rawKey];
+    const values = typeof raw === "string" ? raw.split(",") : Array.isArray(raw) ? raw.flatMap((v) => v.split(",")) : [];
+    for (const v of values) {
+      const trimmed = v.trim();
+      if (trimmed.length === 0) {
+        continue;
+      }
+      if (parseTypedReference(trimmed) === void 0) {
+        return { rawKey, value: trimmed };
+      }
+    }
+  }
+  return void 0;
+}
+async function listServiceRequestsRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys32(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.SERVICEREQUEST,
+      listOperation: listServiceRequestsOperation,
+      errorLogContext: "GET /ServiceRequest list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(
+    SERVICEREQUEST_RESOURCE_TYPE
+  );
+  const validCodes = new Set(registered.map((p) => p.code));
+  const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
+  if (unknownCodes.length > 0) {
+    return sendInvalidSearch40032(
+      res,
+      buildUnknownParamDiagnostics32([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference32(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch40032(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Encounter/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: SERVICEREQUEST_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(
+      BASE_PATH.SERVICEREQUEST,
+      result.entries
+    );
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(
+      res,
+      err,
+      "GET /ServiceRequest search error:"
+    );
+  }
+}
 
 // src/data/operations/data/servicerequest/servicerequest-update-operation.ts
 async function updateServiceRequestOperation(params) {
@@ -40241,30 +40573,30 @@ async function listSlotsOperation(params) {
 
 // src/data/rest-api/routes/data/slot/slot-list-route.ts
 var SLOT_RESOURCE_TYPE = "Slot";
-function stripModifier30(key) {
+function stripModifier33(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter30(key) {
+function isResultParameter33(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40030(res, diagnostics) {
+function sendInvalidSearch40033(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys30(query) {
+function extractSearchParamKeys33(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter30(rawKey)) {
+    if (isResultParameter33(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier30(rawKey) });
+    out.push({ rawKey, code: stripModifier33(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics30(unknownCodes) {
+function buildUnknownParamDiagnostics33(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(SLOT_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -40273,7 +40605,7 @@ function buildUnknownParamDiagnostics30(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference30(query, searchParamKeys) {
+function findMalformedReference33(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(SLOT_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -40296,7 +40628,7 @@ function findMalformedReference30(query, searchParamKeys) {
   return void 0;
 }
 async function listSlotsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys30(
+  const searchParamKeys = extractSearchParamKeys33(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -40312,17 +40644,17 @@ async function listSlotsRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40030(
+    return sendInvalidSearch40033(
       res,
-      buildUnknownParamDiagnostics30([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics33([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference30(
+  const malformedRef = findMalformedReference33(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40030(
+    return sendInvalidSearch40033(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Schedule/<id>"; got "${malformedRef.value}".`
     );
@@ -40499,30 +40831,30 @@ async function listSpecimensOperation(params) {
 
 // src/data/rest-api/routes/data/specimen/specimen-list-route.ts
 var SPECIMEN_RESOURCE_TYPE = "Specimen";
-function stripModifier31(key) {
+function stripModifier34(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter31(key) {
+function isResultParameter34(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40031(res, diagnostics) {
+function sendInvalidSearch40034(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys31(query) {
+function extractSearchParamKeys34(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter31(rawKey)) {
+    if (isResultParameter34(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier31(rawKey) });
+    out.push({ rawKey, code: stripModifier34(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics31(unknownCodes) {
+function buildUnknownParamDiagnostics34(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(SPECIMEN_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -40531,7 +40863,7 @@ function buildUnknownParamDiagnostics31(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference31(query, searchParamKeys) {
+function findMalformedReference34(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(SPECIMEN_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -40557,7 +40889,7 @@ function findMalformedReference31(query, searchParamKeys) {
   return void 0;
 }
 async function listSpecimensRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys31(
+  const searchParamKeys = extractSearchParamKeys34(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -40573,17 +40905,17 @@ async function listSpecimensRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40031(
+    return sendInvalidSearch40034(
       res,
-      buildUnknownParamDiagnostics31([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics34([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference31(
+  const malformedRef = findMalformedReference34(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40031(
+    return sendInvalidSearch40034(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
     );
@@ -42987,30 +43319,30 @@ async function listTasksOperation(params) {
 
 // src/data/rest-api/routes/data/task/task-list-route.ts
 var TASK_RESOURCE_TYPE = "Task";
-function stripModifier32(key) {
+function stripModifier35(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter32(key) {
+function isResultParameter35(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40032(res, diagnostics) {
+function sendInvalidSearch40035(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys32(query) {
+function extractSearchParamKeys35(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter32(rawKey)) {
+    if (isResultParameter35(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier32(rawKey) });
+    out.push({ rawKey, code: stripModifier35(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics32(unknownCodes) {
+function buildUnknownParamDiagnostics35(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(TASK_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -43019,7 +43351,7 @@ function buildUnknownParamDiagnostics32(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference32(query, searchParamKeys) {
+function findMalformedReference35(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(TASK_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -43042,7 +43374,7 @@ function findMalformedReference32(query, searchParamKeys) {
   return void 0;
 }
 async function listTasksRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys32(
+  const searchParamKeys = extractSearchParamKeys35(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -43058,17 +43390,17 @@ async function listTasksRoute(req, res) {
   const validCodes = new Set(registered.map((p) => p.code));
   const unknownCodes = searchParamKeys.map((k) => k.code).filter((code) => !validCodes.has(code));
   if (unknownCodes.length > 0) {
-    return sendInvalidSearch40032(
+    return sendInvalidSearch40035(
       res,
-      buildUnknownParamDiagnostics32([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics35([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference32(
+  const malformedRef = findMalformedReference35(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40032(
+    return sendInvalidSearch40035(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );