@openhi/constructs 0.0.142 → 0.0.144

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

@@ -9399,206 +9399,6 @@ async function listAllergyIntolerancesOperation(params) {
   );
 }
 
-// src/data/rest-api/routes/data/allergyintolerance/allergyintolerance-list-route.ts
-async function listAllergyIntolerancesRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.ALLERGYINTOLERANCE,
-    listOperation: listAllergyIntolerancesOperation,
-    errorLogContext: "GET /AllergyIntolerance list error:"
-  });
-}
-
-// src/data/operations/data/allergyintolerance/allergyintolerance-update-operation.ts
-async function updateAllergyIntoleranceOperation(params) {
-  const { context, id, body, tableName } = params;
-  const { tenantId, workspaceId, date, actorId, actorName } = context;
-  const service = getDynamoDataService(tableName);
-  return updateDataEntityById(
-    service.entities.allergyintolerance,
-    tenantId,
-    workspaceId,
-    id,
-    "AllergyIntolerance",
-    context,
-    (existingResourceStr) => buildUpdatedResourceWithAudit(
-      body,
-      id,
-      date,
-      actorId,
-      actorName,
-      existingResourceStr,
-      "AllergyIntolerance"
-    )
-  );
-}
-
-// src/data/rest-api/routes/data/allergyintolerance/allergyintolerance-update-route.ts
-async function updateAllergyIntoleranceRoute(req, res) {
-  const bodyResult = requireJsonBodyAs(req, res);
-  if ("errorResponse" in bodyResult) return bodyResult.errorResponse;
-  const id = String(req.params.id);
-  const ctx = req.openhiContext;
-  const body = bodyResult.body;
-  const resource = {
-    ...body,
-    resourceType: "AllergyIntolerance",
-    id
-  };
-  try {
-    const result = await updateAllergyIntoleranceOperation({
-      context: ctx,
-      id,
-      body: resource
-    });
-    return res.json(result.resource);
-  } catch (err) {
-    const status = domainErrorToHttpStatus(err);
-    if (status === 404) {
-      const diagnostics = err instanceof NotFoundError ? err.message : `AllergyIntolerance ${id} not found`;
-      return sendOperationOutcome404(res, diagnostics);
-    }
-    return sendOperationOutcome500(res, err, "PUT AllergyIntolerance error:");
-  }
-}
-
-// src/data/rest-api/routes/data/allergyintolerance/allergyintolerance.ts
-var router13 = import_express13.default.Router();
-router13.get("/", listAllergyIntolerancesRoute);
-router13.get("/:id", getAllergyIntoleranceByIdRoute);
-router13.post("/", createAllergyIntoleranceRoute);
-router13.put("/:id", updateAllergyIntoleranceRoute);
-router13.delete("/:id", deleteAllergyIntoleranceRoute);
-
-// src/data/rest-api/routes/data/appointment/appointment.ts
-var import_express14 = __toESM(require("express"));
-
-// src/data/operations/data/appointment/appointment-create-operation.ts
-var import_ulid6 = require("ulid");
-async function createAppointmentOperation(params) {
-  const { context, body, tableName } = params;
-  const { tenantId, workspaceId, date, actorId, actorName } = context;
-  const id = body.id ?? (0, import_ulid6.ulid)();
-  const meta = {
-    ...body.meta ?? {},
-    lastUpdated: date,
-    versionId: "1"
-  };
-  const resourceWithAudit = {
-    ...body,
-    resourceType: "Appointment",
-    id,
-    meta: mergeAuditIntoMeta(meta, {
-      createdDate: date,
-      createdById: actorId,
-      createdByName: actorName,
-      modifiedDate: date,
-      modifiedById: actorId,
-      modifiedByName: actorName
-    })
-  };
-  const service = getDynamoDataService(tableName);
-  return createDataEntityRecord(
-    service.entities.appointment,
-    tenantId,
-    workspaceId,
-    id,
-    resourceWithAudit,
-    date
-  );
-}
-
-// src/data/rest-api/routes/data/appointment/appointment-create-route.ts
-async function createAppointmentRoute(req, res) {
-  const bodyResult = requireJsonBodyAs(req, res);
-  if ("errorResponse" in bodyResult) return bodyResult.errorResponse;
-  const ctx = req.openhiContext;
-  const body = bodyResult.body;
-  const resource = {
-    ...body,
-    resourceType: "Appointment"
-  };
-  try {
-    const result = await createAppointmentOperation({
-      context: ctx,
-      body: resource
-    });
-    return res.status(201).location(`${BASE_PATH.APPOINTMENT}/${result.id}`).json(result.resource);
-  } catch (err) {
-    return sendOperationOutcome500(res, err, "POST Appointment error:");
-  }
-}
-
-// src/data/operations/data/appointment/appointment-delete-operation.ts
-async function deleteAppointmentOperation(params) {
-  const { context, id, tableName } = params;
-  const { tenantId, workspaceId } = context;
-  const service = getDynamoDataService(tableName);
-  await deleteDataEntityById(
-    service.entities.appointment,
-    tenantId,
-    workspaceId,
-    id
-  );
-}
-
-// src/data/rest-api/routes/data/appointment/appointment-delete-route.ts
-async function deleteAppointmentRoute(req, res) {
-  const id = String(req.params.id);
-  const ctx = req.openhiContext;
-  try {
-    await deleteAppointmentOperation({ context: ctx, id });
-    return res.status(204).send();
-  } catch (err) {
-    return sendOperationOutcome500(res, err, "DELETE Appointment error:");
-  }
-}
-
-// src/data/operations/data/appointment/appointment-get-by-id-operation.ts
-async function getAppointmentByIdOperation(params) {
-  const { context, id, tableName } = params;
-  const { tenantId, workspaceId } = context;
-  const service = getDynamoDataService(tableName);
-  return getDataEntityById(
-    service.entities.appointment,
-    tenantId,
-    workspaceId,
-    id,
-    "Appointment"
-  );
-}
-
-// src/data/rest-api/routes/data/appointment/appointment-get-by-id-route.ts
-async function getAppointmentByIdRoute(req, res) {
-  const id = String(req.params.id);
-  const ctx = req.openhiContext;
-  try {
-    const result = await getAppointmentByIdOperation({ context: ctx, id });
-    return res.json(result.resource);
-  } catch (err) {
-    const status = domainErrorToHttpStatus(err);
-    if (status === 404) {
-      const diagnostics = err instanceof NotFoundError ? err.message : `Appointment ${id} not found`;
-      return sendOperationOutcome404(res, diagnostics);
-    }
-    return sendOperationOutcome500(res, err, "GET Appointment error:");
-  }
-}
-
-// src/data/operations/data/appointment/appointment-list-operation.ts
-async function listAppointmentsOperation(params) {
-  const { context, tableName, mode } = params;
-  const { tenantId, workspaceId } = context;
-  const service = getDynamoDataService(tableName);
-  return listDataEntitiesByWorkspace(
-    service.entities.appointment,
-    tenantId,
-    workspaceId,
-    mode
-  );
-}
-
 // src/data/search/engine/reference-predicate.ts
 function buildOpenHiResourceUrn(opts) {
   return `urn:ohi:${opts.tenantId}:${opts.workspaceId}:${opts.resourceType}:${opts.resourceId}`;
@@ -10252,6 +10052,30 @@ async function genericSearchOperation(params) {
   return { entries, total: entries.length };
 }
 
+// src/data/search/registry/allergyintolerance-search-parameters.ts
+var ALLERGYINTOLERANCE_SEARCH_PARAMETERS = [
+  {
+    code: "clinical-status",
+    type: "token",
+    jsonbPath: "$.clinicalStatus"
+  },
+  {
+    code: "verification-status",
+    type: "token",
+    jsonbPath: "$.verificationStatus"
+  },
+  { code: "type", type: "token", jsonbPath: "$.type" },
+  { code: "category", type: "token", jsonbPath: "$.category[*]" },
+  { code: "criticality", type: "token", jsonbPath: "$.criticality" },
+  { code: "code", type: "token", jsonbPath: "$.code" },
+  { code: "patient", type: "reference", jsonbPath: "$.patient" },
+  { code: "recorder", type: "reference", jsonbPath: "$.recorder" },
+  { code: "asserter", type: "reference", jsonbPath: "$.asserter" },
+  { code: "date", type: "date", jsonbPath: "$.recordedDate" },
+  { code: "last-date", type: "date", jsonbPath: "$.lastOccurrence" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" }
+];
+
 // src/data/search/registry/appointment-search-parameters.ts
 var APPOINTMENT_SEARCH_PARAMETERS = [
   { code: "status", type: "token", jsonbPath: "$.status" },
@@ -10286,6 +10110,32 @@ var APPOINTMENT_SEARCH_PARAMETERS = [
   { code: "slot", type: "reference", jsonbPath: "$.slot[*]" }
 ];
 
+// src/data/search/registry/condition-search-parameters.ts
+var CONDITION_SEARCH_PARAMETERS = [
+  {
+    code: "clinical-status",
+    type: "token",
+    jsonbPath: "$.clinicalStatus"
+  },
+  {
+    code: "verification-status",
+    type: "token",
+    jsonbPath: "$.verificationStatus"
+  },
+  { code: "category", type: "token", jsonbPath: "$.category[*]" },
+  { code: "severity", type: "token", jsonbPath: "$.severity" },
+  { code: "code", type: "token", jsonbPath: "$.code" },
+  { code: "subject", type: "reference", jsonbPath: "$.subject" },
+  { code: "patient", type: "reference", jsonbPath: "$.subject" },
+  { code: "encounter", type: "reference", jsonbPath: "$.encounter" },
+  { code: "asserter", type: "reference", jsonbPath: "$.asserter" },
+  { code: "recorder", type: "reference", jsonbPath: "$.recorder" },
+  { code: "onset-date", type: "date", jsonbPath: "$.onsetDateTime" },
+  { code: "recorded-date", type: "date", jsonbPath: "$.recordedDate" },
+  { code: "body-site", type: "token", jsonbPath: "$.bodySite[*]" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" }
+];
+
 // src/data/search/registry/encounter-search-parameters.ts
 var ENCOUNTER_SEARCH_PARAMETERS = [
   { code: "status", type: "token", jsonbPath: "$.status" },
@@ -10312,129 +10162,516 @@ var ENCOUNTER_SEARCH_PARAMETERS = [
   }
 ];
 
-// src/data/search/registry/observation-search-parameters.ts
-var OBSERVATION_SEARCH_PARAMETERS = [
+// src/data/search/registry/familymemberhistory-search-parameters.ts
+var FAMILYMEMBERHISTORY_SEARCH_PARAMETERS = [
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "relationship", type: "token", jsonbPath: "$.relationship" },
+  { code: "sex", type: "token", jsonbPath: "$.sex" },
+  { code: "patient", type: "reference", jsonbPath: "$.patient" },
+  { code: "date", type: "date", jsonbPath: "$.date" },
+  { code: "code", type: "token", jsonbPath: "$.condition[*]" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" }
+];
+
+// src/data/search/registry/immunization-search-parameters.ts
+var IMMUNIZATION_SEARCH_PARAMETERS = [
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "status-reason", type: "token", jsonbPath: "$.statusReason" },
+  { code: "vaccine-code", type: "token", jsonbPath: "$.vaccineCode" },
+  { code: "patient", type: "reference", jsonbPath: "$.patient" },
+  { code: "date", type: "date", jsonbPath: "$.occurrenceDateTime" },
+  { code: "performer", type: "reference", jsonbPath: "$.performer[*].actor" },
+  { code: "location", type: "reference", jsonbPath: "$.location" },
+  {
+    code: "lot-number",
+    type: "string",
+    jsonbPath: "$.lotNumber",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  { code: "manufacturer", type: "reference", jsonbPath: "$.manufacturer" },
+  { code: "reaction", type: "reference", jsonbPath: "$.reaction[*].detail" },
+  { code: "reason-code", type: "token", jsonbPath: "$.reasonCode[*]" },
+  {
+    code: "reason-reference",
+    type: "reference",
+    jsonbPath: "$.reasonReference[*]"
+  },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" }
+];
+
+// src/data/search/registry/medicationrequest-search-parameters.ts
+var MEDICATIONREQUEST_SEARCH_PARAMETERS = [
   { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "intent", type: "token", jsonbPath: "$.intent" },
   { code: "category", type: "token", jsonbPath: "$.category[*]" },
-  { code: "code", type: "token", jsonbPath: "$.code" },
+  { code: "priority", type: "token", jsonbPath: "$.priority" },
+  { code: "code", type: "token", jsonbPath: "$.medicationCodeableConcept" },
   { code: "subject", type: "reference", jsonbPath: "$.subject" },
   { code: "patient", type: "reference", jsonbPath: "$.subject" },
   { code: "encounter", type: "reference", jsonbPath: "$.encounter" },
-  { code: "performer", type: "reference", jsonbPath: "$.performer[*]" },
-  { code: "date", type: "date", jsonbPath: "$.effectiveDateTime" },
+  { code: "authored-on", type: "date", jsonbPath: "$.authoredOn" },
+  { code: "requester", type: "reference", jsonbPath: "$.requester" },
+  { code: "performer", type: "reference", jsonbPath: "$.performer" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" }
+];
+
+// src/data/search/registry/medicationstatement-search-parameters.ts
+var MEDICATIONSTATEMENT_SEARCH_PARAMETERS = [
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "category", type: "token", jsonbPath: "$.category" },
+  { code: "code", type: "token", jsonbPath: "$.medicationCodeableConcept" },
+  { code: "subject", type: "reference", jsonbPath: "$.subject" },
+  { code: "patient", type: "reference", jsonbPath: "$.subject" },
+  { code: "context", type: "reference", jsonbPath: "$.context" },
+  { code: "effective", type: "date", jsonbPath: "$.effectiveDateTime" },
   {
-    code: "value-string",
-    type: "string",
-    jsonbPath: "$.valueString",
-    modifiers: ["exact", "contains", "missing", "not"]
+    code: "information-source",
+    type: "reference",
+    jsonbPath: "$.informationSource"
+  },
+  {
+    code: "medication",
+    type: "reference",
+    jsonbPath: "$.medicationReference"
+  },
+  { code: "source", type: "reference", jsonbPath: "$.informationSource" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
+  { code: "part-of", type: "reference", jsonbPath: "$.partOf[*]" }
+];
+
+// src/data/search/registry/observation-search-parameters.ts
+var OBSERVATION_SEARCH_PARAMETERS = [
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "category", type: "token", jsonbPath: "$.category[*]" },
+  { code: "code", type: "token", jsonbPath: "$.code" },
+  { code: "subject", type: "reference", jsonbPath: "$.subject" },
+  { code: "patient", type: "reference", jsonbPath: "$.subject" },
+  { code: "encounter", type: "reference", jsonbPath: "$.encounter" },
+  { code: "performer", type: "reference", jsonbPath: "$.performer[*]" },
+  { code: "date", type: "date", jsonbPath: "$.effectiveDateTime" },
+  {
+    code: "value-string",
+    type: "string",
+    jsonbPath: "$.valueString",
+    modifiers: ["exact", "contains", "missing", "not"]
   },
   { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
   { code: "based-on", type: "reference", jsonbPath: "$.basedOn[*]" },
   { code: "part-of", type: "reference", jsonbPath: "$.partOf[*]" }
 ];
 
-// src/data/search/registry/patient-search-parameters.ts
-var PATIENT_SEARCH_PARAMETERS = [
-  { code: "gender", type: "token", jsonbPath: "$.gender" },
-  { code: "identifier", type: "token", jsonbPath: "$.identifier[*].value" },
-  { code: "birthdate", type: "date", jsonbPath: "$.birthDate" },
-  {
-    code: "name",
-    type: "string",
-    jsonbPath: "$.name[*].text",
-    modifiers: ["exact", "contains", "missing", "not"]
-  },
-  {
-    code: "family",
-    type: "string",
-    jsonbPath: "$.name[*].family",
-    modifiers: ["exact", "contains", "missing", "not"]
-  },
-  {
-    code: "given",
-    type: "string",
-    jsonbPath: "$.name[*].given",
-    modifiers: ["exact", "contains", "missing", "not"]
-  },
-  { code: "active", type: "token", jsonbPath: "$.active" },
-  { code: "deceased", type: "token", jsonbPath: "$.deceasedBoolean" },
-  {
-    code: "general-practitioner",
-    type: "reference",
-    jsonbPath: "$.generalPractitioner[*]"
-  },
-  {
-    code: "organization",
-    type: "reference",
-    jsonbPath: "$.managingOrganization"
+// src/data/search/registry/patient-search-parameters.ts
+var PATIENT_SEARCH_PARAMETERS = [
+  { code: "gender", type: "token", jsonbPath: "$.gender" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*].value" },
+  { code: "birthdate", type: "date", jsonbPath: "$.birthDate" },
+  {
+    code: "name",
+    type: "string",
+    jsonbPath: "$.name[*].text",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  {
+    code: "family",
+    type: "string",
+    jsonbPath: "$.name[*].family",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  {
+    code: "given",
+    type: "string",
+    jsonbPath: "$.name[*].given",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  { code: "active", type: "token", jsonbPath: "$.active" },
+  { code: "deceased", type: "token", jsonbPath: "$.deceasedBoolean" },
+  {
+    code: "general-practitioner",
+    type: "reference",
+    jsonbPath: "$.generalPractitioner[*]"
+  },
+  {
+    code: "organization",
+    type: "reference",
+    jsonbPath: "$.managingOrganization"
+  }
+];
+
+// src/data/search/registry/procedure-search-parameters.ts
+var PROCEDURE_SEARCH_PARAMETERS = [
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "category", type: "token", jsonbPath: "$.category" },
+  { code: "code", type: "token", jsonbPath: "$.code" },
+  { code: "subject", type: "reference", jsonbPath: "$.subject" },
+  { code: "patient", type: "reference", jsonbPath: "$.subject" },
+  { code: "encounter", type: "reference", jsonbPath: "$.encounter" },
+  {
+    code: "performer",
+    type: "reference",
+    jsonbPath: "$.performer[*].actor"
+  },
+  { code: "date", type: "date", jsonbPath: "$.performedDateTime" },
+  { code: "location", type: "reference", jsonbPath: "$.location" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
+  { code: "based-on", type: "reference", jsonbPath: "$.basedOn[*]" },
+  { code: "part-of", type: "reference", jsonbPath: "$.partOf[*]" },
+  { code: "reason-code", type: "token", jsonbPath: "$.reasonCode[*]" },
+  {
+    code: "reason-reference",
+    type: "reference",
+    jsonbPath: "$.reasonReference[*]"
+  }
+];
+
+// src/data/search/registry/resolver.ts
+var STATIC_SEARCH_PARAMETER_MAP = {
+  AllergyIntolerance: ALLERGYINTOLERANCE_SEARCH_PARAMETERS,
+  Appointment: APPOINTMENT_SEARCH_PARAMETERS,
+  Condition: CONDITION_SEARCH_PARAMETERS,
+  Encounter: ENCOUNTER_SEARCH_PARAMETERS,
+  FamilyMemberHistory: FAMILYMEMBERHISTORY_SEARCH_PARAMETERS,
+  Immunization: IMMUNIZATION_SEARCH_PARAMETERS,
+  MedicationRequest: MEDICATIONREQUEST_SEARCH_PARAMETERS,
+  MedicationStatement: MEDICATIONSTATEMENT_SEARCH_PARAMETERS,
+  Observation: OBSERVATION_SEARCH_PARAMETERS,
+  Patient: PATIENT_SEARCH_PARAMETERS,
+  Procedure: PROCEDURE_SEARCH_PARAMETERS
+};
+var defaultSearchParameterResolver = (resourceType, _tenantId) => STATIC_SEARCH_PARAMETER_MAP[resourceType] ?? [];
+function getRegisteredSearchParameters(resourceType) {
+  return STATIC_SEARCH_PARAMETER_MAP[resourceType] ?? [];
+}
+
+// src/data/rest-api/routes/data/allergyintolerance/allergyintolerance-list-route.ts
+var ALLERGYINTOLERANCE_RESOURCE_TYPE = "AllergyIntolerance";
+function stripModifier(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch400(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
+  });
+}
+function extractSearchParamKeys(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(
+    ALLERGYINTOLERANCE_RESOURCE_TYPE
+  ).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for AllergyIntolerance: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(ALLERGYINTOLERANCE_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
+  );
+  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 listAllergyIntolerancesRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.ALLERGYINTOLERANCE,
+      listOperation: listAllergyIntolerancesOperation,
+      errorLogContext: "GET /AllergyIntolerance list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(
+    ALLERGYINTOLERANCE_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 sendInvalidSearch400(
+      res,
+      buildUnknownParamDiagnostics([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch400(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: ALLERGYINTOLERANCE_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(
+      BASE_PATH.ALLERGYINTOLERANCE,
+      result.entries
+    );
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(
+      res,
+      err,
+      "GET /AllergyIntolerance search error:"
+    );
+  }
+}
+
+// src/data/operations/data/allergyintolerance/allergyintolerance-update-operation.ts
+async function updateAllergyIntoleranceOperation(params) {
+  const { context, id, body, tableName } = params;
+  const { tenantId, workspaceId, date, actorId, actorName } = context;
+  const service = getDynamoDataService(tableName);
+  return updateDataEntityById(
+    service.entities.allergyintolerance,
+    tenantId,
+    workspaceId,
+    id,
+    "AllergyIntolerance",
+    context,
+    (existingResourceStr) => buildUpdatedResourceWithAudit(
+      body,
+      id,
+      date,
+      actorId,
+      actorName,
+      existingResourceStr,
+      "AllergyIntolerance"
+    )
+  );
+}
+
+// src/data/rest-api/routes/data/allergyintolerance/allergyintolerance-update-route.ts
+async function updateAllergyIntoleranceRoute(req, res) {
+  const bodyResult = requireJsonBodyAs(req, res);
+  if ("errorResponse" in bodyResult) return bodyResult.errorResponse;
+  const id = String(req.params.id);
+  const ctx = req.openhiContext;
+  const body = bodyResult.body;
+  const resource = {
+    ...body,
+    resourceType: "AllergyIntolerance",
+    id
+  };
+  try {
+    const result = await updateAllergyIntoleranceOperation({
+      context: ctx,
+      id,
+      body: resource
+    });
+    return res.json(result.resource);
+  } catch (err) {
+    const status = domainErrorToHttpStatus(err);
+    if (status === 404) {
+      const diagnostics = err instanceof NotFoundError ? err.message : `AllergyIntolerance ${id} not found`;
+      return sendOperationOutcome404(res, diagnostics);
+    }
+    return sendOperationOutcome500(res, err, "PUT AllergyIntolerance error:");
+  }
+}
+
+// src/data/rest-api/routes/data/allergyintolerance/allergyintolerance.ts
+var router13 = import_express13.default.Router();
+router13.get("/", listAllergyIntolerancesRoute);
+router13.get("/:id", getAllergyIntoleranceByIdRoute);
+router13.post("/", createAllergyIntoleranceRoute);
+router13.put("/:id", updateAllergyIntoleranceRoute);
+router13.delete("/:id", deleteAllergyIntoleranceRoute);
+
+// src/data/rest-api/routes/data/appointment/appointment.ts
+var import_express14 = __toESM(require("express"));
+
+// src/data/operations/data/appointment/appointment-create-operation.ts
+var import_ulid6 = require("ulid");
+async function createAppointmentOperation(params) {
+  const { context, body, tableName } = params;
+  const { tenantId, workspaceId, date, actorId, actorName } = context;
+  const id = body.id ?? (0, import_ulid6.ulid)();
+  const meta = {
+    ...body.meta ?? {},
+    lastUpdated: date,
+    versionId: "1"
+  };
+  const resourceWithAudit = {
+    ...body,
+    resourceType: "Appointment",
+    id,
+    meta: mergeAuditIntoMeta(meta, {
+      createdDate: date,
+      createdById: actorId,
+      createdByName: actorName,
+      modifiedDate: date,
+      modifiedById: actorId,
+      modifiedByName: actorName
+    })
+  };
+  const service = getDynamoDataService(tableName);
+  return createDataEntityRecord(
+    service.entities.appointment,
+    tenantId,
+    workspaceId,
+    id,
+    resourceWithAudit,
+    date
+  );
+}
+
+// src/data/rest-api/routes/data/appointment/appointment-create-route.ts
+async function createAppointmentRoute(req, res) {
+  const bodyResult = requireJsonBodyAs(req, res);
+  if ("errorResponse" in bodyResult) return bodyResult.errorResponse;
+  const ctx = req.openhiContext;
+  const body = bodyResult.body;
+  const resource = {
+    ...body,
+    resourceType: "Appointment"
+  };
+  try {
+    const result = await createAppointmentOperation({
+      context: ctx,
+      body: resource
+    });
+    return res.status(201).location(`${BASE_PATH.APPOINTMENT}/${result.id}`).json(result.resource);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "POST Appointment error:");
+  }
+}
+
+// src/data/operations/data/appointment/appointment-delete-operation.ts
+async function deleteAppointmentOperation(params) {
+  const { context, id, tableName } = params;
+  const { tenantId, workspaceId } = context;
+  const service = getDynamoDataService(tableName);
+  await deleteDataEntityById(
+    service.entities.appointment,
+    tenantId,
+    workspaceId,
+    id
+  );
+}
+
+// src/data/rest-api/routes/data/appointment/appointment-delete-route.ts
+async function deleteAppointmentRoute(req, res) {
+  const id = String(req.params.id);
+  const ctx = req.openhiContext;
+  try {
+    await deleteAppointmentOperation({ context: ctx, id });
+    return res.status(204).send();
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "DELETE Appointment error:");
   }
-];
+}
 
-// src/data/search/registry/procedure-search-parameters.ts
-var PROCEDURE_SEARCH_PARAMETERS = [
-  { code: "status", type: "token", jsonbPath: "$.status" },
-  { code: "category", type: "token", jsonbPath: "$.category" },
-  { code: "code", type: "token", jsonbPath: "$.code" },
-  { code: "subject", type: "reference", jsonbPath: "$.subject" },
-  { code: "patient", type: "reference", jsonbPath: "$.subject" },
-  { code: "encounter", type: "reference", jsonbPath: "$.encounter" },
-  {
-    code: "performer",
-    type: "reference",
-    jsonbPath: "$.performer[*].actor"
-  },
-  { code: "date", type: "date", jsonbPath: "$.performedDateTime" },
-  { code: "location", type: "reference", jsonbPath: "$.location" },
-  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
-  { code: "based-on", type: "reference", jsonbPath: "$.basedOn[*]" },
-  { code: "part-of", type: "reference", jsonbPath: "$.partOf[*]" },
-  { code: "reason-code", type: "token", jsonbPath: "$.reasonCode[*]" },
-  {
-    code: "reason-reference",
-    type: "reference",
-    jsonbPath: "$.reasonReference[*]"
+// src/data/operations/data/appointment/appointment-get-by-id-operation.ts
+async function getAppointmentByIdOperation(params) {
+  const { context, id, tableName } = params;
+  const { tenantId, workspaceId } = context;
+  const service = getDynamoDataService(tableName);
+  return getDataEntityById(
+    service.entities.appointment,
+    tenantId,
+    workspaceId,
+    id,
+    "Appointment"
+  );
+}
+
+// src/data/rest-api/routes/data/appointment/appointment-get-by-id-route.ts
+async function getAppointmentByIdRoute(req, res) {
+  const id = String(req.params.id);
+  const ctx = req.openhiContext;
+  try {
+    const result = await getAppointmentByIdOperation({ context: ctx, id });
+    return res.json(result.resource);
+  } catch (err) {
+    const status = domainErrorToHttpStatus(err);
+    if (status === 404) {
+      const diagnostics = err instanceof NotFoundError ? err.message : `Appointment ${id} not found`;
+      return sendOperationOutcome404(res, diagnostics);
+    }
+    return sendOperationOutcome500(res, err, "GET Appointment error:");
   }
-];
+}
 
-// src/data/search/registry/resolver.ts
-var STATIC_SEARCH_PARAMETER_MAP = {
-  Appointment: APPOINTMENT_SEARCH_PARAMETERS,
-  Encounter: ENCOUNTER_SEARCH_PARAMETERS,
-  Observation: OBSERVATION_SEARCH_PARAMETERS,
-  Patient: PATIENT_SEARCH_PARAMETERS,
-  Procedure: PROCEDURE_SEARCH_PARAMETERS
-};
-var defaultSearchParameterResolver = (resourceType, _tenantId) => STATIC_SEARCH_PARAMETER_MAP[resourceType] ?? [];
-function getRegisteredSearchParameters(resourceType) {
-  return STATIC_SEARCH_PARAMETER_MAP[resourceType] ?? [];
+// src/data/operations/data/appointment/appointment-list-operation.ts
+async function listAppointmentsOperation(params) {
+  const { context, tableName, mode } = params;
+  const { tenantId, workspaceId } = context;
+  const service = getDynamoDataService(tableName);
+  return listDataEntitiesByWorkspace(
+    service.entities.appointment,
+    tenantId,
+    workspaceId,
+    mode
+  );
 }
 
 // src/data/rest-api/routes/data/appointment/appointment-list-route.ts
 var APPOINTMENT_RESOURCE_TYPE = "Appointment";
-function stripModifier(key) {
+function stripModifier2(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter(key) {
+function isResultParameter2(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch400(res, diagnostics) {
+function sendInvalidSearch4002(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys(query) {
+function extractSearchParamKeys2(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter(rawKey)) {
+    if (isResultParameter2(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier(rawKey) });
+    out.push({ rawKey, code: stripModifier2(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics(unknownCodes) {
+function buildUnknownParamDiagnostics2(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(APPOINTMENT_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -10443,7 +10680,7 @@ function buildUnknownParamDiagnostics(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference(query, searchParamKeys) {
+function findMalformedReference2(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(APPOINTMENT_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -10466,7 +10703,7 @@ function findMalformedReference(query, searchParamKeys) {
   return void 0;
 }
 async function listAppointmentsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys(
+  const searchParamKeys = extractSearchParamKeys2(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -10482,17 +10719,17 @@ async function listAppointmentsRoute(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 sendInvalidSearch400(
+    return sendInvalidSearch4002(
       res,
-      buildUnknownParamDiagnostics([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics2([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference(
+  const malformedRef = findMalformedReference2(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch400(
+    return sendInvalidSearch4002(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -14758,42 +14995,135 @@ async function getConditionByIdRoute(req, res) {
   const id = String(req.params.id);
   const ctx = req.openhiContext;
   try {
-    const result = await getConditionByIdOperation({ context: ctx, id });
-    return res.json(result.resource);
+    const result = await getConditionByIdOperation({ context: ctx, id });
+    return res.json(result.resource);
+  } catch (err) {
+    const status = domainErrorToHttpStatus(err);
+    if (status === 404) {
+      const diagnostics = err instanceof NotFoundError ? err.message : `Condition ${id} not found`;
+      return sendOperationOutcome404(res, diagnostics);
+    }
+    return sendOperationOutcome500(res, err, "GET Condition error:");
+  }
+}
+
+// src/data/operations/data/condition/condition-list-operation.ts
+async function listConditionsOperation(params) {
+  const { context, tableName, mode } = params;
+  const { tenantId, workspaceId } = context;
+  const service = getDynamoDataService(tableName);
+  return listDataEntitiesByWorkspace(
+    service.entities.condition,
+    tenantId,
+    workspaceId,
+    mode
+  );
+}
+
+// src/data/rest-api/routes/data/condition/condition-list-route.ts
+var CONDITION_RESOURCE_TYPE = "Condition";
+function stripModifier3(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter3(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch4003(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
+  });
+}
+function extractSearchParamKeys3(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter3(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier3(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics3(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(CONDITION_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for Condition: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference3(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(CONDITION_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
+  );
+  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 listConditionsRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys3(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.CONDITION,
+      listOperation: listConditionsOperation,
+      errorLogContext: "GET /Condition list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(CONDITION_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 sendInvalidSearch4003(
+      res,
+      buildUnknownParamDiagnostics3([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference3(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch4003(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: CONDITION_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(BASE_PATH.CONDITION, result.entries);
+    return res.json(bundle);
   } catch (err) {
-    const status = domainErrorToHttpStatus(err);
-    if (status === 404) {
-      const diagnostics = err instanceof NotFoundError ? err.message : `Condition ${id} not found`;
-      return sendOperationOutcome404(res, diagnostics);
-    }
-    return sendOperationOutcome500(res, err, "GET Condition error:");
+    return sendOperationOutcome500(res, err, "GET /Condition search error:");
   }
 }
 
-// src/data/operations/data/condition/condition-list-operation.ts
-async function listConditionsOperation(params) {
-  const { context, tableName, mode } = params;
-  const { tenantId, workspaceId } = context;
-  const service = getDynamoDataService(tableName);
-  return listDataEntitiesByWorkspace(
-    service.entities.condition,
-    tenantId,
-    workspaceId,
-    mode
-  );
-}
-
-// src/data/rest-api/routes/data/condition/condition-list-route.ts
-async function listConditionsRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.CONDITION,
-    listOperation: listConditionsOperation,
-    errorLogContext: "GET /Condition list error:"
-  });
-}
-
 // src/data/operations/data/condition/condition-update-operation.ts
 async function updateConditionOperation(params) {
   const { context, id, body, tableName } = params;
@@ -18055,30 +18385,30 @@ async function listEncountersOperation(params) {
 
 // src/data/rest-api/routes/data/encounter/encounter-list-route.ts
 var ENCOUNTER_RESOURCE_TYPE = "Encounter";
-function stripModifier2(key) {
+function stripModifier4(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter2(key) {
+function isResultParameter4(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch4002(res, diagnostics) {
+function sendInvalidSearch4004(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys2(query) {
+function extractSearchParamKeys4(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter2(rawKey)) {
+    if (isResultParameter4(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier2(rawKey) });
+    out.push({ rawKey, code: stripModifier4(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics2(unknownCodes) {
+function buildUnknownParamDiagnostics4(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(ENCOUNTER_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -18087,7 +18417,7 @@ function buildUnknownParamDiagnostics2(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference2(query, searchParamKeys) {
+function findMalformedReference4(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(ENCOUNTER_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -18110,7 +18440,7 @@ function findMalformedReference2(query, searchParamKeys) {
   return void 0;
 }
 async function listEncountersRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys2(
+  const searchParamKeys = extractSearchParamKeys4(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -18126,17 +18456,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 sendInvalidSearch4002(
+    return sendInvalidSearch4004(
       res,
-      buildUnknownParamDiagnostics2([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics4([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference2(
+  const malformedRef = findMalformedReference4(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch4002(
+    return sendInvalidSearch4004(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -20180,15 +20510,119 @@ async function listFamilyMemberHistorysOperation(params) {
 }
 
 // src/data/rest-api/routes/data/familymemberhistory/familymemberhistory-list-route.ts
-async function listFamilyMemberHistorysRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.FAMILYMEMBERHISTORY,
-    listOperation: listFamilyMemberHistorysOperation,
-    errorLogContext: "GET /FamilyMemberHistory list error:"
+var FAMILYMEMBERHISTORY_RESOURCE_TYPE = "FamilyMemberHistory";
+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(
+    FAMILYMEMBERHISTORY_RESOURCE_TYPE
+  ).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for FamilyMemberHistory: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference5(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(FAMILYMEMBERHISTORY_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
+  );
+  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 listFamilyMemberHistorysRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys5(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.FAMILYMEMBERHISTORY,
+      listOperation: listFamilyMemberHistorysOperation,
+      errorLogContext: "GET /FamilyMemberHistory list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(
+    FAMILYMEMBERHISTORY_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 "Patient/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: FAMILYMEMBERHISTORY_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(
+      BASE_PATH.FAMILYMEMBERHISTORY,
+      result.entries
+    );
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(
+      res,
+      err,
+      "GET /FamilyMemberHistory search error:"
+    );
+  }
+}
 
 // src/data/operations/data/familymemberhistory/familymemberhistory-update-operation.ts
 async function updateFamilyMemberHistoryOperation(params) {
@@ -21757,42 +22191,135 @@ async function getImmunizationByIdRoute(req, res) {
   const id = String(req.params.id);
   const ctx = req.openhiContext;
   try {
-    const result = await getImmunizationByIdOperation({ context: ctx, id });
-    return res.json(result.resource);
+    const result = await getImmunizationByIdOperation({ context: ctx, id });
+    return res.json(result.resource);
+  } catch (err) {
+    const status = domainErrorToHttpStatus(err);
+    if (status === 404) {
+      const diagnostics = err instanceof NotFoundError ? err.message : `Immunization ${id} not found`;
+      return sendOperationOutcome404(res, diagnostics);
+    }
+    return sendOperationOutcome500(res, err, "GET Immunization error:");
+  }
+}
+
+// src/data/operations/data/immunization/immunization-list-operation.ts
+async function listImmunizationsOperation(params) {
+  const { context, tableName, mode } = params;
+  const { tenantId, workspaceId } = context;
+  const service = getDynamoDataService(tableName);
+  return listDataEntitiesByWorkspace(
+    service.entities.immunization,
+    tenantId,
+    workspaceId,
+    mode
+  );
+}
+
+// src/data/rest-api/routes/data/immunization/immunization-list-route.ts
+var IMMUNIZATION_RESOURCE_TYPE = "Immunization";
+function stripModifier6(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter6(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch4006(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
+  });
+}
+function extractSearchParamKeys6(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter6(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier6(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics6(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(IMMUNIZATION_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for Immunization: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference6(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(IMMUNIZATION_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
+  );
+  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 listImmunizationsRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys6(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.IMMUNIZATION,
+      listOperation: listImmunizationsOperation,
+      errorLogContext: "GET /Immunization list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(IMMUNIZATION_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 sendInvalidSearch4006(
+      res,
+      buildUnknownParamDiagnostics6([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference6(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch4006(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: IMMUNIZATION_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(BASE_PATH.IMMUNIZATION, result.entries);
+    return res.json(bundle);
   } catch (err) {
-    const status = domainErrorToHttpStatus(err);
-    if (status === 404) {
-      const diagnostics = err instanceof NotFoundError ? err.message : `Immunization ${id} not found`;
-      return sendOperationOutcome404(res, diagnostics);
-    }
-    return sendOperationOutcome500(res, err, "GET Immunization error:");
+    return sendOperationOutcome500(res, err, "GET /Immunization search error:");
   }
 }
 
-// src/data/operations/data/immunization/immunization-list-operation.ts
-async function listImmunizationsOperation(params) {
-  const { context, tableName, mode } = params;
-  const { tenantId, workspaceId } = context;
-  const service = getDynamoDataService(tableName);
-  return listDataEntitiesByWorkspace(
-    service.entities.immunization,
-    tenantId,
-    workspaceId,
-    mode
-  );
-}
-
-// src/data/rest-api/routes/data/immunization/immunization-list-route.ts
-async function listImmunizationsRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.IMMUNIZATION,
-    listOperation: listImmunizationsOperation,
-    errorLogContext: "GET /Immunization list error:"
-  });
-}
-
 // src/data/operations/data/immunization/immunization-update-operation.ts
 async function updateImmunizationOperation(params) {
   const { context, id, body, tableName } = params;
@@ -25264,15 +25791,119 @@ async function listMedicationRequestsOperation(params) {
 }
 
 // src/data/rest-api/routes/data/medicationrequest/medicationrequest-list-route.ts
-async function listMedicationRequestsRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.MEDICATIONREQUEST,
-    listOperation: listMedicationRequestsOperation,
-    errorLogContext: "GET /MedicationRequest list error:"
+var MEDICATIONREQUEST_RESOURCE_TYPE = "MedicationRequest";
+function stripModifier7(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter7(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch4007(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys7(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter7(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier7(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics7(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(
+    MEDICATIONREQUEST_RESOURCE_TYPE
+  ).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for MedicationRequest: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference7(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(MEDICATIONREQUEST_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
+  );
+  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 listMedicationRequestsRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys7(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.MEDICATIONREQUEST,
+      listOperation: listMedicationRequestsOperation,
+      errorLogContext: "GET /MedicationRequest list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(
+    MEDICATIONREQUEST_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 sendInvalidSearch4007(
+      res,
+      buildUnknownParamDiagnostics7([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference7(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch4007(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: MEDICATIONREQUEST_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(
+      BASE_PATH.MEDICATIONREQUEST,
+      result.entries
+    );
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(
+      res,
+      err,
+      "GET /MedicationRequest search error:"
+    );
+  }
+}
 
 // src/data/operations/data/medicationrequest/medicationrequest-update-operation.ts
 async function updateMedicationRequestOperation(params) {
@@ -25471,15 +26102,119 @@ async function listMedicationStatementsOperation(params) {
 }
 
 // src/data/rest-api/routes/data/medicationstatement/medicationstatement-list-route.ts
-async function listMedicationStatementsRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.MEDICATIONSTATEMENT,
-    listOperation: listMedicationStatementsOperation,
-    errorLogContext: "GET /MedicationStatement list error:"
+var MEDICATIONSTATEMENT_RESOURCE_TYPE = "MedicationStatement";
+function stripModifier8(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter8(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch4008(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys8(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter8(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier8(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics8(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(
+    MEDICATIONSTATEMENT_RESOURCE_TYPE
+  ).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for MedicationStatement: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference8(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(MEDICATIONSTATEMENT_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
+  );
+  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 listMedicationStatementsRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys8(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.MEDICATIONSTATEMENT,
+      listOperation: listMedicationStatementsOperation,
+      errorLogContext: "GET /MedicationStatement list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(
+    MEDICATIONSTATEMENT_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 sendInvalidSearch4008(
+      res,
+      buildUnknownParamDiagnostics8([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference8(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch4008(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: MEDICATIONSTATEMENT_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(
+      BASE_PATH.MEDICATIONSTATEMENT,
+      result.entries
+    );
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(
+      res,
+      err,
+      "GET /MedicationStatement search error:"
+    );
+  }
+}
 
 // src/data/operations/data/medicationstatement/medicationstatement-update-operation.ts
 async function updateMedicationStatementOperation(params) {
@@ -28870,30 +29605,30 @@ async function listObservationsOperation(params) {
 
 // src/data/rest-api/routes/data/observation/observation-list-route.ts
 var OBSERVATION_RESOURCE_TYPE = "Observation";
-function stripModifier3(key) {
+function stripModifier9(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter3(key) {
+function isResultParameter9(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch4003(res, diagnostics) {
+function sendInvalidSearch4009(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys3(query) {
+function extractSearchParamKeys9(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter3(rawKey)) {
+    if (isResultParameter9(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier3(rawKey) });
+    out.push({ rawKey, code: stripModifier9(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics3(unknownCodes) {
+function buildUnknownParamDiagnostics9(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(OBSERVATION_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -28902,7 +29637,7 @@ function buildUnknownParamDiagnostics3(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference3(query, searchParamKeys) {
+function findMalformedReference9(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(OBSERVATION_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -28925,7 +29660,7 @@ function findMalformedReference3(query, searchParamKeys) {
   return void 0;
 }
 async function listObservationsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys3(
+  const searchParamKeys = extractSearchParamKeys9(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -28941,17 +29676,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 sendInvalidSearch4003(
+    return sendInvalidSearch4009(
       res,
-      buildUnknownParamDiagnostics3([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics9([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference3(
+  const malformedRef = findMalformedReference9(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch4003(
+    return sendInvalidSearch4009(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -29981,30 +30716,30 @@ async function listPatientsOperation(params) {
 
 // src/data/rest-api/routes/data/patient/patient-list-route.ts
 var PATIENT_RESOURCE_TYPE = "Patient";
-function stripModifier4(key) {
+function stripModifier10(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter4(key) {
+function isResultParameter10(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch4004(res, diagnostics) {
+function sendInvalidSearch40010(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys4(query) {
+function extractSearchParamKeys10(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter4(rawKey)) {
+    if (isResultParameter10(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier4(rawKey) });
+    out.push({ rawKey, code: stripModifier10(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics4(unknownCodes) {
+function buildUnknownParamDiagnostics10(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(PATIENT_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -30013,7 +30748,7 @@ function buildUnknownParamDiagnostics4(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference4(query, searchParamKeys) {
+function findMalformedReference10(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(PATIENT_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -30036,7 +30771,7 @@ function findMalformedReference4(query, searchParamKeys) {
   return void 0;
 }
 async function listPatientsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys4(
+  const searchParamKeys = extractSearchParamKeys10(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -30052,17 +30787,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 sendInvalidSearch4004(
+    return sendInvalidSearch40010(
       res,
-      buildUnknownParamDiagnostics4([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics10([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference4(
+  const malformedRef = findMalformedReference10(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch4004(
+    return sendInvalidSearch40010(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -31437,30 +32172,30 @@ async function listProceduresOperation(params) {
 
 // src/data/rest-api/routes/data/procedure/procedure-list-route.ts
 var PROCEDURE_RESOURCE_TYPE = "Procedure";
-function stripModifier5(key) {
+function stripModifier11(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter5(key) {
+function isResultParameter11(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch4005(res, diagnostics) {
+function sendInvalidSearch40011(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys5(query) {
+function extractSearchParamKeys11(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter5(rawKey)) {
+    if (isResultParameter11(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier5(rawKey) });
+    out.push({ rawKey, code: stripModifier11(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics5(unknownCodes) {
+function buildUnknownParamDiagnostics11(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(PROCEDURE_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -31469,7 +32204,7 @@ function buildUnknownParamDiagnostics5(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference5(query, searchParamKeys) {
+function findMalformedReference11(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(PROCEDURE_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -31492,7 +32227,7 @@ function findMalformedReference5(query, searchParamKeys) {
   return void 0;
 }
 async function listProceduresRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys5(
+  const searchParamKeys = extractSearchParamKeys11(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -31508,17 +32243,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 sendInvalidSearch4005(
+    return sendInvalidSearch40011(
       res,
-      buildUnknownParamDiagnostics5([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics11([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference5(
+  const malformedRef = findMalformedReference11(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch4005(
+    return sendInvalidSearch40011(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -34045,7 +34780,7 @@ function singleStringQueryParam(req, name) {
   const trimmed = v.trim();
   return trimmed === "" ? void 0 : trimmed;
 }
-function sendInvalidSearch4006(res, diagnostics) {
+function sendInvalidSearch40012(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
@@ -34055,7 +34790,7 @@ async function listSchedulesRoute(req, res) {
   const actorRef = singleStringQueryParam(req, "actor");
   if (actorRef !== void 0) {
     if (parseTypedReference(actorRef) === void 0) {
-      return sendInvalidSearch4006(
+      return sendInvalidSearch40012(
         res,
         `?actor must be a typed reference like "Practitioner/<id>"; got "${actorRef}".`
       );
@@ -37853,7 +38588,7 @@ function singleStringQueryParam2(req, name) {
   const trimmed = v.trim();
   return trimmed === "" ? void 0 : trimmed;
 }
-function sendInvalidSearch4007(res, diagnostics) {
+function sendInvalidSearch40013(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
@@ -37863,14 +38598,14 @@ async function listTasksRoute(req, res) {
   const ownerRef = singleStringQueryParam2(req, "owner");
   const requesterRef = singleStringQueryParam2(req, "requester");
   if (ownerRef !== void 0 && requesterRef !== void 0) {
-    return sendInvalidSearch4007(
+    return sendInvalidSearch40013(
       res,
       "?owner= and ?requester= cannot be combined on the same request."
     );
   }
   if (ownerRef !== void 0) {
     if (parseTypedReference(ownerRef) === void 0) {
-      return sendInvalidSearch4007(
+      return sendInvalidSearch40013(
         res,
         `?owner must be a typed reference like "Practitioner/<id>"; got "${ownerRef}".`
       );
@@ -37893,7 +38628,7 @@ async function listTasksRoute(req, res) {
   }
   if (requesterRef !== void 0) {
     if (parseTypedReference(requesterRef) === void 0) {
-      return sendInvalidSearch4007(
+      return sendInvalidSearch40013(
         res,
         `?requester must be a typed reference like "Practitioner/<id>"; got "${requesterRef}".`
       );