@openhi/constructs 0.0.186 → 0.0.188

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

@@ -6182,6 +6182,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" },
@@ -6843,6 +6846,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" },
@@ -6858,6 +6867,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" },
@@ -6934,6 +6946,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,
@@ -6958,7 +6971,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
@@ -14581,15 +14596,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) {
@@ -15437,30 +15559,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;
@@ -15469,7 +15591,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)
   );
@@ -15495,7 +15617,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) {
@@ -15511,17 +15633,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}".`
     );
@@ -15863,30 +15985,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;
@@ -15895,7 +16017,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)
   );
@@ -15918,7 +16040,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) {
@@ -15934,17 +16056,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}".`
     );
@@ -16454,30 +16576,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;
@@ -16486,7 +16608,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)
   );
@@ -16512,7 +16634,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) {
@@ -16530,17 +16652,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}".`
     );
@@ -18089,30 +18211,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(", ");
@@ -18123,7 +18245,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)
   );
@@ -18149,7 +18271,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) {
@@ -18167,17 +18289,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}".`
     );
@@ -18361,30 +18483,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(", ");
@@ -18395,7 +18517,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)
   );
@@ -18421,7 +18543,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) {
@@ -18439,17 +18561,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}".`
     );
@@ -18636,30 +18758,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(", ");
@@ -18670,7 +18792,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)
   );
@@ -18696,7 +18818,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) {
@@ -18714,17 +18836,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}".`
     );
@@ -19092,30 +19214,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;
@@ -19124,7 +19246,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)
   );
@@ -19147,7 +19269,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) {
@@ -19163,17 +19285,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}".`
     );
@@ -19355,30 +19477,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;
@@ -19387,7 +19509,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)
   );
@@ -19413,7 +19535,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) {
@@ -19429,17 +19551,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}".`
     );
@@ -20792,30 +20914,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(", ");
@@ -20826,7 +20948,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)
   );
@@ -20852,7 +20974,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) {
@@ -20870,17 +20992,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}".`
     );
@@ -21071,30 +21193,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(", ");
@@ -21105,7 +21227,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)
   );
@@ -21128,7 +21250,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) {
@@ -21146,17 +21268,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}".`
     );
@@ -22333,30 +22455,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;
@@ -22365,7 +22487,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)
   );
@@ -22391,7 +22513,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) {
@@ -22407,17 +22529,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}".`
     );
@@ -22594,30 +22716,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;
@@ -22626,7 +22748,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)
   );
@@ -22649,7 +22771,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) {
@@ -22665,17 +22787,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}".`
     );
@@ -23557,30 +23679,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;
@@ -23589,7 +23711,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)
   );
@@ -23615,7 +23737,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) {
@@ -23631,17 +23753,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}".`
     );
@@ -24313,30 +24435,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;
@@ -24345,7 +24467,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)
   );
@@ -24371,7 +24493,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) {
@@ -24387,17 +24509,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}".`
     );
@@ -25765,30 +25887,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(", ");
@@ -25799,7 +25921,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)
   );
@@ -25822,7 +25944,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) {
@@ -25840,17 +25962,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}".`
     );
@@ -26041,30 +26163,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(", ");
@@ -26075,7 +26197,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)
   );
@@ -26098,7 +26220,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) {
@@ -26116,17 +26238,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}".`
     );
@@ -28983,30 +29105,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;
@@ -29015,7 +29137,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)
   );
@@ -29038,7 +29160,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) {
@@ -29054,17 +29176,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}".`
     );
@@ -29570,30 +29692,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;
@@ -29602,7 +29724,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)
   );
@@ -29628,7 +29750,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) {
@@ -29644,17 +29766,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}".`
     );
@@ -30015,30 +30137,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;
@@ -30047,7 +30169,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)
   );
@@ -30070,7 +30192,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) {
@@ -30086,17 +30208,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}".`
     );
@@ -30273,30 +30395,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;
@@ -30305,7 +30427,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)
   );
@@ -30331,7 +30453,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) {
@@ -30347,17 +30469,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}".`
     );
@@ -31055,30 +31177,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;
@@ -31087,7 +31209,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)
   );
@@ -31113,7 +31235,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) {
@@ -31129,17 +31251,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}".`
     );
@@ -31295,30 +31417,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(", ");
@@ -31329,7 +31451,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)
   );
@@ -31352,7 +31474,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) {
@@ -31370,17 +31492,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}".`
     );
@@ -31564,30 +31686,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;
@@ -31596,7 +31718,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)
   );
@@ -31619,7 +31741,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) {
@@ -31635,17 +31757,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}".`
     );
@@ -32336,30 +32458,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;
@@ -32368,7 +32490,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)
   );
@@ -32391,7 +32513,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) {
@@ -32407,17 +32529,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}".`
     );
@@ -33451,15 +33573,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) {
@@ -33801,30 +34028,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;
@@ -33833,7 +34060,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)
   );
@@ -33856,7 +34083,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) {
@@ -33872,17 +34099,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}".`
     );
@@ -34223,15 +34450,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) {
@@ -34389,30 +34721,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;
@@ -34421,7 +34753,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)
   );
@@ -34444,7 +34776,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) {
@@ -34460,17 +34792,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}".`
     );
@@ -34647,30 +34979,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;
@@ -34679,7 +35011,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)
   );
@@ -34705,7 +35037,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) {
@@ -34721,17 +35053,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}".`
     );
@@ -37135,30 +37467,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;
@@ -37167,7 +37499,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)
   );
@@ -37190,7 +37522,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) {
@@ -37206,17 +37538,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}".`
     );