@openhi/constructs 0.0.144 → 0.0.146

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

@@ -44,7 +44,7 @@ import {
   membershipListByUserOperation,
   switchUserTenantWorkspaceOperation,
   updateUserOperation
-} from "./chunk-UT7ADSEJ.mjs";
+} from "./chunk-AOSEKL7U.mjs";
 import {
   batchGetWithRetry,
   buildUpdatedResourceWithAudit,
@@ -5209,7 +5209,6 @@ async function listAllergyIntolerancesOperation(params) {
 function buildOpenHiResourceUrn(opts) {
   return `urn:ohi:${opts.tenantId}:${opts.workspaceId}:${opts.resourceType}:${opts.resourceId}`;
 }
-var REFERENCE_CONTAINMENT_SQL_FRAGMENT = "(resource @> :containmentRelative::jsonb OR resource @> :containmentUrn::jsonb)";
 function parseTypedReference(s) {
   const match = /^([A-Za-z][A-Za-z0-9_]*)\/([^\s/]+)$/.exec(s);
   if (!match) {
@@ -5879,6 +5878,89 @@ var APPOINTMENT_SEARCH_PARAMETERS = [
   { code: "slot", type: "reference", jsonbPath: "$.slot[*]" }
 ];
 
+// src/data/search/registry/chargeitem-search-parameters.ts
+var CHARGEITEM_SEARCH_PARAMETERS = [
+  { code: "account", type: "reference", jsonbPath: "$.account[*]" },
+  { code: "code", type: "token", jsonbPath: "$.code" },
+  { code: "context", type: "reference", jsonbPath: "$.context" },
+  { code: "entered-date", type: "date", jsonbPath: "$.enteredDate" },
+  { code: "enterer", type: "reference", jsonbPath: "$.enterer" },
+  {
+    code: "factor-override",
+    type: "string",
+    jsonbPath: "$.factorOverride",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
+  { code: "occurrence", type: "date", jsonbPath: "$.occurrenceDateTime" },
+  { code: "patient", type: "reference", jsonbPath: "$.subject" },
+  {
+    code: "performer-actor",
+    type: "reference",
+    jsonbPath: "$.performer[*].actor"
+  },
+  {
+    code: "performer-function",
+    type: "token",
+    jsonbPath: "$.performer[*].function"
+  },
+  {
+    code: "performing-organization",
+    type: "reference",
+    jsonbPath: "$.performingOrganization"
+  },
+  {
+    code: "requesting-organization",
+    type: "reference",
+    jsonbPath: "$.requestingOrganization"
+  },
+  { code: "service", type: "reference", jsonbPath: "$.service[*]" },
+  { code: "subject", type: "reference", jsonbPath: "$.subject" }
+];
+
+// src/data/search/registry/claim-search-parameters.ts
+var CLAIM_SEARCH_PARAMETERS = [
+  {
+    code: "care-team",
+    type: "reference",
+    jsonbPath: "$.careTeam[*].provider"
+  },
+  { code: "created", type: "date", jsonbPath: "$.created" },
+  { code: "enterer", type: "reference", jsonbPath: "$.enterer" },
+  { code: "facility", type: "reference", jsonbPath: "$.facility" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
+  { code: "insurer", type: "reference", jsonbPath: "$.insurer" },
+  { code: "patient", type: "reference", jsonbPath: "$.patient" },
+  { code: "priority", type: "token", jsonbPath: "$.priority" },
+  { code: "provider", type: "reference", jsonbPath: "$.provider" },
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "use", type: "token", jsonbPath: "$.use" }
+];
+
+// src/data/search/registry/composition-search-parameters.ts
+var COMPOSITION_SEARCH_PARAMETERS = [
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "type", type: "token", jsonbPath: "$.type" },
+  { code: "category", type: "token", jsonbPath: "$.category[*]" },
+  { code: "subject", type: "reference", jsonbPath: "$.subject" },
+  { code: "patient", type: "reference", jsonbPath: "$.subject" },
+  { code: "encounter", type: "reference", jsonbPath: "$.encounter" },
+  { code: "author", type: "reference", jsonbPath: "$.author[*]" },
+  { code: "date", type: "date", jsonbPath: "$.date" },
+  {
+    code: "confidentiality",
+    type: "token",
+    jsonbPath: "$.confidentiality"
+  },
+  {
+    code: "title",
+    type: "string",
+    jsonbPath: "$.title",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier" }
+];
+
 // src/data/search/registry/condition-search-parameters.ts
 var CONDITION_SEARCH_PARAMETERS = [
   {
@@ -5905,6 +5987,121 @@ var CONDITION_SEARCH_PARAMETERS = [
   { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" }
 ];
 
+// src/data/search/registry/coverage-search-parameters.ts
+var COVERAGE_SEARCH_PARAMETERS = [
+  { code: "beneficiary", type: "reference", jsonbPath: "$.beneficiary" },
+  { code: "class-type", type: "token", jsonbPath: "$.class[*].type" },
+  {
+    code: "class-value",
+    type: "string",
+    jsonbPath: "$.class[*].value",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  {
+    code: "dependent",
+    type: "string",
+    jsonbPath: "$.dependent",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
+  { code: "patient", type: "reference", jsonbPath: "$.beneficiary" },
+  { code: "payor", type: "reference", jsonbPath: "$.payor[*]" },
+  {
+    code: "policy-holder",
+    type: "reference",
+    jsonbPath: "$.policyHolder"
+  },
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "subscriber", type: "reference", jsonbPath: "$.subscriber" },
+  { code: "type", type: "token", jsonbPath: "$.type" }
+];
+
+// src/data/search/registry/diagnosticreport-search-parameters.ts
+var DIAGNOSTICREPORT_SEARCH_PARAMETERS = [
+  { code: "based-on", type: "reference", jsonbPath: "$.basedOn[*]" },
+  { code: "category", type: "token", jsonbPath: "$.category[*]" },
+  { code: "code", type: "token", jsonbPath: "$.code" },
+  {
+    code: "conclusion",
+    type: "token",
+    jsonbPath: "$.conclusionCode[*]"
+  },
+  { code: "date", type: "date", jsonbPath: "$.effectiveDateTime" },
+  { code: "encounter", type: "reference", jsonbPath: "$.encounter" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
+  { code: "issued", type: "date", jsonbPath: "$.issued" },
+  { code: "patient", type: "reference", jsonbPath: "$.subject" },
+  { code: "performer", type: "reference", jsonbPath: "$.performer[*]" },
+  { code: "result", type: "reference", jsonbPath: "$.result[*]" },
+  {
+    code: "results-interpreter",
+    type: "reference",
+    jsonbPath: "$.resultsInterpreter[*]"
+  },
+  { code: "specimen", type: "reference", jsonbPath: "$.specimen[*]" },
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "subject", type: "reference", jsonbPath: "$.subject" }
+];
+
+// src/data/search/registry/documentmanifest-search-parameters.ts
+var DOCUMENTMANIFEST_SEARCH_PARAMETERS = [
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "type", type: "token", jsonbPath: "$.type" },
+  { code: "subject", type: "reference", jsonbPath: "$.subject" },
+  { code: "patient", type: "reference", jsonbPath: "$.subject" },
+  { code: "author", type: "reference", jsonbPath: "$.author[*]" },
+  { code: "recipient", type: "reference", jsonbPath: "$.recipient[*]" },
+  { code: "created", type: "date", jsonbPath: "$.created" },
+  {
+    code: "description",
+    type: "string",
+    jsonbPath: "$.description",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier" },
+  {
+    code: "source",
+    type: "string",
+    jsonbPath: "$.source",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  {
+    code: "related-id",
+    type: "token",
+    jsonbPath: "$.related[*].identifier"
+  },
+  {
+    code: "related-ref",
+    type: "reference",
+    jsonbPath: "$.related[*].ref"
+  }
+];
+
+// src/data/search/registry/documentreference-search-parameters.ts
+var DOCUMENTREFERENCE_SEARCH_PARAMETERS = [
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "docStatus", type: "token", jsonbPath: "$.docStatus" },
+  { code: "type", type: "token", jsonbPath: "$.type" },
+  { code: "category", type: "token", jsonbPath: "$.category[*]" },
+  { code: "subject", type: "reference", jsonbPath: "$.subject" },
+  { code: "patient", type: "reference", jsonbPath: "$.subject" },
+  { code: "author", type: "reference", jsonbPath: "$.author[*]" },
+  {
+    code: "authenticator",
+    type: "reference",
+    jsonbPath: "$.authenticator"
+  },
+  { code: "custodian", type: "reference", jsonbPath: "$.custodian" },
+  { code: "date", type: "date", jsonbPath: "$.date" },
+  {
+    code: "description",
+    type: "string",
+    jsonbPath: "$.description",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" }
+];
+
 // src/data/search/registry/encounter-search-parameters.ts
 var ENCOUNTER_SEARCH_PARAMETERS = [
   { code: "status", type: "token", jsonbPath: "$.status" },
@@ -5931,6 +6128,61 @@ var ENCOUNTER_SEARCH_PARAMETERS = [
   }
 ];
 
+// src/data/search/registry/endpoint-search-parameters.ts
+var ENDPOINT_SEARCH_PARAMETERS = [
+  {
+    code: "connection-type",
+    type: "token",
+    jsonbPath: "$.connectionType"
+  },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
+  {
+    code: "name",
+    type: "string",
+    jsonbPath: "$.name",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  {
+    code: "organization",
+    type: "reference",
+    jsonbPath: "$.managingOrganization"
+  },
+  {
+    code: "payload-type",
+    type: "token",
+    jsonbPath: "$.payloadType[*]"
+  },
+  { code: "status", type: "token", jsonbPath: "$.status" }
+];
+
+// src/data/search/registry/explanationofbenefit-search-parameters.ts
+var EXPLANATIONOFBENEFIT_SEARCH_PARAMETERS = [
+  {
+    code: "care-team",
+    type: "reference",
+    jsonbPath: "$.careTeam[*].provider"
+  },
+  { code: "claim", type: "reference", jsonbPath: "$.claim" },
+  {
+    code: "coverage",
+    type: "reference",
+    jsonbPath: "$.insurance[*].coverage"
+  },
+  { code: "created", type: "date", jsonbPath: "$.created" },
+  {
+    code: "disposition",
+    type: "string",
+    jsonbPath: "$.disposition",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  { code: "enterer", type: "reference", jsonbPath: "$.enterer" },
+  { code: "facility", type: "reference", jsonbPath: "$.facility" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
+  { code: "patient", type: "reference", jsonbPath: "$.patient" },
+  { code: "provider", type: "reference", jsonbPath: "$.provider" },
+  { code: "status", type: "token", jsonbPath: "$.status" }
+];
+
 // src/data/search/registry/familymemberhistory-search-parameters.ts
 var FAMILYMEMBERHISTORY_SEARCH_PARAMETERS = [
   { code: "status", type: "token", jsonbPath: "$.status" },
@@ -5942,6 +6194,24 @@ var FAMILYMEMBERHISTORY_SEARCH_PARAMETERS = [
   { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" }
 ];
 
+// src/data/search/registry/imagingstudy-search-parameters.ts
+var IMAGINGSTUDY_SEARCH_PARAMETERS = [
+  { code: "basedon", type: "reference", jsonbPath: "$.basedOn[*]" },
+  { code: "bodysite", type: "token", jsonbPath: "$.series[*].bodySite" },
+  { code: "encounter", type: "reference", jsonbPath: "$.encounter" },
+  { code: "endpoint", type: "reference", jsonbPath: "$.endpoint[*]" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
+  { code: "interpreter", type: "reference", jsonbPath: "$.interpreter[*]" },
+  { code: "modality", type: "token", jsonbPath: "$.series[*].modality" },
+  { code: "patient", type: "reference", jsonbPath: "$.subject" },
+  { code: "reason", type: "token", jsonbPath: "$.reasonCode[*]" },
+  { code: "referrer", type: "reference", jsonbPath: "$.referrer" },
+  { code: "series", type: "token", jsonbPath: "$.series[*].uid" },
+  { code: "started", type: "date", jsonbPath: "$.started" },
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "subject", type: "reference", jsonbPath: "$.subject" }
+];
+
 // src/data/search/registry/immunization-search-parameters.ts
 var IMMUNIZATION_SEARCH_PARAMETERS = [
   { code: "status", type: "token", jsonbPath: "$.status" },
@@ -5968,6 +6238,54 @@ var IMMUNIZATION_SEARCH_PARAMETERS = [
   { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" }
 ];
 
+// src/data/search/registry/invoice-search-parameters.ts
+var INVOICE_SEARCH_PARAMETERS = [
+  { code: "account", type: "reference", jsonbPath: "$.account" },
+  { code: "date", type: "date", jsonbPath: "$.date" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
+  { code: "issuer", type: "reference", jsonbPath: "$.issuer" },
+  {
+    code: "participant",
+    type: "reference",
+    jsonbPath: "$.participant[*].actor"
+  },
+  {
+    code: "participant-role",
+    type: "token",
+    jsonbPath: "$.participant[*].role"
+  },
+  { code: "patient", type: "reference", jsonbPath: "$.subject" },
+  { code: "recipient", type: "reference", jsonbPath: "$.recipient" },
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "subject", type: "reference", jsonbPath: "$.subject" },
+  { code: "type", type: "token", jsonbPath: "$.type" }
+];
+
+// src/data/search/registry/location-search-parameters.ts
+var LOCATION_SEARCH_PARAMETERS = [
+  { code: "endpoint", type: "reference", jsonbPath: "$.endpoint[*]" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
+  {
+    code: "name",
+    type: "string",
+    jsonbPath: "$.name",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  {
+    code: "operational-status",
+    type: "token",
+    jsonbPath: "$.operationalStatus"
+  },
+  {
+    code: "organization",
+    type: "reference",
+    jsonbPath: "$.managingOrganization"
+  },
+  { code: "partof", type: "reference", jsonbPath: "$.partOf" },
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "type", type: "token", jsonbPath: "$.type[*]" }
+];
+
 // src/data/search/registry/medicationrequest-search-parameters.ts
 var MEDICATIONREQUEST_SEARCH_PARAMETERS = [
   { code: "status", type: "token", jsonbPath: "$.status" },
@@ -6029,6 +6347,58 @@ var OBSERVATION_SEARCH_PARAMETERS = [
   { code: "part-of", type: "reference", jsonbPath: "$.partOf[*]" }
 ];
 
+// src/data/search/registry/organization-search-parameters.ts
+var ORGANIZATION_SEARCH_PARAMETERS = [
+  { code: "active", type: "token", jsonbPath: "$.active" },
+  {
+    code: "address",
+    type: "string",
+    jsonbPath: "$.address[*].text",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  {
+    code: "address-city",
+    type: "string",
+    jsonbPath: "$.address[*].city",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  {
+    code: "address-country",
+    type: "string",
+    jsonbPath: "$.address[*].country",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  {
+    code: "address-postalcode",
+    type: "string",
+    jsonbPath: "$.address[*].postalCode",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  {
+    code: "address-state",
+    type: "string",
+    jsonbPath: "$.address[*].state",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  { code: "address-use", type: "token", jsonbPath: "$.address[*].use" },
+  { code: "endpoint", type: "reference", jsonbPath: "$.endpoint[*]" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
+  {
+    code: "name",
+    type: "string",
+    jsonbPath: "$.name",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  { code: "partof", type: "reference", jsonbPath: "$.partOf" },
+  {
+    code: "phonetic",
+    type: "string",
+    jsonbPath: "$.name",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  { code: "type", type: "token", jsonbPath: "$.type[*]" }
+];
+
 // src/data/search/registry/patient-search-parameters.ts
 var PATIENT_SEARCH_PARAMETERS = [
   { code: "gender", type: "token", jsonbPath: "$.gender" },
@@ -6066,6 +6436,101 @@ var PATIENT_SEARCH_PARAMETERS = [
   }
 ];
 
+// src/data/search/registry/paymentnotice-search-parameters.ts
+var PAYMENTNOTICE_SEARCH_PARAMETERS = [
+  { code: "created", type: "date", jsonbPath: "$.created" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
+  {
+    code: "payment-status",
+    type: "token",
+    jsonbPath: "$.paymentStatus"
+  },
+  { code: "provider", type: "reference", jsonbPath: "$.provider" },
+  { code: "request", type: "reference", jsonbPath: "$.request" },
+  { code: "response", type: "reference", jsonbPath: "$.response" },
+  { code: "status", type: "token", jsonbPath: "$.status" }
+];
+
+// src/data/search/registry/practitioner-search-parameters.ts
+var PRACTITIONER_SEARCH_PARAMETERS = [
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
+  {
+    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: "gender", type: "token", jsonbPath: "$.gender" },
+  { code: "email", type: "token", jsonbPath: "$.telecom[*]" },
+  { code: "phone", type: "token", jsonbPath: "$.telecom[*]" },
+  { code: "telecom", type: "token", jsonbPath: "$.telecom[*]" },
+  {
+    code: "address",
+    type: "string",
+    jsonbPath: "$.address[*].text",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  {
+    code: "address-city",
+    type: "string",
+    jsonbPath: "$.address[*].city",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  {
+    code: "address-country",
+    type: "string",
+    jsonbPath: "$.address[*].country",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  {
+    code: "address-postalcode",
+    type: "string",
+    jsonbPath: "$.address[*].postalCode",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  {
+    code: "address-state",
+    type: "string",
+    jsonbPath: "$.address[*].state",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  { code: "communication", type: "token", jsonbPath: "$.communication[*]" }
+];
+
+// src/data/search/registry/practitionerrole-search-parameters.ts
+var PRACTITIONERROLE_SEARCH_PARAMETERS = [
+  { code: "active", type: "token", jsonbPath: "$.active" },
+  { code: "date", type: "date", jsonbPath: "$.period.start" },
+  { code: "email", type: "token", jsonbPath: "$.telecom[*]" },
+  { code: "phone", type: "token", jsonbPath: "$.telecom[*]" },
+  { code: "telecom", type: "token", jsonbPath: "$.telecom[*]" },
+  { code: "endpoint", type: "reference", jsonbPath: "$.endpoint[*]" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
+  { code: "location", type: "reference", jsonbPath: "$.location[*]" },
+  { code: "organization", type: "reference", jsonbPath: "$.organization" },
+  { code: "practitioner", type: "reference", jsonbPath: "$.practitioner" },
+  { code: "role", type: "token", jsonbPath: "$.code[*]" },
+  {
+    code: "service",
+    type: "reference",
+    jsonbPath: "$.healthcareService[*]"
+  },
+  { code: "specialty", type: "token", jsonbPath: "$.specialty[*]" }
+];
+
 // src/data/search/registry/procedure-search-parameters.ts
 var PROCEDURE_SEARCH_PARAMETERS = [
   { code: "status", type: "token", jsonbPath: "$.status" },
@@ -6092,19 +6557,160 @@ var PROCEDURE_SEARCH_PARAMETERS = [
   }
 ];
 
+// src/data/search/registry/relatedperson-search-parameters.ts
+var RELATEDPERSON_SEARCH_PARAMETERS = [
+  { code: "active", type: "token", jsonbPath: "$.active" },
+  {
+    code: "address",
+    type: "string",
+    jsonbPath: "$.address[*].text",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  {
+    code: "address-city",
+    type: "string",
+    jsonbPath: "$.address[*].city",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  { code: "birthdate", type: "date", jsonbPath: "$.birthDate" },
+  { code: "email", type: "token", jsonbPath: "$.telecom[*]" },
+  { code: "phone", type: "token", jsonbPath: "$.telecom[*]" },
+  { code: "telecom", type: "token", jsonbPath: "$.telecom[*]" },
+  { code: "gender", type: "token", jsonbPath: "$.gender" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
+  {
+    code: "name",
+    type: "string",
+    jsonbPath: "$.name[*].text",
+    modifiers: ["exact", "contains", "missing", "not"]
+  },
+  { code: "patient", type: "reference", jsonbPath: "$.patient" },
+  {
+    code: "relationship",
+    type: "token",
+    jsonbPath: "$.relationship[*]"
+  }
+];
+
+// src/data/search/registry/schedule-search-parameters.ts
+var SCHEDULE_SEARCH_PARAMETERS = [
+  { code: "active", type: "token", jsonbPath: "$.active" },
+  { code: "actor", type: "reference", jsonbPath: "$.actor[*]" },
+  { code: "date", type: "date", jsonbPath: "$.planningHorizon.start" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
+  {
+    code: "service-category",
+    type: "token",
+    jsonbPath: "$.serviceCategory[*]"
+  },
+  { code: "service-type", type: "token", jsonbPath: "$.serviceType[*]" },
+  { code: "specialty", type: "token", jsonbPath: "$.specialty[*]" }
+];
+
+// src/data/search/registry/slot-search-parameters.ts
+var SLOT_SEARCH_PARAMETERS = [
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "start", type: "date", jsonbPath: "$.start" },
+  { code: "schedule", type: "reference", jsonbPath: "$.schedule" },
+  {
+    code: "appointment-type",
+    type: "token",
+    jsonbPath: "$.appointmentType"
+  },
+  {
+    code: "service-category",
+    type: "token",
+    jsonbPath: "$.serviceCategory[*]"
+  },
+  { code: "service-type", type: "token", jsonbPath: "$.serviceType[*]" },
+  { code: "specialty", type: "token", jsonbPath: "$.specialty[*]" },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" }
+];
+
+// src/data/search/registry/specimen-search-parameters.ts
+var SPECIMEN_SEARCH_PARAMETERS = [
+  { code: "accession", type: "token", jsonbPath: "$.accessionIdentifier" },
+  {
+    code: "collected",
+    type: "date",
+    jsonbPath: "$.collection.collectedDateTime"
+  },
+  {
+    code: "container-id",
+    type: "token",
+    jsonbPath: "$.container[*].identifier"
+  },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" },
+  { code: "parent", type: "reference", jsonbPath: "$.parent[*]" },
+  { code: "patient", type: "reference", jsonbPath: "$.subject" },
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "subject", type: "reference", jsonbPath: "$.subject" },
+  { code: "type", type: "token", jsonbPath: "$.type" }
+];
+
+// src/data/search/registry/task-search-parameters.ts
+var TASK_SEARCH_PARAMETERS = [
+  { code: "status", type: "token", jsonbPath: "$.status" },
+  { code: "intent", type: "token", jsonbPath: "$.intent" },
+  { code: "priority", type: "token", jsonbPath: "$.priority" },
+  { code: "code", type: "token", jsonbPath: "$.code" },
+  { code: "business-status", type: "token", jsonbPath: "$.businessStatus" },
+  { code: "subject", type: "reference", jsonbPath: "$.for" },
+  { code: "patient", type: "reference", jsonbPath: "$.for" },
+  { code: "for", type: "reference", jsonbPath: "$.for" },
+  { code: "encounter", type: "reference", jsonbPath: "$.encounter" },
+  { code: "focus", type: "reference", jsonbPath: "$.focus" },
+  { code: "owner", type: "reference", jsonbPath: "$.owner" },
+  { code: "requester", type: "reference", jsonbPath: "$.requester" },
+  { code: "performer", type: "token", jsonbPath: "$.performerType[*]" },
+  { code: "based-on", type: "reference", jsonbPath: "$.basedOn[*]" },
+  { code: "part-of", type: "reference", jsonbPath: "$.partOf[*]" },
+  { code: "period", type: "date", jsonbPath: "$.executionPeriod.start" },
+  { code: "authored-on", type: "date", jsonbPath: "$.authoredOn" },
+  { code: "modified", type: "date", jsonbPath: "$.lastModified" },
+  { code: "reason-code", type: "token", jsonbPath: "$.reasonCode" },
+  {
+    code: "reason-reference",
+    type: "reference",
+    jsonbPath: "$.reasonReference"
+  },
+  { code: "identifier", type: "token", jsonbPath: "$.identifier[*]" }
+];
+
 // src/data/search/registry/resolver.ts
 var STATIC_SEARCH_PARAMETER_MAP = {
   AllergyIntolerance: ALLERGYINTOLERANCE_SEARCH_PARAMETERS,
   Appointment: APPOINTMENT_SEARCH_PARAMETERS,
+  ChargeItem: CHARGEITEM_SEARCH_PARAMETERS,
+  Claim: CLAIM_SEARCH_PARAMETERS,
+  Composition: COMPOSITION_SEARCH_PARAMETERS,
   Condition: CONDITION_SEARCH_PARAMETERS,
+  Coverage: COVERAGE_SEARCH_PARAMETERS,
+  DiagnosticReport: DIAGNOSTICREPORT_SEARCH_PARAMETERS,
+  DocumentManifest: DOCUMENTMANIFEST_SEARCH_PARAMETERS,
+  DocumentReference: DOCUMENTREFERENCE_SEARCH_PARAMETERS,
   Encounter: ENCOUNTER_SEARCH_PARAMETERS,
+  Endpoint: ENDPOINT_SEARCH_PARAMETERS,
+  ExplanationOfBenefit: EXPLANATIONOFBENEFIT_SEARCH_PARAMETERS,
   FamilyMemberHistory: FAMILYMEMBERHISTORY_SEARCH_PARAMETERS,
+  ImagingStudy: IMAGINGSTUDY_SEARCH_PARAMETERS,
   Immunization: IMMUNIZATION_SEARCH_PARAMETERS,
+  Invoice: INVOICE_SEARCH_PARAMETERS,
+  Location: LOCATION_SEARCH_PARAMETERS,
   MedicationRequest: MEDICATIONREQUEST_SEARCH_PARAMETERS,
   MedicationStatement: MEDICATIONSTATEMENT_SEARCH_PARAMETERS,
   Observation: OBSERVATION_SEARCH_PARAMETERS,
+  Organization: ORGANIZATION_SEARCH_PARAMETERS,
   Patient: PATIENT_SEARCH_PARAMETERS,
-  Procedure: PROCEDURE_SEARCH_PARAMETERS
+  PaymentNotice: PAYMENTNOTICE_SEARCH_PARAMETERS,
+  Practitioner: PRACTITIONER_SEARCH_PARAMETERS,
+  PractitionerRole: PRACTITIONERROLE_SEARCH_PARAMETERS,
+  Procedure: PROCEDURE_SEARCH_PARAMETERS,
+  RelatedPerson: RELATEDPERSON_SEARCH_PARAMETERS,
+  Schedule: SCHEDULE_SEARCH_PARAMETERS,
+  Slot: SLOT_SEARCH_PARAMETERS,
+  Specimen: SPECIMEN_SEARCH_PARAMETERS,
+  Task: TASK_SEARCH_PARAMETERS
 };
 var defaultSearchParameterResolver = (resourceType, _tenantId) => STATIC_SEARCH_PARAMETER_MAP[resourceType] ?? [];
 function getRegisteredSearchParameters(resourceType) {
@@ -8542,15 +9148,111 @@ async function listChargeItemsOperation(params) {
 }
 
 // src/data/rest-api/routes/data/chargeitem/chargeitem-list-route.ts
-async function listChargeItemsRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.CHARGEITEM,
-    listOperation: listChargeItemsOperation,
-    errorLogContext: "GET /ChargeItem list error:"
+var CHARGEITEM_RESOURCE_TYPE = "ChargeItem";
+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(CHARGEITEM_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for ChargeItem: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference3(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(CHARGEITEM_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 listChargeItemsRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys3(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.CHARGEITEM,
+      listOperation: listChargeItemsOperation,
+      errorLogContext: "GET /ChargeItem list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(CHARGEITEM_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 "Patient/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: CHARGEITEM_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(BASE_PATH.CHARGEITEM, result.entries);
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /ChargeItem search error:");
+  }
+}
 
 // src/data/operations/data/chargeitem/chargeitem-update-operation.ts
 async function updateChargeItemOperation(params) {
@@ -8953,15 +9655,111 @@ async function listClaimsOperation(params) {
 }
 
 // src/data/rest-api/routes/data/claim/claim-list-route.ts
-async function listClaimsRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.CLAIM,
-    listOperation: listClaimsOperation,
-    errorLogContext: "GET /Claim list error:"
+var CLAIM_RESOURCE_TYPE = "Claim";
+function stripModifier4(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter4(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch4004(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys4(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter4(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier4(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics4(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(CLAIM_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for Claim: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference4(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(CLAIM_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 listClaimsRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys4(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.CLAIM,
+      listOperation: listClaimsOperation,
+      errorLogContext: "GET /Claim list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(CLAIM_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 sendInvalidSearch4004(
+      res,
+      buildUnknownParamDiagnostics4([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference4(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch4004(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: CLAIM_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(BASE_PATH.CLAIM, result.entries);
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /Claim search error:");
+  }
+}
 
 // src/data/operations/data/claim/claim-update-operation.ts
 async function updateClaimOperation(params) {
@@ -10390,15 +11188,111 @@ async function listCompositionsOperation(params) {
 }
 
 // src/data/rest-api/routes/data/composition/composition-list-route.ts
-async function listCompositionsRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.COMPOSITION,
-    listOperation: listCompositionsOperation,
-    errorLogContext: "GET /Composition list error:"
+var COMPOSITION_RESOURCE_TYPE = "Composition";
+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(COMPOSITION_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for Composition: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference5(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(COMPOSITION_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 listCompositionsRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys5(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.COMPOSITION,
+      listOperation: listCompositionsOperation,
+      errorLogContext: "GET /Composition list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(COMPOSITION_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: COMPOSITION_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(BASE_PATH.COMPOSITION, result.entries);
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /Composition search error:");
+  }
+}
 
 // src/data/operations/data/composition/composition-update-operation.ts
 async function updateCompositionOperation(params) {
@@ -10791,30 +11685,30 @@ async function listConditionsOperation(params) {
 
 // src/data/rest-api/routes/data/condition/condition-list-route.ts
 var CONDITION_RESOURCE_TYPE = "Condition";
-function stripModifier3(key) {
+function stripModifier6(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter3(key) {
+function isResultParameter6(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch4003(res, diagnostics) {
+function sendInvalidSearch4006(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys3(query) {
+function extractSearchParamKeys6(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter3(rawKey)) {
+    if (isResultParameter6(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier3(rawKey) });
+    out.push({ rawKey, code: stripModifier6(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics3(unknownCodes) {
+function buildUnknownParamDiagnostics6(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(CONDITION_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -10823,7 +11717,7 @@ function buildUnknownParamDiagnostics3(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference3(query, searchParamKeys) {
+function findMalformedReference6(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(CONDITION_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -10846,7 +11740,7 @@ function findMalformedReference3(query, searchParamKeys) {
   return void 0;
 }
 async function listConditionsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys3(
+  const searchParamKeys = extractSearchParamKeys6(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -10862,17 +11756,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 sendInvalidSearch4003(
+    return sendInvalidSearch4006(
       res,
-      buildUnknownParamDiagnostics3([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics6([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference3(
+  const malformedRef = findMalformedReference6(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch4003(
+    return sendInvalidSearch4006(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -11486,15 +12380,120 @@ async function listCoveragesOperation(params) {
 }
 
 // src/data/rest-api/routes/data/coverage/coverage-list-route.ts
-async function listCoveragesRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.COVERAGE,
-    listOperation: listCoveragesOperation,
-    errorLogContext: "GET /Coverage list error:"
+var COVERAGE_RESOURCE_TYPE = "Coverage";
+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(COVERAGE_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for Coverage: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference7(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(COVERAGE_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 listCoveragesRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys7(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.COVERAGE,
+      listOperation: listCoveragesOperation,
+      errorLogContext: "GET /Coverage list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(
+    COVERAGE_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 "Patient/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: COVERAGE_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(
+      BASE_PATH.COVERAGE,
+      result.entries
+    );
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(
+      res,
+      err,
+      "GET /Coverage search error:"
+    );
+  }
+}
 
 // src/data/operations/data/coverage/coverage-update-operation.ts
 async function updateCoverageOperation(params) {
@@ -13331,15 +14330,122 @@ async function listDiagnosticReportsOperation(params) {
 }
 
 // src/data/rest-api/routes/data/diagnosticreport/diagnosticreport-list-route.ts
-async function listDiagnosticReportsRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.DIAGNOSTICREPORT,
-    listOperation: listDiagnosticReportsOperation,
-    errorLogContext: "GET /DiagnosticReport list error:"
+var DIAGNOSTICREPORT_RESOURCE_TYPE = "DiagnosticReport";
+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(
+    DIAGNOSTICREPORT_RESOURCE_TYPE
+  ).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for DiagnosticReport: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference8(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(DIAGNOSTICREPORT_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 listDiagnosticReportsRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys8(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.DIAGNOSTICREPORT,
+      listOperation: listDiagnosticReportsOperation,
+      errorLogContext: "GET /DiagnosticReport list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(
+    DIAGNOSTICREPORT_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 "Patient/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: DIAGNOSTICREPORT_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(
+      BASE_PATH.DIAGNOSTICREPORT,
+      result.entries
+    );
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(
+      res,
+      err,
+      "GET /DiagnosticReport search error:"
+    );
+  }
+}
 
 // src/data/operations/data/diagnosticreport/diagnosticreport-update-operation.ts
 async function updateDiagnosticReportOperation(params) {
@@ -13531,15 +14637,122 @@ async function listDocumentManifestsOperation(params) {
 }
 
 // src/data/rest-api/routes/data/documentmanifest/documentmanifest-list-route.ts
-async function listDocumentManifestsRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.DOCUMENTMANIFEST,
-    listOperation: listDocumentManifestsOperation,
-    errorLogContext: "GET /DocumentManifest list error:"
+var DOCUMENTMANIFEST_RESOURCE_TYPE = "DocumentManifest";
+function stripModifier9(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter9(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch4009(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys9(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter9(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier9(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics9(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(
+    DOCUMENTMANIFEST_RESOURCE_TYPE
+  ).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for DocumentManifest: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference9(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(DOCUMENTMANIFEST_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 listDocumentManifestsRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys9(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.DOCUMENTMANIFEST,
+      listOperation: listDocumentManifestsOperation,
+      errorLogContext: "GET /DocumentManifest list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(
+    DOCUMENTMANIFEST_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 sendInvalidSearch4009(
+      res,
+      buildUnknownParamDiagnostics9([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference9(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch4009(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: DOCUMENTMANIFEST_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(
+      BASE_PATH.DOCUMENTMANIFEST,
+      result.entries
+    );
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(
+      res,
+      err,
+      "GET /DocumentManifest search error:"
+    );
+  }
+}
 
 // src/data/operations/data/documentmanifest/documentmanifest-update-operation.ts
 async function updateDocumentManifestOperation(params) {
@@ -13734,15 +14947,122 @@ async function listDocumentReferencesOperation(params) {
 }
 
 // src/data/rest-api/routes/data/documentreference/documentreference-list-route.ts
-async function listDocumentReferencesRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.DOCUMENTREFERENCE,
-    listOperation: listDocumentReferencesOperation,
-    errorLogContext: "GET /DocumentReference list error:"
+var DOCUMENTREFERENCE_RESOURCE_TYPE = "DocumentReference";
+function stripModifier10(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter10(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch40010(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys10(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter10(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier10(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics10(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(
+    DOCUMENTREFERENCE_RESOURCE_TYPE
+  ).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for DocumentReference: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference10(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(DOCUMENTREFERENCE_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 listDocumentReferencesRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys10(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.DOCUMENTREFERENCE,
+      listOperation: listDocumentReferencesOperation,
+      errorLogContext: "GET /DocumentReference list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(
+    DOCUMENTREFERENCE_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 sendInvalidSearch40010(
+      res,
+      buildUnknownParamDiagnostics10([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference10(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch40010(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: DOCUMENTREFERENCE_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(
+      BASE_PATH.DOCUMENTREFERENCE,
+      result.entries
+    );
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(
+      res,
+      err,
+      "GET /DocumentReference search error:"
+    );
+  }
+}
 
 // src/data/operations/data/documentreference/documentreference-update-operation.ts
 async function updateDocumentReferenceOperation(params) {
@@ -14119,30 +15439,30 @@ async function listEncountersOperation(params) {
 
 // src/data/rest-api/routes/data/encounter/encounter-list-route.ts
 var ENCOUNTER_RESOURCE_TYPE = "Encounter";
-function stripModifier4(key) {
+function stripModifier11(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter4(key) {
+function isResultParameter11(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch4004(res, diagnostics) {
+function sendInvalidSearch40011(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys4(query) {
+function extractSearchParamKeys11(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter4(rawKey)) {
+    if (isResultParameter11(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier4(rawKey) });
+    out.push({ rawKey, code: stripModifier11(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics4(unknownCodes) {
+function buildUnknownParamDiagnostics11(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(ENCOUNTER_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -14151,7 +15471,7 @@ function buildUnknownParamDiagnostics4(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference4(query, searchParamKeys) {
+function findMalformedReference11(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(ENCOUNTER_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -14174,7 +15494,7 @@ function findMalformedReference4(query, searchParamKeys) {
   return void 0;
 }
 async function listEncountersRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys4(
+  const searchParamKeys = extractSearchParamKeys11(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -14190,17 +15510,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 sendInvalidSearch4004(
+    return sendInvalidSearch40011(
       res,
-      buildUnknownParamDiagnostics4([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics11([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference4(
+  const malformedRef = findMalformedReference11(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch4004(
+    return sendInvalidSearch40011(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -14416,15 +15736,111 @@ async function listEndpointsOperation(params) {
 }
 
 // src/data/rest-api/routes/data/endpoint/endpoint-list-route.ts
-async function listEndpointsRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.ENDPOINT,
-    listOperation: listEndpointsOperation,
-    errorLogContext: "GET /Endpoint list error:"
+var ENDPOINT_RESOURCE_TYPE = "Endpoint";
+function stripModifier12(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter12(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch40012(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys12(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter12(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier12(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics12(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(ENDPOINT_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for Endpoint: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference12(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(ENDPOINT_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 listEndpointsRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys12(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.ENDPOINT,
+      listOperation: listEndpointsOperation,
+      errorLogContext: "GET /Endpoint list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(ENDPOINT_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 sendInvalidSearch40012(
+      res,
+      buildUnknownParamDiagnostics12([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference12(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch40012(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: ENDPOINT_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(BASE_PATH.ENDPOINT, result.entries);
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /Endpoint search error:");
+  }
+}
 
 // src/data/operations/data/endpoint/endpoint-update-operation.ts
 async function updateEndpointOperation(params) {
@@ -16037,15 +17453,122 @@ async function listExplanationOfBenefitsOperation(params) {
 }
 
 // src/data/rest-api/routes/data/explanationofbenefit/explanationofbenefit-list-route.ts
-async function listExplanationOfBenefitsRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.EXPLANATIONOFBENEFIT,
-    listOperation: listExplanationOfBenefitsOperation,
-    errorLogContext: "GET /ExplanationOfBenefit list error:"
+var EXPLANATIONOFBENEFIT_RESOURCE_TYPE = "ExplanationOfBenefit";
+function stripModifier13(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter13(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch40013(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys13(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter13(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier13(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics13(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(
+    EXPLANATIONOFBENEFIT_RESOURCE_TYPE
+  ).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for ExplanationOfBenefit: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference13(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(EXPLANATIONOFBENEFIT_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 listExplanationOfBenefitsRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys13(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.EXPLANATIONOFBENEFIT,
+      listOperation: listExplanationOfBenefitsOperation,
+      errorLogContext: "GET /ExplanationOfBenefit list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(
+    EXPLANATIONOFBENEFIT_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 sendInvalidSearch40013(
+      res,
+      buildUnknownParamDiagnostics13([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference13(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch40013(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: EXPLANATIONOFBENEFIT_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(
+      BASE_PATH.EXPLANATIONOFBENEFIT,
+      result.entries
+    );
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(
+      res,
+      err,
+      "GET /ExplanationOfBenefit search error:"
+    );
+  }
+}
 
 // src/data/operations/data/explanationofbenefit/explanationofbenefit-update-operation.ts
 async function updateExplanationOfBenefitOperation(params) {
@@ -16245,30 +17768,30 @@ async function listFamilyMemberHistorysOperation(params) {
 
 // src/data/rest-api/routes/data/familymemberhistory/familymemberhistory-list-route.ts
 var FAMILYMEMBERHISTORY_RESOURCE_TYPE = "FamilyMemberHistory";
-function stripModifier5(key) {
+function stripModifier14(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter5(key) {
+function isResultParameter14(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch4005(res, diagnostics) {
+function sendInvalidSearch40014(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys5(query) {
+function extractSearchParamKeys14(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter5(rawKey)) {
+    if (isResultParameter14(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier5(rawKey) });
+    out.push({ rawKey, code: stripModifier14(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics5(unknownCodes) {
+function buildUnknownParamDiagnostics14(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(
     FAMILYMEMBERHISTORY_RESOURCE_TYPE
   ).map((p) => p.code).sort().join(", ");
@@ -16279,7 +17802,7 @@ function buildUnknownParamDiagnostics5(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference5(query, searchParamKeys) {
+function findMalformedReference14(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(FAMILYMEMBERHISTORY_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -16302,7 +17825,7 @@ function findMalformedReference5(query, searchParamKeys) {
   return void 0;
 }
 async function listFamilyMemberHistorysRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys5(
+  const searchParamKeys = extractSearchParamKeys14(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -16320,17 +17843,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 sendInvalidSearch4005(
+    return sendInvalidSearch40014(
       res,
-      buildUnknownParamDiagnostics5([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics14([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference5(
+  const malformedRef = findMalformedReference14(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch4005(
+    return sendInvalidSearch40014(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
     );
@@ -17751,15 +19274,111 @@ async function listImagingStudysOperation(params) {
 }
 
 // src/data/rest-api/routes/data/imagingstudy/imagingstudy-list-route.ts
-async function listImagingStudysRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.IMAGINGSTUDY,
-    listOperation: listImagingStudysOperation,
-    errorLogContext: "GET /ImagingStudy list error:"
+var IMAGINGSTUDY_RESOURCE_TYPE = "ImagingStudy";
+function stripModifier15(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter15(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch40015(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys15(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter15(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier15(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics15(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(IMAGINGSTUDY_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for ImagingStudy: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference15(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(IMAGINGSTUDY_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 listImagingStudysRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys15(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.IMAGINGSTUDY,
+      listOperation: listImagingStudysOperation,
+      errorLogContext: "GET /ImagingStudy list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(IMAGINGSTUDY_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 sendInvalidSearch40015(
+      res,
+      buildUnknownParamDiagnostics15([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference15(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch40015(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: IMAGINGSTUDY_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(BASE_PATH.IMAGINGSTUDY, result.entries);
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /ImagingStudy search error:");
+  }
+}
 
 // src/data/operations/data/imagingstudy/imagingstudy-update-operation.ts
 async function updateImagingStudyOperation(params) {
@@ -17952,30 +19571,30 @@ async function listImmunizationsOperation(params) {
 
 // src/data/rest-api/routes/data/immunization/immunization-list-route.ts
 var IMMUNIZATION_RESOURCE_TYPE = "Immunization";
-function stripModifier6(key) {
+function stripModifier16(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter6(key) {
+function isResultParameter16(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch4006(res, diagnostics) {
+function sendInvalidSearch40016(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys6(query) {
+function extractSearchParamKeys16(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter6(rawKey)) {
+    if (isResultParameter16(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier6(rawKey) });
+    out.push({ rawKey, code: stripModifier16(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics6(unknownCodes) {
+function buildUnknownParamDiagnostics16(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(IMMUNIZATION_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -17984,7 +19603,7 @@ function buildUnknownParamDiagnostics6(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference6(query, searchParamKeys) {
+function findMalformedReference16(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(IMMUNIZATION_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -18007,7 +19626,7 @@ function findMalformedReference6(query, searchParamKeys) {
   return void 0;
 }
 async function listImmunizationsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys6(
+  const searchParamKeys = extractSearchParamKeys16(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -18023,17 +19642,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 sendInvalidSearch4006(
+    return sendInvalidSearch40016(
       res,
-      buildUnknownParamDiagnostics6([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics16([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference6(
+  const malformedRef = findMalformedReference16(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch4006(
+    return sendInvalidSearch40016(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -19089,15 +20708,111 @@ async function listInvoicesOperation(params) {
 }
 
 // src/data/rest-api/routes/data/invoice/invoice-list-route.ts
-async function listInvoicesRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.INVOICE,
-    listOperation: listInvoicesOperation,
-    errorLogContext: "GET /Invoice list error:"
+var INVOICE_RESOURCE_TYPE = "Invoice";
+function stripModifier17(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter17(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch40017(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys17(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter17(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier17(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics17(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(INVOICE_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for Invoice: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference17(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(INVOICE_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 listInvoicesRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys17(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.INVOICE,
+      listOperation: listInvoicesOperation,
+      errorLogContext: "GET /Invoice list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(INVOICE_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 sendInvalidSearch40017(
+      res,
+      buildUnknownParamDiagnostics17([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference17(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch40017(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: INVOICE_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(BASE_PATH.INVOICE, result.entries);
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /Invoice search error:");
+  }
+}
 
 // src/data/operations/data/invoice/invoice-update-operation.ts
 async function updateInvoiceOperation(params) {
@@ -19889,15 +21604,111 @@ async function listLocationsOperation(params) {
 }
 
 // src/data/rest-api/routes/data/location/location-list-route.ts
-async function listLocationsRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.LOCATION,
-    listOperation: listLocationsOperation,
-    errorLogContext: "GET /Location list error:"
+var LOCATION_RESOURCE_TYPE = "Location";
+function stripModifier18(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter18(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch40018(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys18(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter18(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier18(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics18(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(LOCATION_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for Location: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference18(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(LOCATION_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 listLocationsRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys18(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.LOCATION,
+      listOperation: listLocationsOperation,
+      errorLogContext: "GET /Location list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(LOCATION_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 sendInvalidSearch40018(
+      res,
+      buildUnknownParamDiagnostics18([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference18(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch40018(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: LOCATION_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(BASE_PATH.LOCATION, result.entries);
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /Location search error:");
+  }
+}
 
 // src/data/operations/data/location/location-update-operation.ts
 async function updateLocationOperation(params) {
@@ -21526,30 +23337,30 @@ async function listMedicationRequestsOperation(params) {
 
 // src/data/rest-api/routes/data/medicationrequest/medicationrequest-list-route.ts
 var MEDICATIONREQUEST_RESOURCE_TYPE = "MedicationRequest";
-function stripModifier7(key) {
+function stripModifier19(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter7(key) {
+function isResultParameter19(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch4007(res, diagnostics) {
+function sendInvalidSearch40019(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys7(query) {
+function extractSearchParamKeys19(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter7(rawKey)) {
+    if (isResultParameter19(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier7(rawKey) });
+    out.push({ rawKey, code: stripModifier19(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics7(unknownCodes) {
+function buildUnknownParamDiagnostics19(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(
     MEDICATIONREQUEST_RESOURCE_TYPE
   ).map((p) => p.code).sort().join(", ");
@@ -21560,7 +23371,7 @@ function buildUnknownParamDiagnostics7(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference7(query, searchParamKeys) {
+function findMalformedReference19(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(MEDICATIONREQUEST_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -21583,7 +23394,7 @@ function findMalformedReference7(query, searchParamKeys) {
   return void 0;
 }
 async function listMedicationRequestsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys7(
+  const searchParamKeys = extractSearchParamKeys19(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -21601,17 +23412,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 sendInvalidSearch4007(
+    return sendInvalidSearch40019(
       res,
-      buildUnknownParamDiagnostics7([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics19([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference7(
+  const malformedRef = findMalformedReference19(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch4007(
+    return sendInvalidSearch40019(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -21837,30 +23648,30 @@ async function listMedicationStatementsOperation(params) {
 
 // src/data/rest-api/routes/data/medicationstatement/medicationstatement-list-route.ts
 var MEDICATIONSTATEMENT_RESOURCE_TYPE = "MedicationStatement";
-function stripModifier8(key) {
+function stripModifier20(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter8(key) {
+function isResultParameter20(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch4008(res, diagnostics) {
+function sendInvalidSearch40020(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys8(query) {
+function extractSearchParamKeys20(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter8(rawKey)) {
+    if (isResultParameter20(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier8(rawKey) });
+    out.push({ rawKey, code: stripModifier20(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics8(unknownCodes) {
+function buildUnknownParamDiagnostics20(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(
     MEDICATIONSTATEMENT_RESOURCE_TYPE
   ).map((p) => p.code).sort().join(", ");
@@ -21871,7 +23682,7 @@ function buildUnknownParamDiagnostics8(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference8(query, searchParamKeys) {
+function findMalformedReference20(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(MEDICATIONSTATEMENT_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -21894,7 +23705,7 @@ function findMalformedReference8(query, searchParamKeys) {
   return void 0;
 }
 async function listMedicationStatementsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys8(
+  const searchParamKeys = extractSearchParamKeys20(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -21912,17 +23723,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 sendInvalidSearch4008(
+    return sendInvalidSearch40020(
       res,
-      buildUnknownParamDiagnostics8([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics20([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference8(
+  const malformedRef = findMalformedReference20(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch4008(
+    return sendInvalidSearch40020(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -25304,30 +27115,30 @@ async function listObservationsOperation(params) {
 
 // src/data/rest-api/routes/data/observation/observation-list-route.ts
 var OBSERVATION_RESOURCE_TYPE = "Observation";
-function stripModifier9(key) {
+function stripModifier21(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter9(key) {
+function isResultParameter21(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch4009(res, diagnostics) {
+function sendInvalidSearch40021(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys9(query) {
+function extractSearchParamKeys21(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter9(rawKey)) {
+    if (isResultParameter21(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier9(rawKey) });
+    out.push({ rawKey, code: stripModifier21(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics9(unknownCodes) {
+function buildUnknownParamDiagnostics21(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(OBSERVATION_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -25336,7 +27147,7 @@ function buildUnknownParamDiagnostics9(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference9(query, searchParamKeys) {
+function findMalformedReference21(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(OBSERVATION_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -25359,7 +27170,7 @@ function findMalformedReference9(query, searchParamKeys) {
   return void 0;
 }
 async function listObservationsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys9(
+  const searchParamKeys = extractSearchParamKeys21(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -25375,17 +27186,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 sendInvalidSearch4009(
+    return sendInvalidSearch40021(
       res,
-      buildUnknownParamDiagnostics9([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics21([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference9(
+  const malformedRef = findMalformedReference21(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch4009(
+    return sendInvalidSearch40021(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -25995,15 +27806,111 @@ async function listOrganizationsOperation(params) {
 }
 
 // src/data/rest-api/routes/data/organization/organization-list-route.ts
-async function listOrganizationsRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.ORGANIZATION,
-    listOperation: listOrganizationsOperation,
-    errorLogContext: "GET /Organization list error:"
+var ORGANIZATION_RESOURCE_TYPE = "Organization";
+function stripModifier22(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter22(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch40022(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys22(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter22(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier22(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics22(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(ORGANIZATION_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for Organization: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference22(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(ORGANIZATION_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 listOrganizationsRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys22(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.ORGANIZATION,
+      listOperation: listOrganizationsOperation,
+      errorLogContext: "GET /Organization list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(ORGANIZATION_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 sendInvalidSearch40022(
+      res,
+      buildUnknownParamDiagnostics22([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference22(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch40022(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: ORGANIZATION_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(BASE_PATH.ORGANIZATION, result.entries);
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /Organization search error:");
+  }
+}
 
 // src/data/operations/data/organization/organization-update-operation.ts
 async function updateOrganizationOperation(params) {
@@ -26380,30 +28287,30 @@ async function listPatientsOperation(params) {
 
 // src/data/rest-api/routes/data/patient/patient-list-route.ts
 var PATIENT_RESOURCE_TYPE = "Patient";
-function stripModifier10(key) {
+function stripModifier23(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter10(key) {
+function isResultParameter23(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40010(res, diagnostics) {
+function sendInvalidSearch40023(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys10(query) {
+function extractSearchParamKeys23(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter10(rawKey)) {
+    if (isResultParameter23(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier10(rawKey) });
+    out.push({ rawKey, code: stripModifier23(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics10(unknownCodes) {
+function buildUnknownParamDiagnostics23(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(PATIENT_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -26412,7 +28319,7 @@ function buildUnknownParamDiagnostics10(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference10(query, searchParamKeys) {
+function findMalformedReference23(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(PATIENT_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -26435,7 +28342,7 @@ function findMalformedReference10(query, searchParamKeys) {
   return void 0;
 }
 async function listPatientsRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys10(
+  const searchParamKeys = extractSearchParamKeys23(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -26451,17 +28358,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 sendInvalidSearch40010(
+    return sendInvalidSearch40023(
       res,
-      buildUnknownParamDiagnostics10([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics23([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference10(
+  const malformedRef = findMalformedReference23(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40010(
+    return sendInvalidSearch40023(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -26672,15 +28579,118 @@ async function listPaymentNoticesOperation(params) {
 }
 
 // src/data/rest-api/routes/data/paymentnotice/paymentnotice-list-route.ts
-async function listPaymentNoticesRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.PAYMENTNOTICE,
-    listOperation: listPaymentNoticesOperation,
-    errorLogContext: "GET /PaymentNotice list error:"
+var PAYMENTNOTICE_RESOURCE_TYPE = "PaymentNotice";
+function stripModifier24(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter24(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch40024(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys24(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter24(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier24(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics24(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(PAYMENTNOTICE_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for PaymentNotice: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference24(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(PAYMENTNOTICE_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 listPaymentNoticesRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys24(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.PAYMENTNOTICE,
+      listOperation: listPaymentNoticesOperation,
+      errorLogContext: "GET /PaymentNotice list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(PAYMENTNOTICE_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 sendInvalidSearch40024(
+      res,
+      buildUnknownParamDiagnostics24([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference24(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch40024(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: PAYMENTNOTICE_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(
+      BASE_PATH.PAYMENTNOTICE,
+      result.entries
+    );
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(
+      res,
+      err,
+      "GET /PaymentNotice search error:"
+    );
+  }
+}
 
 // src/data/operations/data/paymentnotice/paymentnotice-update-operation.ts
 async function updatePaymentNoticeOperation(params) {
@@ -27456,15 +29466,111 @@ async function listPractitionersOperation(params) {
 }
 
 // src/data/rest-api/routes/data/practitioner/practitioner-list-route.ts
-async function listPractitionersRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.PRACTITIONER,
-    listOperation: listPractitionersOperation,
-    errorLogContext: "GET /Practitioner list error:"
+var PRACTITIONER_RESOURCE_TYPE = "Practitioner";
+function stripModifier25(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter25(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch40025(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys25(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter25(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier25(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics25(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(PRACTITIONER_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for Practitioner: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference25(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(PRACTITIONER_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 listPractitionersRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys25(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.PRACTITIONER,
+      listOperation: listPractitionersOperation,
+      errorLogContext: "GET /Practitioner list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(PRACTITIONER_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 sendInvalidSearch40025(
+      res,
+      buildUnknownParamDiagnostics25([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference25(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch40025(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: PRACTITIONER_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(BASE_PATH.PRACTITIONER, result.entries);
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /Practitioner search error:");
+  }
+}
 
 // src/data/operations/data/practitioner/practitioner-update-operation.ts
 async function updatePractitionerOperation(params) {
@@ -27600,15 +29706,119 @@ async function getPractitionerRoleByIdRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/practitionerrole/practitionerrole-list-route.ts
-async function listPractitionerRolesRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.PRACTITIONERROLE,
-    listOperation: listPractitionerRolesOperation,
-    errorLogContext: "GET /PractitionerRole list error:"
+var PRACTITIONERROLE_RESOURCE_TYPE = "PractitionerRole";
+function stripModifier26(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter26(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch40026(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys26(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter26(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier26(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics26(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(
+    PRACTITIONERROLE_RESOURCE_TYPE
+  ).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for PractitionerRole: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference26(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(PRACTITIONERROLE_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 listPractitionerRolesRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys26(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.PRACTITIONERROLE,
+      listOperation: listPractitionerRolesOperation,
+      errorLogContext: "GET /PractitionerRole list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(
+    PRACTITIONERROLE_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 sendInvalidSearch40026(
+      res,
+      buildUnknownParamDiagnostics26([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference26(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch40026(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: PRACTITIONERROLE_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(
+      BASE_PATH.PRACTITIONERROLE,
+      result.entries
+    );
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(
+      res,
+      err,
+      "GET /PractitionerRole search error:"
+    );
+  }
+}
 
 // src/data/operations/data/practitionerrole/practitionerrole-update-operation.ts
 async function updatePractitionerRoleOperation(params) {
@@ -27801,30 +30011,30 @@ async function listProceduresOperation(params) {
 
 // src/data/rest-api/routes/data/procedure/procedure-list-route.ts
 var PROCEDURE_RESOURCE_TYPE = "Procedure";
-function stripModifier11(key) {
+function stripModifier27(key) {
   const idx = key.indexOf(":");
   return idx === -1 ? key : key.slice(0, idx);
 }
-function isResultParameter11(key) {
+function isResultParameter27(key) {
   return key.startsWith("_");
 }
-function sendInvalidSearch40011(res, diagnostics) {
+function sendInvalidSearch40027(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-function extractSearchParamKeys11(query) {
+function extractSearchParamKeys27(query) {
   const out = [];
   for (const rawKey of Object.keys(query)) {
-    if (isResultParameter11(rawKey)) {
+    if (isResultParameter27(rawKey)) {
       continue;
     }
-    out.push({ rawKey, code: stripModifier11(rawKey) });
+    out.push({ rawKey, code: stripModifier27(rawKey) });
   }
   return out;
 }
-function buildUnknownParamDiagnostics11(unknownCodes) {
+function buildUnknownParamDiagnostics27(unknownCodes) {
   const validCodes = getRegisteredSearchParameters(PROCEDURE_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
   const codes = unknownCodes.join(", ");
   const isPlural = unknownCodes.length !== 1;
@@ -27833,7 +30043,7 @@ function buildUnknownParamDiagnostics11(unknownCodes) {
     `Valid codes: ${validCodes}.`
   ].join(" ");
 }
-function findMalformedReference11(query, searchParamKeys) {
+function findMalformedReference27(query, searchParamKeys) {
   const referenceCodes = new Set(
     getRegisteredSearchParameters(PROCEDURE_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
@@ -27856,7 +30066,7 @@ function findMalformedReference11(query, searchParamKeys) {
   return void 0;
 }
 async function listProceduresRoute(req, res) {
-  const searchParamKeys = extractSearchParamKeys11(
+  const searchParamKeys = extractSearchParamKeys27(
     req.query
   );
   if (searchParamKeys.length === 0) {
@@ -27872,17 +30082,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 sendInvalidSearch40011(
+    return sendInvalidSearch40027(
       res,
-      buildUnknownParamDiagnostics11([...new Set(unknownCodes)])
+      buildUnknownParamDiagnostics27([...new Set(unknownCodes)])
     );
   }
-  const malformedRef = findMalformedReference11(
+  const malformedRef = findMalformedReference27(
     req.query,
     searchParamKeys
   );
   if (malformedRef !== void 0) {
-    return sendInvalidSearch40011(
+    return sendInvalidSearch40027(
       res,
       `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
     );
@@ -28712,15 +30922,115 @@ async function listRelatedPersonsOperation(params) {
 }
 
 // src/data/rest-api/routes/data/relatedperson/relatedperson-list-route.ts
-async function listRelatedPersonsRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.RELATEDPERSON,
-    listOperation: listRelatedPersonsOperation,
-    errorLogContext: "GET /RelatedPerson list error:"
+var RELATEDPERSON_RESOURCE_TYPE = "RelatedPerson";
+function stripModifier28(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter28(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch40028(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys28(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter28(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier28(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics28(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(RELATEDPERSON_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for RelatedPerson: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference28(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(RELATEDPERSON_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 listRelatedPersonsRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys28(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.RELATEDPERSON,
+      listOperation: listRelatedPersonsOperation,
+      errorLogContext: "GET /RelatedPerson list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(RELATEDPERSON_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 sendInvalidSearch40028(
+      res,
+      buildUnknownParamDiagnostics28([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference28(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch40028(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: RELATEDPERSON_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(
+      BASE_PATH.RELATEDPERSON,
+      result.entries
+    );
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(
+      res,
+      err,
+      "GET /RelatedPerson search error:"
+    );
+  }
+}
 
 // src/data/operations/data/relatedperson/relatedperson-update-operation.ts
 async function updateRelatedPersonOperation(params) {
@@ -30356,97 +32666,108 @@ async function listSchedulesOperation(params) {
   );
 }
 
-// src/data/operations/data/schedule/schedule-search-by-actor-operation.ts
-var DEFAULT_LIMIT2 = 100;
-function buildSearchSchedulesByActorSql() {
-  return [
-    "SELECT resource_id AS id, resource",
-    "FROM resources",
-    "WHERE tenant_id = :tenantId",
-    "  AND workspace_id = :workspaceId",
-    "  AND resource_type = 'Schedule'",
-    "  AND deleted_at IS NULL",
-    `  AND ${REFERENCE_CONTAINMENT_SQL_FRAGMENT}`,
-    "ORDER BY last_updated DESC",
-    "LIMIT :limit;"
-  ].join("\n");
-}
-async function searchSchedulesByActorOperation(params) {
-  const { context, actorReference } = params;
-  const { tenantId, workspaceId } = context;
-  const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT2;
-  const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
-    shape: { kind: "array-of-references", field: "actor" },
-    reference: actorReference,
-    tenantId,
-    workspaceId
-  });
-  const queryParams = [
-    { name: "tenantId", value: tenantId },
-    { name: "workspaceId", value: workspaceId },
-    { name: "containmentRelative", value: containmentRelative },
-    { name: "containmentUrn", value: containmentUrn },
-    { name: "limit", value: limit }
-  ];
-  const rows = await runner.query(
-    buildSearchSchedulesByActorSql(),
-    queryParams
-  );
-  const entries = rows.map((row) => ({
-    id: row.id,
-    resource: { ...row.resource, id: row.id }
-  }));
-  return { entries, total: entries.length };
-}
-
 // src/data/rest-api/routes/data/schedule/schedule-list-route.ts
-function singleStringQueryParam(req, name) {
-  const v = req.query[name];
-  if (typeof v !== "string") {
-    return void 0;
-  }
-  const trimmed = v.trim();
-  return trimmed === "" ? void 0 : trimmed;
+var SCHEDULE_RESOURCE_TYPE = "Schedule";
+function stripModifier29(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
 }
-function sendInvalidSearch40012(res, diagnostics) {
+function isResultParameter29(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch40029(res, diagnostics) {
   return res.status(400).json({
     resourceType: "OperationOutcome",
     issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
-async function listSchedulesRoute(req, res) {
-  const actorRef = singleStringQueryParam(req, "actor");
-  if (actorRef !== void 0) {
-    if (parseTypedReference(actorRef) === void 0) {
-      return sendInvalidSearch40012(
-        res,
-        `?actor must be a typed reference like "Practitioner/<id>"; got "${actorRef}".`
-      );
+function extractSearchParamKeys29(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter29(rawKey)) {
+      continue;
     }
-    const ctx = req.openhiContext;
-    try {
-      const result = await searchSchedulesByActorOperation({
-        context: ctx,
-        actorReference: actorRef
-      });
-      const bundle = buildSearchsetBundle(BASE_PATH.SCHEDULE, result.entries);
-      return res.json(bundle);
-    } catch (err) {
-      return sendOperationOutcome500(
-        res,
-        err,
-        "GET /Schedule?actor= search error:"
-      );
+    out.push({ rawKey, code: stripModifier29(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics29(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(SCHEDULE_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for Schedule: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference29(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(SCHEDULE_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 handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.SCHEDULE,
-    listOperation: listSchedulesOperation,
-    errorLogContext: "GET /Schedule list error:"
-  });
+  return void 0;
+}
+async function listSchedulesRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys29(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.SCHEDULE,
+      listOperation: listSchedulesOperation,
+      errorLogContext: "GET /Schedule list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(SCHEDULE_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 sendInvalidSearch40029(
+      res,
+      buildUnknownParamDiagnostics29([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference29(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch40029(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: SCHEDULE_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(BASE_PATH.SCHEDULE, result.entries);
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /Schedule search error:");
+  }
 }
 
 // src/data/operations/data/schedule/schedule-update-operation.ts
@@ -31039,15 +33360,108 @@ async function listSlotsOperation(params) {
 }
 
 // src/data/rest-api/routes/data/slot/slot-list-route.ts
-async function listSlotsRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.SLOT,
-    listOperation: listSlotsOperation,
-    errorLogContext: "GET /Slot list error:"
+var SLOT_RESOURCE_TYPE = "Slot";
+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(SLOT_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for Slot: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference30(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(SLOT_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 listSlotsRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys30(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.SLOT,
+      listOperation: listSlotsOperation,
+      errorLogContext: "GET /Slot list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(SLOT_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 "Schedule/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: SLOT_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(BASE_PATH.SLOT, result.entries);
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /Slot search error:");
+  }
+}
 
 // src/data/operations/data/slot/slot-update-operation.ts
 async function updateSlotOperation(params) {
@@ -31239,15 +33653,111 @@ async function listSpecimensOperation(params) {
 }
 
 // src/data/rest-api/routes/data/specimen/specimen-list-route.ts
-async function listSpecimensRoute(req, res) {
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.SPECIMEN,
-    listOperation: listSpecimensOperation,
-    errorLogContext: "GET /Specimen list error:"
+var SPECIMEN_RESOURCE_TYPE = "Specimen";
+function stripModifier31(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
+}
+function isResultParameter31(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch40031(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
 }
+function extractSearchParamKeys31(query) {
+  const out = [];
+  for (const rawKey of Object.keys(query)) {
+    if (isResultParameter31(rawKey)) {
+      continue;
+    }
+    out.push({ rawKey, code: stripModifier31(rawKey) });
+  }
+  return out;
+}
+function buildUnknownParamDiagnostics31(unknownCodes) {
+  const validCodes = getRegisteredSearchParameters(SPECIMEN_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
+  return [
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for Specimen: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
+}
+function findMalformedReference31(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(SPECIMEN_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 listSpecimensRoute(req, res) {
+  const searchParamKeys = extractSearchParamKeys31(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
+      res,
+      basePath: BASE_PATH.SPECIMEN,
+      listOperation: listSpecimensOperation,
+      errorLogContext: "GET /Specimen list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(SPECIMEN_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 sendInvalidSearch40031(
+      res,
+      buildUnknownParamDiagnostics31([...new Set(unknownCodes)])
+    );
+  }
+  const malformedRef = findMalformedReference31(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch40031(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Patient/<id>"; got "${malformedRef.value}".`
+    );
+  }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: SPECIMEN_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(BASE_PATH.SPECIMEN, result.entries);
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /Specimen search error:");
+  }
+}
 
 // src/data/operations/data/specimen/specimen-update-operation.ts
 async function updateSpecimenOperation(params) {
@@ -34120,171 +36630,108 @@ async function listTasksOperation(params) {
   );
 }
 
-// src/data/operations/data/task/task-search-by-owner-operation.ts
-var DEFAULT_LIMIT3 = 100;
-function buildSearchTasksByOwnerSql() {
-  return [
-    "SELECT resource_id AS id, resource",
-    "FROM resources",
-    "WHERE tenant_id = :tenantId",
-    "  AND workspace_id = :workspaceId",
-    "  AND resource_type = 'Task'",
-    "  AND deleted_at IS NULL",
-    `  AND ${REFERENCE_CONTAINMENT_SQL_FRAGMENT}`,
-    "ORDER BY last_updated DESC",
-    "LIMIT :limit;"
-  ].join("\n");
+// src/data/rest-api/routes/data/task/task-list-route.ts
+var TASK_RESOURCE_TYPE = "Task";
+function stripModifier32(key) {
+  const idx = key.indexOf(":");
+  return idx === -1 ? key : key.slice(0, idx);
 }
-async function searchTasksByOwnerOperation(params) {
-  const { context, ownerReference } = params;
-  const { tenantId, workspaceId } = context;
-  const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT3;
-  const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
-    shape: { kind: "scalar", field: "owner" },
-    reference: ownerReference,
-    tenantId,
-    workspaceId
+function isResultParameter32(key) {
+  return key.startsWith("_");
+}
+function sendInvalidSearch40032(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
   });
-  const queryParams = [
-    { name: "tenantId", value: tenantId },
-    { name: "workspaceId", value: workspaceId },
-    { name: "containmentRelative", value: containmentRelative },
-    { name: "containmentUrn", value: containmentUrn },
-    { name: "limit", value: limit }
-  ];
-  const rows = await runner.query(
-    buildSearchTasksByOwnerSql(),
-    queryParams
-  );
-  const entries = rows.map((row) => ({
-    id: row.id,
-    resource: { ...row.resource, id: row.id }
-  }));
-  return { entries, total: entries.length };
 }
-
-// src/data/operations/data/task/task-search-by-requester-operation.ts
-var DEFAULT_LIMIT4 = 100;
-function buildSearchTasksByRequesterSql() {
+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(TASK_RESOURCE_TYPE).map((p) => p.code).sort().join(", ");
+  const codes = unknownCodes.join(", ");
+  const isPlural = unknownCodes.length !== 1;
   return [
-    "SELECT resource_id AS id, resource",
-    "FROM resources",
-    "WHERE tenant_id = :tenantId",
-    "  AND workspace_id = :workspaceId",
-    "  AND resource_type = 'Task'",
-    "  AND deleted_at IS NULL",
-    `  AND ${REFERENCE_CONTAINMENT_SQL_FRAGMENT}`,
-    "ORDER BY last_updated DESC",
-    "LIMIT :limit;"
-  ].join("\n");
+    `Unknown search ${isPlural ? "parameters" : "parameter"} for Task: ${codes}.`,
+    `Valid codes: ${validCodes}.`
+  ].join(" ");
 }
-async function searchTasksByRequesterOperation(params) {
-  const { context, requesterReference } = params;
-  const { tenantId, workspaceId } = context;
-  const runner = params.runner ?? getDefaultPostgresQueryRunner();
-  const limit = params.limit ?? DEFAULT_LIMIT4;
-  const { containmentRelative, containmentUrn } = buildReferenceContainmentPayload({
-    shape: { kind: "scalar", field: "requester" },
-    reference: requesterReference,
-    tenantId,
-    workspaceId
-  });
-  const queryParams = [
-    { name: "tenantId", value: tenantId },
-    { name: "workspaceId", value: workspaceId },
-    { name: "containmentRelative", value: containmentRelative },
-    { name: "containmentUrn", value: containmentUrn },
-    { name: "limit", value: limit }
-  ];
-  const rows = await runner.query(
-    buildSearchTasksByRequesterSql(),
-    queryParams
+function findMalformedReference32(query, searchParamKeys) {
+  const referenceCodes = new Set(
+    getRegisteredSearchParameters(TASK_RESOURCE_TYPE).filter((p) => p.type === "reference").map((p) => p.code)
   );
-  const entries = rows.map((row) => ({
-    id: row.id,
-    resource: { ...row.resource, id: row.id }
-  }));
-  return { entries, total: entries.length };
-}
-
-// src/data/rest-api/routes/data/task/task-list-route.ts
-function singleStringQueryParam2(req, name) {
-  const v = req.query[name];
-  if (typeof v !== "string") {
-    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 };
+      }
+    }
   }
-  const trimmed = v.trim();
-  return trimmed === "" ? void 0 : trimmed;
-}
-function sendInvalidSearch40013(res, diagnostics) {
-  return res.status(400).json({
-    resourceType: "OperationOutcome",
-    issue: [{ severity: "error", code: "invalid", diagnostics }]
-  });
+  return void 0;
 }
 async function listTasksRoute(req, res) {
-  const ownerRef = singleStringQueryParam2(req, "owner");
-  const requesterRef = singleStringQueryParam2(req, "requester");
-  if (ownerRef !== void 0 && requesterRef !== void 0) {
-    return sendInvalidSearch40013(
+  const searchParamKeys = extractSearchParamKeys32(
+    req.query
+  );
+  if (searchParamKeys.length === 0) {
+    return handleListRoute({
+      req,
       res,
-      "?owner= and ?requester= cannot be combined on the same request."
+      basePath: BASE_PATH.TASK,
+      listOperation: listTasksOperation,
+      errorLogContext: "GET /Task list error:"
+    });
+  }
+  const registered = getRegisteredSearchParameters(TASK_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)])
     );
   }
-  if (ownerRef !== void 0) {
-    if (parseTypedReference(ownerRef) === void 0) {
-      return sendInvalidSearch40013(
-        res,
-        `?owner must be a typed reference like "Practitioner/<id>"; got "${ownerRef}".`
-      );
-    }
-    const ctx = req.openhiContext;
-    try {
-      const result = await searchTasksByOwnerOperation({
-        context: ctx,
-        ownerReference: ownerRef
-      });
-      const bundle = buildSearchsetBundle(BASE_PATH.TASK, result.entries);
-      return res.json(bundle);
-    } catch (err) {
-      return sendOperationOutcome500(
-        res,
-        err,
-        "GET /Task?owner= search error:"
-      );
-    }
+  const malformedRef = findMalformedReference32(
+    req.query,
+    searchParamKeys
+  );
+  if (malformedRef !== void 0) {
+    return sendInvalidSearch40032(
+      res,
+      `?${malformedRef.rawKey} must be a typed reference like "Practitioner/<id>"; got "${malformedRef.value}".`
+    );
   }
-  if (requesterRef !== void 0) {
-    if (parseTypedReference(requesterRef) === void 0) {
-      return sendInvalidSearch40013(
-        res,
-        `?requester must be a typed reference like "Practitioner/<id>"; got "${requesterRef}".`
-      );
-    }
-    const ctx = req.openhiContext;
-    try {
-      const result = await searchTasksByRequesterOperation({
-        context: ctx,
-        requesterReference: requesterRef
-      });
-      const bundle = buildSearchsetBundle(BASE_PATH.TASK, result.entries);
-      return res.json(bundle);
-    } catch (err) {
-      return sendOperationOutcome500(
-        res,
-        err,
-        "GET /Task?requester= search error:"
-      );
-    }
+  const ctx = req.openhiContext;
+  try {
+    const result = await genericSearchOperation({
+      resourceType: TASK_RESOURCE_TYPE,
+      tenantId: ctx.tenantId,
+      workspaceId: ctx.workspaceId,
+      query: req.query,
+      resolver: defaultSearchParameterResolver
+    });
+    const bundle = buildSearchsetBundle(BASE_PATH.TASK, result.entries);
+    return res.json(bundle);
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /Task search error:");
   }
-  return handleListRoute({
-    req,
-    res,
-    basePath: BASE_PATH.TASK,
-    listOperation: listTasksOperation,
-    errorLogContext: "GET /Task list error:"
-  });
 }
 
 // src/data/operations/data/task/task-update-operation.ts