@openhi/constructs 0.0.108 → 0.0.110

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

@@ -33,11 +33,11 @@ __export(rest_api_lambda_handler_exports, {
   handler: () => handler
 });
 module.exports = __toCommonJS(rest_api_lambda_handler_exports);
-var import_serverless_express2 = __toESM(require("@codegenie/serverless-express"));
+var import_serverless_express3 = __toESM(require("@codegenie/serverless-express"));
 
 // src/data/rest-api/rest-api.ts
 var import_node_path = __toESM(require("path"));
-var import_express150 = __toESM(require("express"));
+var import_express151 = __toESM(require("express"));
 
 // src/data/middleware/normalize-json-body.ts
 function normalizeJsonBodyMiddleware(req, _res, next) {
@@ -1408,10 +1408,16 @@ var ConflictError = class extends DomainError {
     super(message, "CONFLICT", options);
   }
 };
+var ForbiddenError = class extends DomainError {
+  constructor(message, options) {
+    super(message, "FORBIDDEN", options);
+  }
+};
 function domainErrorToHttpStatus(err) {
   if (err instanceof NotFoundError) return 404;
   if (err instanceof ValidationError) return 400;
   if (err instanceof ConflictError) return 409;
+  if (err instanceof ForbiddenError) return 403;
   return null;
 }
 
@@ -4790,12 +4796,353 @@ router6.post("/", createUserRoute);
 router6.put("/:id", updateUserRoute);
 router6.delete("/:id", deleteUserRoute);
 
-// src/data/rest-api/routes/control/workspace/workspace.ts
+// src/data/rest-api/routes/control/user/user-operations.ts
 var import_express7 = __toESM(require("express"));
 
-// src/data/operations/control/workspace/workspace-create-operation.ts
+// src/data/rest-api/routes/control/user/user-operation-helpers.ts
+var import_serverless_express2 = require("@codegenie/serverless-express");
+function getCognitoSubFromRequest(req) {
+  const invoke = (0, import_serverless_express2.getCurrentInvoke)();
+  const event = invoke?.event ?? req.apiGateway?.event;
+  const sub = event?.requestContext?.authorizer?.jwt?.claims?.sub;
+  if (typeof sub !== "string") {
+    return void 0;
+  }
+  const trimmed = sub.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+
+// src/data/operations/control/user/user-find-by-sub-operation.ts
+async function findUserBySubOperation(params) {
+  const { cognitoSub, tableName } = params;
+  const service = getDynamoControlService(tableName);
+  const result = await service.entities.user.query.gsi2({ cognitoSub }).go({ limit: 1 });
+  const item = result.data?.[0];
+  if (!item) {
+    return void 0;
+  }
+  return {
+    id: item.id,
+    cognitoSub: item.cognitoSub,
+    resource: item.resource,
+    vid: item.vid
+  };
+}
+
+// src/data/operations/control/user/user-switch-tenant-workspace-operation.ts
 var import_types14 = require("@openhi/types");
 
+// src/data/operations/control/user/user-resource-helpers.ts
+function parseUserResource(resource) {
+  try {
+    return JSON.parse(resource);
+  } catch {
+    return void 0;
+  }
+}
+
+// src/data/operations/fhir-reference.ts
+function idFromReference(reference, prefix) {
+  if (!reference || !reference.startsWith(prefix)) {
+    return void 0;
+  }
+  const id = reference.slice(prefix.length);
+  return id.length > 0 ? id : void 0;
+}
+
+// src/data/operations/control/membership/membership-find-for-user-in-tenant-operation.ts
+var SK11 = "CURRENT";
+async function findMembershipsForUserInTenantOperation(params) {
+  const { tenantId, userId, tableName } = params;
+  const service = getDynamoControlService(tableName);
+  const shardResults = await Promise.all(
+    Array.from(
+      { length: SHARD_COUNT },
+      (_, shard) => service.entities.membership.query.gsi1({ tenantId, gsi1Shard: String(shard) }).go()
+    )
+  );
+  const expectedUserRef = `User/${userId}`;
+  const memberships = [];
+  for (const shard of shardResults) {
+    for (const item of shard.data ?? []) {
+      if (item.sk !== SK11) {
+        continue;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(item.resource);
+      } catch {
+        continue;
+      }
+      const userRef = parsed.user?.reference;
+      if (userRef !== expectedUserRef) {
+        continue;
+      }
+      memberships.push({ id: item.id, resource: parsed });
+    }
+  }
+  return { memberships };
+}
+function pickTenantMembership(memberships) {
+  return memberships.find(
+    (m) => m.resource.workspace == null
+  );
+}
+function pickWorkspaceMembership(memberships, workspaceId) {
+  const expectedWorkspaceRef = `Workspace/${workspaceId}`;
+  return memberships.find(
+    (m) => m.resource.workspace?.reference === expectedWorkspaceRef
+  );
+}
+
+// src/data/operations/control/user/user-switch-tenant-workspace-operation.ts
+var SK12 = "CURRENT";
+async function switchUserTenantWorkspaceOperation(params) {
+  const { cognitoSub, tenantReference, workspaceReference, tableName } = params;
+  const tenantId = idFromReference(tenantReference, "Tenant/");
+  if (!tenantId) {
+    throw new ValidationError(
+      "tenant.reference must be a 'Tenant/<id>' reference."
+    );
+  }
+  const workspaceId = idFromReference(workspaceReference, "Workspace/");
+  if (!workspaceId) {
+    throw new ValidationError(
+      "workspace.reference must be a 'Workspace/<id>' reference."
+    );
+  }
+  const user = await findUserBySubOperation({
+    // findUserBySubOperation does not read context fields; pass a stub.
+    context: {
+      tenantId: "",
+      workspaceId: "",
+      date: "",
+      actorId: "",
+      actorName: "",
+      actorType: "internal-system"
+    },
+    cognitoSub,
+    tableName
+  });
+  if (!user) {
+    throw new NotFoundError(
+      "User not yet provisioned for the authenticated Cognito subject."
+    );
+  }
+  const { memberships } = await findMembershipsForUserInTenantOperation({
+    tenantId,
+    userId: user.id,
+    tableName
+  });
+  if (!pickTenantMembership(memberships)) {
+    throw new ForbiddenError(`User is not a member of Tenant/${tenantId}.`);
+  }
+  if (!pickWorkspaceMembership(memberships, workspaceId)) {
+    throw new ForbiddenError(
+      `User is not a member of Workspace/${workspaceId} in Tenant/${tenantId}.`
+    );
+  }
+  const existingResource = parseUserResource(user.resource) ?? {};
+  const updatedResource = {
+    ...existingResource,
+    resourceType: "User",
+    id: user.id,
+    currentTenant: { reference: `Tenant/${tenantId}` },
+    currentWorkspace: { reference: `Workspace/${workspaceId}` }
+  };
+  const lastUpdated = (params.now ? params.now() : /* @__PURE__ */ new Date()).toISOString();
+  const vid = `${Date.now()}`;
+  const summary = JSON.stringify(
+    (0, import_types14.extractSummary)(updatedResource)
+  );
+  const service = getDynamoControlService(tableName);
+  await service.entities.user.patch({ id: user.id, sk: SK12 }).set({
+    resource: JSON.stringify(updatedResource),
+    summary,
+    vid,
+    lastUpdated
+  }).go();
+  return {
+    id: user.id,
+    resource: updatedResource,
+    meta: { lastUpdated, versionId: vid }
+  };
+}
+
+// src/data/rest-api/routes/control/user/user-current-route.ts
+async function userCurrentRoute(req, res) {
+  if (Object.keys(req.query ?? {}).length > 0) {
+    return res.status(400).json({
+      resourceType: "OperationOutcome",
+      issue: [
+        {
+          severity: "error",
+          code: "invalid",
+          diagnostics: "GET /User/$current does not accept query parameters."
+        }
+      ]
+    });
+  }
+  if (hasNonEmptyBody(req.body)) {
+    return res.status(400).json({
+      resourceType: "OperationOutcome",
+      issue: [
+        {
+          severity: "error",
+          code: "invalid",
+          diagnostics: "GET /User/$current does not accept a request body."
+        }
+      ]
+    });
+  }
+  const cognitoSub = getCognitoSubFromRequest(req);
+  if (!cognitoSub) {
+    return res.status(401).json({
+      resourceType: "OperationOutcome",
+      issue: [
+        {
+          severity: "error",
+          code: "login",
+          diagnostics: "Missing or invalid JWT."
+        }
+      ]
+    });
+  }
+  try {
+    const found = await findUserBySubOperation({
+      // findUserBySubOperation does not read context fields; pass a stub.
+      context: {
+        tenantId: "",
+        workspaceId: "",
+        date: "",
+        actorId: "",
+        actorName: "",
+        actorType: "internal-system"
+      },
+      cognitoSub
+    });
+    if (!found) {
+      return res.status(404).json({
+        resourceType: "OperationOutcome",
+        issue: [
+          {
+            severity: "error",
+            code: "not-found",
+            diagnostics: "User not yet provisioned for the authenticated Cognito subject."
+          }
+        ]
+      });
+    }
+    const parsedResource = JSON.parse(found.resource);
+    res.setHeader("Cache-Control", "no-store");
+    return res.json({
+      resourceType: "User",
+      id: found.id,
+      ...parsedResource
+    });
+  } catch (err) {
+    return sendOperationOutcome500(res, err, "GET /User/$current error:");
+  }
+}
+function hasNonEmptyBody(body) {
+  if (body == null) {
+    return false;
+  }
+  if (Array.isArray(body)) {
+    return body.length > 0;
+  }
+  if (typeof body === "object") {
+    return Object.keys(body).length > 0;
+  }
+  if (typeof body === "string") {
+    return body.length > 0;
+  }
+  return true;
+}
+
+// src/data/rest-api/routes/control/user/user-switch-route.ts
+async function userSwitchRoute(req, res) {
+  const cognitoSub = getCognitoSubFromRequest(req);
+  if (!cognitoSub) {
+    return res.status(401).json({
+      resourceType: "OperationOutcome",
+      issue: [
+        {
+          severity: "error",
+          code: "login",
+          diagnostics: "Missing or invalid JWT."
+        }
+      ]
+    });
+  }
+  const bodyResult = requireJsonBody(req, res);
+  if ("errorResponse" in bodyResult) {
+    return bodyResult.errorResponse;
+  }
+  const body = bodyResult.body;
+  const tenantReference = body.tenant?.reference;
+  const workspaceReference = body.workspace?.reference;
+  if (typeof tenantReference !== "string" || tenantReference === "") {
+    return sendInvalid(
+      res,
+      "Body must include `tenant.reference` (e.g. 'Tenant/<id>')."
+    );
+  }
+  if (typeof workspaceReference !== "string" || workspaceReference === "") {
+    return sendInvalid(
+      res,
+      "Body must include `workspace.reference` (e.g. 'Workspace/<id>')."
+    );
+  }
+  try {
+    const result = await switchUserTenantWorkspaceOperation({
+      cognitoSub,
+      tenantReference,
+      workspaceReference
+    });
+    res.setHeader("Cache-Control", "no-store");
+    return res.status(200).json(result.resource);
+  } catch (err) {
+    if (err instanceof ValidationError) {
+      return sendInvalid(res, err.message);
+    }
+    if (err instanceof ForbiddenError) {
+      return res.status(403).json({
+        resourceType: "OperationOutcome",
+        issue: [
+          { severity: "error", code: "forbidden", diagnostics: err.message }
+        ]
+      });
+    }
+    if (err instanceof NotFoundError) {
+      return res.status(404).json({
+        resourceType: "OperationOutcome",
+        issue: [
+          { severity: "error", code: "not-found", diagnostics: err.message }
+        ]
+      });
+    }
+    return sendOperationOutcome500(res, err, "POST /User/$switch error:");
+  }
+}
+function sendInvalid(res, diagnostics) {
+  return res.status(400).json({
+    resourceType: "OperationOutcome",
+    issue: [{ severity: "error", code: "invalid", diagnostics }]
+  });
+}
+
+// src/data/rest-api/routes/control/user/user-operations.ts
+var router7 = import_express7.default.Router();
+router7.get("/$current", userCurrentRoute);
+router7.post("/$switch", userSwitchRoute);
+
+// src/data/rest-api/routes/control/workspace/workspace.ts
+var import_express8 = __toESM(require("express"));
+
+// src/data/operations/control/workspace/workspace-create-operation.ts
+var import_types15 = require("@openhi/types");
+
 // src/data/operations/data/organization/organization-provision-for-workspace-operation.ts
 async function provisionOrganizationForWorkspaceOperation(params) {
   const { context, workspaceId, workspaceName, tableName } = params;
@@ -4844,7 +5191,7 @@ async function createWorkspaceOperation(params) {
   const vid = lastUpdated.replace(/[-:T.Z]/g, "").slice(0, 12) || Date.now().toString(36);
   const parsedResource = typeof body.resource === "string" ? JSON.parse(body.resource) : body.resource ?? {};
   const resource = { resourceType: "Workspace", id, ...parsedResource };
-  const summary = JSON.stringify((0, import_types14.extractSummary)(resource));
+  const summary = JSON.stringify((0, import_types15.extractSummary)(resource));
   await service.entities.workspace.put({
     tenantId,
     id,
@@ -4982,7 +5329,7 @@ async function getWorkspaceByIdRoute(req, res) {
 }
 
 // src/data/operations/control/workspace/workspace-list-operation.ts
-var SK11 = "CURRENT";
+var SK13 = "CURRENT";
 async function listWorkspacesOperation(params) {
   const { context, tableName, mode = "full" } = params;
   const { tenantId } = context;
@@ -4999,7 +5346,7 @@ async function listWorkspacesOperation(params) {
     {
       hydrate: (orderedIds) => batchGetWithRetry(
         service.entities.workspace,
-        orderedIds.map((id) => ({ tenantId, id, sk: SK11 }))
+        orderedIds.map((id) => ({ tenantId, id, sk: SK13 }))
       ),
       getId: (item) => item.id,
       buildEntry: (id, item) => ({
@@ -5030,7 +5377,7 @@ async function listWorkspacesRoute(req, res) {
 }
 
 // src/data/operations/control/workspace/workspace-update-operation.ts
-var import_types15 = require("@openhi/types");
+var import_types16 = require("@openhi/types");
 async function updateWorkspaceOperation(params) {
   const { context, id, body, tableName } = params;
   const { tenantId } = context;
@@ -5049,7 +5396,7 @@ async function updateWorkspaceOperation(params) {
     resourceType: "Workspace",
     id
   };
-  const summary = JSON.stringify((0, import_types15.extractSummary)(updated));
+  const summary = JSON.stringify((0, import_types16.extractSummary)(updated));
   await service.entities.workspace.patch({ tenantId, id, sk: "CURRENT" }).set({ resource: JSON.stringify(updated), summary, vid, lastUpdated }).go();
   return { id, resource: updated, meta: { lastUpdated, versionId: vid } };
 }
@@ -5095,15 +5442,15 @@ async function updateWorkspaceRoute(req, res) {
 }
 
 // src/data/rest-api/routes/control/workspace/workspace.ts
-var router7 = import_express7.default.Router();
-router7.get("/", listWorkspacesRoute);
-router7.get("/:id", getWorkspaceByIdRoute);
-router7.post("/", createWorkspaceRoute);
-router7.put("/:id", updateWorkspaceRoute);
-router7.delete("/:id", deleteWorkspaceRoute);
+var router8 = import_express8.default.Router();
+router8.get("/", listWorkspacesRoute);
+router8.get("/:id", getWorkspaceByIdRoute);
+router8.post("/", createWorkspaceRoute);
+router8.put("/:id", updateWorkspaceRoute);
+router8.delete("/:id", deleteWorkspaceRoute);
 
 // src/data/rest-api/routes/data/account/account.ts
-var import_express8 = __toESM(require("express"));
+var import_express9 = __toESM(require("express"));
 
 // src/data/operations/data/account/account-create-operation.ts
 var import_ulid2 = require("ulid");
@@ -5295,15 +5642,15 @@ async function updateAccountRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/account/account.ts
-var router8 = import_express8.default.Router();
-router8.get("/", listAccountsRoute);
-router8.get("/:id", getAccountByIdRoute);
-router8.post("/", createAccountRoute);
-router8.put("/:id", updateAccountRoute);
-router8.delete("/:id", deleteAccountRoute);
+var router9 = import_express9.default.Router();
+router9.get("/", listAccountsRoute);
+router9.get("/:id", getAccountByIdRoute);
+router9.post("/", createAccountRoute);
+router9.put("/:id", updateAccountRoute);
+router9.delete("/:id", deleteAccountRoute);
 
 // src/data/rest-api/routes/data/activitydefinition/activitydefinition.ts
-var import_express9 = __toESM(require("express"));
+var import_express10 = __toESM(require("express"));
 
 // src/data/operations/data/activitydefinition/activitydefinition-create-operation.ts
 var import_ulid3 = require("ulid");
@@ -5502,15 +5849,15 @@ async function updateActivityDefinitionRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/activitydefinition/activitydefinition.ts
-var router9 = import_express9.default.Router();
-router9.get("/", listActivityDefinitionsRoute);
-router9.get("/:id", getActivityDefinitionByIdRoute);
-router9.post("/", createActivityDefinitionRoute);
-router9.put("/:id", updateActivityDefinitionRoute);
-router9.delete("/:id", deleteActivityDefinitionRoute);
+var router10 = import_express10.default.Router();
+router10.get("/", listActivityDefinitionsRoute);
+router10.get("/:id", getActivityDefinitionByIdRoute);
+router10.post("/", createActivityDefinitionRoute);
+router10.put("/:id", updateActivityDefinitionRoute);
+router10.delete("/:id", deleteActivityDefinitionRoute);
 
 // src/data/rest-api/routes/data/adverseevent/adverseevent.ts
-var import_express10 = __toESM(require("express"));
+var import_express11 = __toESM(require("express"));
 
 // src/data/operations/data/adverseevent/adverseevent-create-operation.ts
 var import_ulid4 = require("ulid");
@@ -5702,15 +6049,15 @@ async function updateAdverseEventRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/adverseevent/adverseevent.ts
-var router10 = import_express10.default.Router();
-router10.get("/", listAdverseEventsRoute);
-router10.get("/:id", getAdverseEventByIdRoute);
-router10.post("/", createAdverseEventRoute);
-router10.put("/:id", updateAdverseEventRoute);
-router10.delete("/:id", deleteAdverseEventRoute);
+var router11 = import_express11.default.Router();
+router11.get("/", listAdverseEventsRoute);
+router11.get("/:id", getAdverseEventByIdRoute);
+router11.post("/", createAdverseEventRoute);
+router11.put("/:id", updateAdverseEventRoute);
+router11.delete("/:id", deleteAdverseEventRoute);
 
 // src/data/rest-api/routes/data/allergyintolerance/allergyintolerance.ts
-var import_express11 = __toESM(require("express"));
+var import_express12 = __toESM(require("express"));
 
 // src/data/operations/data/allergyintolerance/allergyintolerance-create-operation.ts
 var import_ulid5 = require("ulid");
@@ -5909,15 +6256,15 @@ async function updateAllergyIntoleranceRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/allergyintolerance/allergyintolerance.ts
-var router11 = import_express11.default.Router();
-router11.get("/", listAllergyIntolerancesRoute);
-router11.get("/:id", getAllergyIntoleranceByIdRoute);
-router11.post("/", createAllergyIntoleranceRoute);
-router11.put("/:id", updateAllergyIntoleranceRoute);
-router11.delete("/:id", deleteAllergyIntoleranceRoute);
+var router12 = import_express12.default.Router();
+router12.get("/", listAllergyIntolerancesRoute);
+router12.get("/:id", getAllergyIntoleranceByIdRoute);
+router12.post("/", createAllergyIntoleranceRoute);
+router12.put("/:id", updateAllergyIntoleranceRoute);
+router12.delete("/:id", deleteAllergyIntoleranceRoute);
 
 // src/data/rest-api/routes/data/appointment/appointment.ts
-var import_express12 = __toESM(require("express"));
+var import_express13 = __toESM(require("express"));
 
 // src/data/operations/data/appointment/appointment-create-operation.ts
 var import_ulid6 = require("ulid");
@@ -6702,15 +7049,15 @@ async function updateAppointmentRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/appointment/appointment.ts
-var router12 = import_express12.default.Router();
-router12.get("/", listAppointmentsRoute);
-router12.get("/:id", getAppointmentByIdRoute);
-router12.post("/", createAppointmentRoute);
-router12.put("/:id", updateAppointmentRoute);
-router12.delete("/:id", deleteAppointmentRoute);
+var router13 = import_express13.default.Router();
+router13.get("/", listAppointmentsRoute);
+router13.get("/:id", getAppointmentByIdRoute);
+router13.post("/", createAppointmentRoute);
+router13.put("/:id", updateAppointmentRoute);
+router13.delete("/:id", deleteAppointmentRoute);
 
 // src/data/rest-api/routes/data/appointmentresponse/appointmentresponse.ts
-var import_express13 = __toESM(require("express"));
+var import_express14 = __toESM(require("express"));
 
 // src/data/operations/data/appointmentresponse/appointmentresponse-create-operation.ts
 var import_ulid7 = require("ulid");
@@ -6909,15 +7256,15 @@ async function updateAppointmentResponseRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/appointmentresponse/appointmentresponse.ts
-var router13 = import_express13.default.Router();
-router13.get("/", listAppointmentResponsesRoute);
-router13.get("/:id", getAppointmentResponseByIdRoute);
-router13.post("/", createAppointmentResponseRoute);
-router13.put("/:id", updateAppointmentResponseRoute);
-router13.delete("/:id", deleteAppointmentResponseRoute);
+var router14 = import_express14.default.Router();
+router14.get("/", listAppointmentResponsesRoute);
+router14.get("/:id", getAppointmentResponseByIdRoute);
+router14.post("/", createAppointmentResponseRoute);
+router14.put("/:id", updateAppointmentResponseRoute);
+router14.delete("/:id", deleteAppointmentResponseRoute);
 
 // src/data/rest-api/routes/data/auditevent/auditevent.ts
-var import_express14 = __toESM(require("express"));
+var import_express15 = __toESM(require("express"));
 
 // src/data/operations/data/auditevent/auditevent-create-operation.ts
 var import_ulid8 = require("ulid");
@@ -7109,15 +7456,15 @@ async function updateAuditEventRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/auditevent/auditevent.ts
-var router14 = import_express14.default.Router();
-router14.get("/", listAuditEventsRoute);
-router14.get("/:id", getAuditEventByIdRoute);
-router14.post("/", createAuditEventRoute);
-router14.put("/:id", updateAuditEventRoute);
-router14.delete("/:id", deleteAuditEventRoute);
+var router15 = import_express15.default.Router();
+router15.get("/", listAuditEventsRoute);
+router15.get("/:id", getAuditEventByIdRoute);
+router15.post("/", createAuditEventRoute);
+router15.put("/:id", updateAuditEventRoute);
+router15.delete("/:id", deleteAuditEventRoute);
 
 // src/data/rest-api/routes/data/basic/basic.ts
-var import_express15 = __toESM(require("express"));
+var import_express16 = __toESM(require("express"));
 
 // src/data/operations/data/basic/basic-create-operation.ts
 var import_ulid9 = require("ulid");
@@ -7309,15 +7656,15 @@ async function updateBasicRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/basic/basic.ts
-var router15 = import_express15.default.Router();
-router15.get("/", listBasicsRoute);
-router15.get("/:id", getBasicByIdRoute);
-router15.post("/", createBasicRoute);
-router15.put("/:id", updateBasicRoute);
-router15.delete("/:id", deleteBasicRoute);
+var router16 = import_express16.default.Router();
+router16.get("/", listBasicsRoute);
+router16.get("/:id", getBasicByIdRoute);
+router16.post("/", createBasicRoute);
+router16.put("/:id", updateBasicRoute);
+router16.delete("/:id", deleteBasicRoute);
 
 // src/data/rest-api/routes/data/biologicallyderivedproduct/biologicallyderivedproduct.ts
-var import_express16 = __toESM(require("express"));
+var import_express17 = __toESM(require("express"));
 
 // src/data/operations/data/biologicallyderivedproduct/biologicallyderivedproduct-create-operation.ts
 var import_ulid10 = require("ulid");
@@ -7528,15 +7875,15 @@ async function updateBiologicallyDerivedProductRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/biologicallyderivedproduct/biologicallyderivedproduct.ts
-var router16 = import_express16.default.Router();
-router16.get("/", listBiologicallyDerivedProductsRoute);
-router16.get("/:id", getBiologicallyDerivedProductByIdRoute);
-router16.post("/", createBiologicallyDerivedProductRoute);
-router16.put("/:id", updateBiologicallyDerivedProductRoute);
-router16.delete("/:id", deleteBiologicallyDerivedProductRoute);
+var router17 = import_express17.default.Router();
+router17.get("/", listBiologicallyDerivedProductsRoute);
+router17.get("/:id", getBiologicallyDerivedProductByIdRoute);
+router17.post("/", createBiologicallyDerivedProductRoute);
+router17.put("/:id", updateBiologicallyDerivedProductRoute);
+router17.delete("/:id", deleteBiologicallyDerivedProductRoute);
 
 // src/data/rest-api/routes/data/bodystructure/bodystructure.ts
-var import_express17 = __toESM(require("express"));
+var import_express18 = __toESM(require("express"));
 
 // src/data/operations/data/bodystructure/bodystructure-create-operation.ts
 var import_ulid11 = require("ulid");
@@ -7728,15 +8075,15 @@ async function updateBodyStructureRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/bodystructure/bodystructure.ts
-var router17 = import_express17.default.Router();
-router17.get("/", listBodyStructuresRoute);
-router17.get("/:id", getBodyStructureByIdRoute);
-router17.post("/", createBodyStructureRoute);
-router17.put("/:id", updateBodyStructureRoute);
-router17.delete("/:id", deleteBodyStructureRoute);
+var router18 = import_express18.default.Router();
+router18.get("/", listBodyStructuresRoute);
+router18.get("/:id", getBodyStructureByIdRoute);
+router18.post("/", createBodyStructureRoute);
+router18.put("/:id", updateBodyStructureRoute);
+router18.delete("/:id", deleteBodyStructureRoute);
 
 // src/data/rest-api/routes/data/capabilitystatement/capabilitystatement.ts
-var import_express18 = __toESM(require("express"));
+var import_express19 = __toESM(require("express"));
 
 // src/data/operations/data/capabilitystatement/capabilitystatement-create-operation.ts
 var import_ulid12 = require("ulid");
@@ -7935,15 +8282,15 @@ async function updateCapabilityStatementRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/capabilitystatement/capabilitystatement.ts
-var router18 = import_express18.default.Router();
-router18.get("/", listCapabilityStatementsRoute);
-router18.get("/:id", getCapabilityStatementByIdRoute);
-router18.post("/", createCapabilityStatementRoute);
-router18.put("/:id", updateCapabilityStatementRoute);
-router18.delete("/:id", deleteCapabilityStatementRoute);
+var router19 = import_express19.default.Router();
+router19.get("/", listCapabilityStatementsRoute);
+router19.get("/:id", getCapabilityStatementByIdRoute);
+router19.post("/", createCapabilityStatementRoute);
+router19.put("/:id", updateCapabilityStatementRoute);
+router19.delete("/:id", deleteCapabilityStatementRoute);
 
 // src/data/rest-api/routes/data/careplan/careplan.ts
-var import_express19 = __toESM(require("express"));
+var import_express20 = __toESM(require("express"));
 
 // src/data/operations/data/careplan/careplan-create-operation.ts
 var import_ulid13 = require("ulid");
@@ -8135,15 +8482,15 @@ async function updateCarePlanRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/careplan/careplan.ts
-var router19 = import_express19.default.Router();
-router19.get("/", listCarePlansRoute);
-router19.get("/:id", getCarePlanByIdRoute);
-router19.post("/", createCarePlanRoute);
-router19.put("/:id", updateCarePlanRoute);
-router19.delete("/:id", deleteCarePlanRoute);
+var router20 = import_express20.default.Router();
+router20.get("/", listCarePlansRoute);
+router20.get("/:id", getCarePlanByIdRoute);
+router20.post("/", createCarePlanRoute);
+router20.put("/:id", updateCarePlanRoute);
+router20.delete("/:id", deleteCarePlanRoute);
 
 // src/data/rest-api/routes/data/careteam/careteam.ts
-var import_express20 = __toESM(require("express"));
+var import_express21 = __toESM(require("express"));
 
 // src/data/operations/data/careteam/careteam-create-operation.ts
 var import_ulid14 = require("ulid");
@@ -8335,15 +8682,15 @@ async function updateCareTeamRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/careteam/careteam.ts
-var router20 = import_express20.default.Router();
-router20.get("/", listCareTeamsRoute);
-router20.get("/:id", getCareTeamByIdRoute);
-router20.post("/", createCareTeamRoute);
-router20.put("/:id", updateCareTeamRoute);
-router20.delete("/:id", deleteCareTeamRoute);
+var router21 = import_express21.default.Router();
+router21.get("/", listCareTeamsRoute);
+router21.get("/:id", getCareTeamByIdRoute);
+router21.post("/", createCareTeamRoute);
+router21.put("/:id", updateCareTeamRoute);
+router21.delete("/:id", deleteCareTeamRoute);
 
 // src/data/rest-api/routes/data/catalogentry/catalogentry.ts
-var import_express21 = __toESM(require("express"));
+var import_express22 = __toESM(require("express"));
 
 // src/data/operations/data/catalogentry/catalogentry-create-operation.ts
 var import_ulid15 = require("ulid");
@@ -8535,15 +8882,15 @@ async function updateCatalogEntryRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/catalogentry/catalogentry.ts
-var router21 = import_express21.default.Router();
-router21.get("/", listCatalogEntrysRoute);
-router21.get("/:id", getCatalogEntryByIdRoute);
-router21.post("/", createCatalogEntryRoute);
-router21.put("/:id", updateCatalogEntryRoute);
-router21.delete("/:id", deleteCatalogEntryRoute);
+var router22 = import_express22.default.Router();
+router22.get("/", listCatalogEntrysRoute);
+router22.get("/:id", getCatalogEntryByIdRoute);
+router22.post("/", createCatalogEntryRoute);
+router22.put("/:id", updateCatalogEntryRoute);
+router22.delete("/:id", deleteCatalogEntryRoute);
 
 // src/data/rest-api/routes/data/chargeitem/chargeitem.ts
-var import_express22 = __toESM(require("express"));
+var import_express23 = __toESM(require("express"));
 
 // src/data/operations/data/chargeitem/chargeitem-create-operation.ts
 var import_ulid16 = require("ulid");
@@ -8735,15 +9082,15 @@ async function updateChargeItemRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/chargeitem/chargeitem.ts
-var router22 = import_express22.default.Router();
-router22.get("/", listChargeItemsRoute);
-router22.get("/:id", getChargeItemByIdRoute);
-router22.post("/", createChargeItemRoute);
-router22.put("/:id", updateChargeItemRoute);
-router22.delete("/:id", deleteChargeItemRoute);
+var router23 = import_express23.default.Router();
+router23.get("/", listChargeItemsRoute);
+router23.get("/:id", getChargeItemByIdRoute);
+router23.post("/", createChargeItemRoute);
+router23.put("/:id", updateChargeItemRoute);
+router23.delete("/:id", deleteChargeItemRoute);
 
 // src/data/rest-api/routes/data/chargeitemdefinition/chargeitemdefinition.ts
-var import_express23 = __toESM(require("express"));
+var import_express24 = __toESM(require("express"));
 
 // src/data/operations/data/chargeitemdefinition/chargeitemdefinition-create-operation.ts
 var import_ulid17 = require("ulid");
@@ -8946,15 +9293,15 @@ async function updateChargeItemDefinitionRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/chargeitemdefinition/chargeitemdefinition.ts
-var router23 = import_express23.default.Router();
-router23.get("/", listChargeItemDefinitionsRoute);
-router23.get("/:id", getChargeItemDefinitionByIdRoute);
-router23.post("/", createChargeItemDefinitionRoute);
-router23.put("/:id", updateChargeItemDefinitionRoute);
-router23.delete("/:id", deleteChargeItemDefinitionRoute);
+var router24 = import_express24.default.Router();
+router24.get("/", listChargeItemDefinitionsRoute);
+router24.get("/:id", getChargeItemDefinitionByIdRoute);
+router24.post("/", createChargeItemDefinitionRoute);
+router24.put("/:id", updateChargeItemDefinitionRoute);
+router24.delete("/:id", deleteChargeItemDefinitionRoute);
 
 // src/data/rest-api/routes/data/claim/claim.ts
-var import_express24 = __toESM(require("express"));
+var import_express25 = __toESM(require("express"));
 
 // src/data/operations/data/claim/claim-create-operation.ts
 var import_ulid18 = require("ulid");
@@ -9146,15 +9493,15 @@ async function updateClaimRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/claim/claim.ts
-var router24 = import_express24.default.Router();
-router24.get("/", listClaimsRoute);
-router24.get("/:id", getClaimByIdRoute);
-router24.post("/", createClaimRoute);
-router24.put("/:id", updateClaimRoute);
-router24.delete("/:id", deleteClaimRoute);
+var router25 = import_express25.default.Router();
+router25.get("/", listClaimsRoute);
+router25.get("/:id", getClaimByIdRoute);
+router25.post("/", createClaimRoute);
+router25.put("/:id", updateClaimRoute);
+router25.delete("/:id", deleteClaimRoute);
 
 // src/data/rest-api/routes/data/claimresponse/claimresponse.ts
-var import_express25 = __toESM(require("express"));
+var import_express26 = __toESM(require("express"));
 
 // src/data/operations/data/claimresponse/claimresponse-create-operation.ts
 var import_ulid19 = require("ulid");
@@ -9346,15 +9693,15 @@ async function updateClaimResponseRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/claimresponse/claimresponse.ts
-var router25 = import_express25.default.Router();
-router25.get("/", listClaimResponsesRoute);
-router25.get("/:id", getClaimResponseByIdRoute);
-router25.post("/", createClaimResponseRoute);
-router25.put("/:id", updateClaimResponseRoute);
-router25.delete("/:id", deleteClaimResponseRoute);
+var router26 = import_express26.default.Router();
+router26.get("/", listClaimResponsesRoute);
+router26.get("/:id", getClaimResponseByIdRoute);
+router26.post("/", createClaimResponseRoute);
+router26.put("/:id", updateClaimResponseRoute);
+router26.delete("/:id", deleteClaimResponseRoute);
 
 // src/data/rest-api/routes/data/clinicalimpression/clinicalimpression.ts
-var import_express26 = __toESM(require("express"));
+var import_express27 = __toESM(require("express"));
 
 // src/data/operations/data/clinicalimpression/clinicalimpression-create-operation.ts
 var import_ulid20 = require("ulid");
@@ -9553,15 +9900,15 @@ async function updateClinicalImpressionRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/clinicalimpression/clinicalimpression.ts
-var router26 = import_express26.default.Router();
-router26.get("/", listClinicalImpressionsRoute);
-router26.get("/:id", getClinicalImpressionByIdRoute);
-router26.post("/", createClinicalImpressionRoute);
-router26.put("/:id", updateClinicalImpressionRoute);
-router26.delete("/:id", deleteClinicalImpressionRoute);
+var router27 = import_express27.default.Router();
+router27.get("/", listClinicalImpressionsRoute);
+router27.get("/:id", getClinicalImpressionByIdRoute);
+router27.post("/", createClinicalImpressionRoute);
+router27.put("/:id", updateClinicalImpressionRoute);
+router27.delete("/:id", deleteClinicalImpressionRoute);
 
 // src/data/rest-api/routes/data/codesystem/codesystem.ts
-var import_express27 = __toESM(require("express"));
+var import_express28 = __toESM(require("express"));
 
 // src/data/operations/data/codesystem/codesystem-create-operation.ts
 var import_ulid21 = require("ulid");
@@ -9753,15 +10100,15 @@ async function updateCodeSystemRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/codesystem/codesystem.ts
-var router27 = import_express27.default.Router();
-router27.get("/", listCodeSystemsRoute);
-router27.get("/:id", getCodeSystemByIdRoute);
-router27.post("/", createCodeSystemRoute);
-router27.put("/:id", updateCodeSystemRoute);
-router27.delete("/:id", deleteCodeSystemRoute);
+var router28 = import_express28.default.Router();
+router28.get("/", listCodeSystemsRoute);
+router28.get("/:id", getCodeSystemByIdRoute);
+router28.post("/", createCodeSystemRoute);
+router28.put("/:id", updateCodeSystemRoute);
+router28.delete("/:id", deleteCodeSystemRoute);
 
 // src/data/rest-api/routes/data/communication/communication.ts
-var import_express28 = __toESM(require("express"));
+var import_express29 = __toESM(require("express"));
 
 // src/data/operations/data/communication/communication-create-operation.ts
 var import_ulid22 = require("ulid");
@@ -9953,15 +10300,15 @@ async function updateCommunicationRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/communication/communication.ts
-var router28 = import_express28.default.Router();
-router28.get("/", listCommunicationsRoute);
-router28.get("/:id", getCommunicationByIdRoute);
-router28.post("/", createCommunicationRoute);
-router28.put("/:id", updateCommunicationRoute);
-router28.delete("/:id", deleteCommunicationRoute);
+var router29 = import_express29.default.Router();
+router29.get("/", listCommunicationsRoute);
+router29.get("/:id", getCommunicationByIdRoute);
+router29.post("/", createCommunicationRoute);
+router29.put("/:id", updateCommunicationRoute);
+router29.delete("/:id", deleteCommunicationRoute);
 
 // src/data/rest-api/routes/data/communicationrequest/communicationrequest.ts
-var import_express29 = __toESM(require("express"));
+var import_express30 = __toESM(require("express"));
 
 // src/data/operations/data/communicationrequest/communicationrequest-create-operation.ts
 var import_ulid23 = require("ulid");
@@ -10164,15 +10511,15 @@ async function updateCommunicationRequestRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/communicationrequest/communicationrequest.ts
-var router29 = import_express29.default.Router();
-router29.get("/", listCommunicationRequestsRoute);
-router29.get("/:id", getCommunicationRequestByIdRoute);
-router29.post("/", createCommunicationRequestRoute);
-router29.put("/:id", updateCommunicationRequestRoute);
-router29.delete("/:id", deleteCommunicationRequestRoute);
+var router30 = import_express30.default.Router();
+router30.get("/", listCommunicationRequestsRoute);
+router30.get("/:id", getCommunicationRequestByIdRoute);
+router30.post("/", createCommunicationRequestRoute);
+router30.put("/:id", updateCommunicationRequestRoute);
+router30.delete("/:id", deleteCommunicationRequestRoute);
 
 // src/data/rest-api/routes/data/compartmentdefinition/compartmentdefinition.ts
-var import_express30 = __toESM(require("express"));
+var import_express31 = __toESM(require("express"));
 
 // src/data/operations/data/compartmentdefinition/compartmentdefinition-create-operation.ts
 var import_ulid24 = require("ulid");
@@ -10383,15 +10730,15 @@ async function updateCompartmentDefinitionRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/compartmentdefinition/compartmentdefinition.ts
-var router30 = import_express30.default.Router();
-router30.get("/", listCompartmentDefinitionsRoute);
-router30.get("/:id", getCompartmentDefinitionByIdRoute);
-router30.post("/", createCompartmentDefinitionRoute);
-router30.put("/:id", updateCompartmentDefinitionRoute);
-router30.delete("/:id", deleteCompartmentDefinitionRoute);
+var router31 = import_express31.default.Router();
+router31.get("/", listCompartmentDefinitionsRoute);
+router31.get("/:id", getCompartmentDefinitionByIdRoute);
+router31.post("/", createCompartmentDefinitionRoute);
+router31.put("/:id", updateCompartmentDefinitionRoute);
+router31.delete("/:id", deleteCompartmentDefinitionRoute);
 
 // src/data/rest-api/routes/data/composition/composition.ts
-var import_express31 = __toESM(require("express"));
+var import_express32 = __toESM(require("express"));
 
 // src/data/operations/data/composition/composition-create-operation.ts
 var import_ulid25 = require("ulid");
@@ -10583,15 +10930,15 @@ async function updateCompositionRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/composition/composition.ts
-var router31 = import_express31.default.Router();
-router31.get("/", listCompositionsRoute);
-router31.get("/:id", getCompositionByIdRoute);
-router31.post("/", createCompositionRoute);
-router31.put("/:id", updateCompositionRoute);
-router31.delete("/:id", deleteCompositionRoute);
+var router32 = import_express32.default.Router();
+router32.get("/", listCompositionsRoute);
+router32.get("/:id", getCompositionByIdRoute);
+router32.post("/", createCompositionRoute);
+router32.put("/:id", updateCompositionRoute);
+router32.delete("/:id", deleteCompositionRoute);
 
 // src/data/rest-api/routes/data/conceptmap/conceptmap.ts
-var import_express32 = __toESM(require("express"));
+var import_express33 = __toESM(require("express"));
 
 // src/data/operations/data/conceptmap/conceptmap-create-operation.ts
 var import_ulid26 = require("ulid");
@@ -10783,15 +11130,15 @@ async function updateConceptMapRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/conceptmap/conceptmap.ts
-var router32 = import_express32.default.Router();
-router32.get("/", listConceptMapsRoute);
-router32.get("/:id", getConceptMapByIdRoute);
-router32.post("/", createConceptMapRoute);
-router32.put("/:id", updateConceptMapRoute);
-router32.delete("/:id", deleteConceptMapRoute);
+var router33 = import_express33.default.Router();
+router33.get("/", listConceptMapsRoute);
+router33.get("/:id", getConceptMapByIdRoute);
+router33.post("/", createConceptMapRoute);
+router33.put("/:id", updateConceptMapRoute);
+router33.delete("/:id", deleteConceptMapRoute);
 
 // src/data/rest-api/routes/data/condition/condition.ts
-var import_express33 = __toESM(require("express"));
+var import_express34 = __toESM(require("express"));
 
 // src/data/operations/data/condition/condition-create-operation.ts
 var import_ulid27 = require("ulid");
@@ -10983,15 +11330,15 @@ async function updateConditionRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/condition/condition.ts
-var router33 = import_express33.default.Router();
-router33.get("/", listConditionsRoute);
-router33.get("/:id", getConditionByIdRoute);
-router33.post("/", createConditionRoute);
-router33.put("/:id", updateConditionRoute);
-router33.delete("/:id", deleteConditionRoute);
+var router34 = import_express34.default.Router();
+router34.get("/", listConditionsRoute);
+router34.get("/:id", getConditionByIdRoute);
+router34.post("/", createConditionRoute);
+router34.put("/:id", updateConditionRoute);
+router34.delete("/:id", deleteConditionRoute);
 
 // src/data/rest-api/routes/data/consent/consent.ts
-var import_express34 = __toESM(require("express"));
+var import_express35 = __toESM(require("express"));
 
 // src/data/operations/data/consent/consent-create-operation.ts
 var import_ulid28 = require("ulid");
@@ -11183,15 +11530,15 @@ async function updateConsentRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/consent/consent.ts
-var router34 = import_express34.default.Router();
-router34.get("/", listConsentsRoute);
-router34.get("/:id", getConsentByIdRoute);
-router34.post("/", createConsentRoute);
-router34.put("/:id", updateConsentRoute);
-router34.delete("/:id", deleteConsentRoute);
+var router35 = import_express35.default.Router();
+router35.get("/", listConsentsRoute);
+router35.get("/:id", getConsentByIdRoute);
+router35.post("/", createConsentRoute);
+router35.put("/:id", updateConsentRoute);
+router35.delete("/:id", deleteConsentRoute);
 
 // src/data/rest-api/routes/data/contract/contract.ts
-var import_express35 = __toESM(require("express"));
+var import_express36 = __toESM(require("express"));
 
 // src/data/operations/data/contract/contract-create-operation.ts
 var import_ulid29 = require("ulid");
@@ -11383,15 +11730,15 @@ async function updateContractRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/contract/contract.ts
-var router35 = import_express35.default.Router();
-router35.get("/", listContractsRoute);
-router35.get("/:id", getContractByIdRoute);
-router35.post("/", createContractRoute);
-router35.put("/:id", updateContractRoute);
-router35.delete("/:id", deleteContractRoute);
+var router36 = import_express36.default.Router();
+router36.get("/", listContractsRoute);
+router36.get("/:id", getContractByIdRoute);
+router36.post("/", createContractRoute);
+router36.put("/:id", updateContractRoute);
+router36.delete("/:id", deleteContractRoute);
 
 // src/data/rest-api/routes/data/coverage/coverage.ts
-var import_express36 = __toESM(require("express"));
+var import_express37 = __toESM(require("express"));
 
 // src/data/operations/data/coverage/coverage-create-operation.ts
 var import_ulid30 = require("ulid");
@@ -11586,15 +11933,15 @@ async function updateCoverageRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/coverage/coverage.ts
-var router36 = import_express36.default.Router();
-router36.get("/", listCoveragesRoute);
-router36.get("/:id", getCoverageByIdRoute);
-router36.post("/", createCoverageRoute);
-router36.put("/:id", updateCoverageRoute);
-router36.delete("/:id", deleteCoverageRoute);
+var router37 = import_express37.default.Router();
+router37.get("/", listCoveragesRoute);
+router37.get("/:id", getCoverageByIdRoute);
+router37.post("/", createCoverageRoute);
+router37.put("/:id", updateCoverageRoute);
+router37.delete("/:id", deleteCoverageRoute);
 
 // src/data/rest-api/routes/data/coverageeligibilityrequest/coverageeligibilityrequest.ts
-var import_express37 = __toESM(require("express"));
+var import_express38 = __toESM(require("express"));
 
 // src/data/operations/data/coverageeligibilityrequest/coverageeligibilityrequest-create-operation.ts
 var import_ulid31 = require("ulid");
@@ -11805,15 +12152,15 @@ async function updateCoverageEligibilityRequestRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/coverageeligibilityrequest/coverageeligibilityrequest.ts
-var router37 = import_express37.default.Router();
-router37.get("/", listCoverageEligibilityRequestsRoute);
-router37.get("/:id", getCoverageEligibilityRequestByIdRoute);
-router37.post("/", createCoverageEligibilityRequestRoute);
-router37.put("/:id", updateCoverageEligibilityRequestRoute);
-router37.delete("/:id", deleteCoverageEligibilityRequestRoute);
+var router38 = import_express38.default.Router();
+router38.get("/", listCoverageEligibilityRequestsRoute);
+router38.get("/:id", getCoverageEligibilityRequestByIdRoute);
+router38.post("/", createCoverageEligibilityRequestRoute);
+router38.put("/:id", updateCoverageEligibilityRequestRoute);
+router38.delete("/:id", deleteCoverageEligibilityRequestRoute);
 
 // src/data/rest-api/routes/data/coverageeligibilityresponse/coverageeligibilityresponse.ts
-var import_express38 = __toESM(require("express"));
+var import_express39 = __toESM(require("express"));
 
 // src/data/operations/data/coverageeligibilityresponse/coverageeligibilityresponse-create-operation.ts
 var import_ulid32 = require("ulid");
@@ -12024,15 +12371,15 @@ async function updateCoverageEligibilityResponseRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/coverageeligibilityresponse/coverageeligibilityresponse.ts
-var router38 = import_express38.default.Router();
-router38.get("/", listCoverageEligibilityResponsesRoute);
-router38.get("/:id", getCoverageEligibilityResponseByIdRoute);
-router38.post("/", createCoverageEligibilityResponseRoute);
-router38.put("/:id", updateCoverageEligibilityResponseRoute);
-router38.delete("/:id", deleteCoverageEligibilityResponseRoute);
+var router39 = import_express39.default.Router();
+router39.get("/", listCoverageEligibilityResponsesRoute);
+router39.get("/:id", getCoverageEligibilityResponseByIdRoute);
+router39.post("/", createCoverageEligibilityResponseRoute);
+router39.put("/:id", updateCoverageEligibilityResponseRoute);
+router39.delete("/:id", deleteCoverageEligibilityResponseRoute);
 
 // src/data/rest-api/routes/data/detectedissue/detectedissue.ts
-var import_express39 = __toESM(require("express"));
+var import_express40 = __toESM(require("express"));
 
 // src/data/operations/data/detectedissue/detectedissue-create-operation.ts
 var import_ulid33 = require("ulid");
@@ -12224,15 +12571,15 @@ async function updateDetectedIssueRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/detectedissue/detectedissue.ts
-var router39 = import_express39.default.Router();
-router39.get("/", listDetectedIssuesRoute);
-router39.get("/:id", getDetectedIssueByIdRoute);
-router39.post("/", createDetectedIssueRoute);
-router39.put("/:id", updateDetectedIssueRoute);
-router39.delete("/:id", deleteDetectedIssueRoute);
+var router40 = import_express40.default.Router();
+router40.get("/", listDetectedIssuesRoute);
+router40.get("/:id", getDetectedIssueByIdRoute);
+router40.post("/", createDetectedIssueRoute);
+router40.put("/:id", updateDetectedIssueRoute);
+router40.delete("/:id", deleteDetectedIssueRoute);
 
 // src/data/rest-api/routes/data/device/device.ts
-var import_express40 = __toESM(require("express"));
+var import_express41 = __toESM(require("express"));
 
 // src/data/operations/data/device/device-create-operation.ts
 var import_ulid34 = require("ulid");
@@ -12424,15 +12771,15 @@ async function updateDeviceRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/device/device.ts
-var router40 = import_express40.default.Router();
-router40.get("/", listDevicesRoute);
-router40.get("/:id", getDeviceByIdRoute);
-router40.post("/", createDeviceRoute);
-router40.put("/:id", updateDeviceRoute);
-router40.delete("/:id", deleteDeviceRoute);
+var router41 = import_express41.default.Router();
+router41.get("/", listDevicesRoute);
+router41.get("/:id", getDeviceByIdRoute);
+router41.post("/", createDeviceRoute);
+router41.put("/:id", updateDeviceRoute);
+router41.delete("/:id", deleteDeviceRoute);
 
 // src/data/rest-api/routes/data/devicedefinition/devicedefinition.ts
-var import_express41 = __toESM(require("express"));
+var import_express42 = __toESM(require("express"));
 
 // src/data/operations/data/devicedefinition/devicedefinition-create-operation.ts
 var import_ulid35 = require("ulid");
@@ -12624,15 +12971,15 @@ async function updateDeviceDefinitionRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/devicedefinition/devicedefinition.ts
-var router41 = import_express41.default.Router();
-router41.get("/", listDeviceDefinitionsRoute);
-router41.get("/:id", getDeviceDefinitionByIdRoute);
-router41.post("/", createDeviceDefinitionRoute);
-router41.put("/:id", updateDeviceDefinitionRoute);
-router41.delete("/:id", deleteDeviceDefinitionRoute);
+var router42 = import_express42.default.Router();
+router42.get("/", listDeviceDefinitionsRoute);
+router42.get("/:id", getDeviceDefinitionByIdRoute);
+router42.post("/", createDeviceDefinitionRoute);
+router42.put("/:id", updateDeviceDefinitionRoute);
+router42.delete("/:id", deleteDeviceDefinitionRoute);
 
 // src/data/rest-api/routes/data/devicemetric/devicemetric.ts
-var import_express42 = __toESM(require("express"));
+var import_express43 = __toESM(require("express"));
 
 // src/data/operations/data/devicemetric/devicemetric-create-operation.ts
 var import_ulid36 = require("ulid");
@@ -12824,15 +13171,15 @@ async function updateDeviceMetricRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/devicemetric/devicemetric.ts
-var router42 = import_express42.default.Router();
-router42.get("/", listDeviceMetricsRoute);
-router42.get("/:id", getDeviceMetricByIdRoute);
-router42.post("/", createDeviceMetricRoute);
-router42.put("/:id", updateDeviceMetricRoute);
-router42.delete("/:id", deleteDeviceMetricRoute);
+var router43 = import_express43.default.Router();
+router43.get("/", listDeviceMetricsRoute);
+router43.get("/:id", getDeviceMetricByIdRoute);
+router43.post("/", createDeviceMetricRoute);
+router43.put("/:id", updateDeviceMetricRoute);
+router43.delete("/:id", deleteDeviceMetricRoute);
 
 // src/data/rest-api/routes/data/devicerequest/devicerequest.ts
-var import_express43 = __toESM(require("express"));
+var import_express44 = __toESM(require("express"));
 
 // src/data/operations/data/devicerequest/devicerequest-create-operation.ts
 var import_ulid37 = require("ulid");
@@ -13024,15 +13371,15 @@ async function updateDeviceRequestRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/devicerequest/devicerequest.ts
-var router43 = import_express43.default.Router();
-router43.get("/", listDeviceRequestsRoute);
-router43.get("/:id", getDeviceRequestByIdRoute);
-router43.post("/", createDeviceRequestRoute);
-router43.put("/:id", updateDeviceRequestRoute);
-router43.delete("/:id", deleteDeviceRequestRoute);
+var router44 = import_express44.default.Router();
+router44.get("/", listDeviceRequestsRoute);
+router44.get("/:id", getDeviceRequestByIdRoute);
+router44.post("/", createDeviceRequestRoute);
+router44.put("/:id", updateDeviceRequestRoute);
+router44.delete("/:id", deleteDeviceRequestRoute);
 
 // src/data/rest-api/routes/data/deviceusestatement/deviceusestatement.ts
-var import_express44 = __toESM(require("express"));
+var import_express45 = __toESM(require("express"));
 
 // src/data/operations/data/deviceusestatement/deviceusestatement-create-operation.ts
 var import_ulid38 = require("ulid");
@@ -13231,15 +13578,15 @@ async function updateDeviceUseStatementRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/deviceusestatement/deviceusestatement.ts
-var router44 = import_express44.default.Router();
-router44.get("/", listDeviceUseStatementsRoute);
-router44.get("/:id", getDeviceUseStatementByIdRoute);
-router44.post("/", createDeviceUseStatementRoute);
-router44.put("/:id", updateDeviceUseStatementRoute);
-router44.delete("/:id", deleteDeviceUseStatementRoute);
+var router45 = import_express45.default.Router();
+router45.get("/", listDeviceUseStatementsRoute);
+router45.get("/:id", getDeviceUseStatementByIdRoute);
+router45.post("/", createDeviceUseStatementRoute);
+router45.put("/:id", updateDeviceUseStatementRoute);
+router45.delete("/:id", deleteDeviceUseStatementRoute);
 
 // src/data/rest-api/routes/data/diagnosticreport/diagnosticreport.ts
-var import_express45 = __toESM(require("express"));
+var import_express46 = __toESM(require("express"));
 
 // src/data/operations/data/diagnosticreport/diagnosticreport-create-operation.ts
 var import_ulid39 = require("ulid");
@@ -13431,15 +13778,15 @@ async function updateDiagnosticReportRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/diagnosticreport/diagnosticreport.ts
-var router45 = import_express45.default.Router();
-router45.get("/", listDiagnosticReportsRoute);
-router45.get("/:id", getDiagnosticReportByIdRoute);
-router45.post("/", createDiagnosticReportRoute);
-router45.put("/:id", updateDiagnosticReportRoute);
-router45.delete("/:id", deleteDiagnosticReportRoute);
+var router46 = import_express46.default.Router();
+router46.get("/", listDiagnosticReportsRoute);
+router46.get("/:id", getDiagnosticReportByIdRoute);
+router46.post("/", createDiagnosticReportRoute);
+router46.put("/:id", updateDiagnosticReportRoute);
+router46.delete("/:id", deleteDiagnosticReportRoute);
 
 // src/data/rest-api/routes/data/documentmanifest/documentmanifest.ts
-var import_express46 = __toESM(require("express"));
+var import_express47 = __toESM(require("express"));
 
 // src/data/operations/data/documentmanifest/documentmanifest-create-operation.ts
 var import_ulid40 = require("ulid");
@@ -13631,15 +13978,15 @@ async function updateDocumentManifestRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/documentmanifest/documentmanifest.ts
-var router46 = import_express46.default.Router();
-router46.get("/", listDocumentManifestsRoute);
-router46.get("/:id", getDocumentManifestByIdRoute);
-router46.post("/", createDocumentManifestRoute);
-router46.put("/:id", updateDocumentManifestRoute);
-router46.delete("/:id", deleteDocumentManifestRoute);
+var router47 = import_express47.default.Router();
+router47.get("/", listDocumentManifestsRoute);
+router47.get("/:id", getDocumentManifestByIdRoute);
+router47.post("/", createDocumentManifestRoute);
+router47.put("/:id", updateDocumentManifestRoute);
+router47.delete("/:id", deleteDocumentManifestRoute);
 
 // src/data/rest-api/routes/data/documentreference/documentreference.ts
-var import_express47 = __toESM(require("express"));
+var import_express48 = __toESM(require("express"));
 
 // src/data/operations/data/documentreference/documentreference-create-operation.ts
 var import_ulid41 = require("ulid");
@@ -13834,15 +14181,15 @@ async function updateDocumentReferenceRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/documentreference/documentreference.ts
-var router47 = import_express47.default.Router();
-router47.get("/", listDocumentReferencesRoute);
-router47.get("/:id", getDocumentReferenceByIdRoute);
-router47.post("/", createDocumentReferenceRoute);
-router47.put("/:id", updateDocumentReferenceRoute);
-router47.delete("/:id", deleteDocumentReferenceRoute);
+var router48 = import_express48.default.Router();
+router48.get("/", listDocumentReferencesRoute);
+router48.get("/:id", getDocumentReferenceByIdRoute);
+router48.post("/", createDocumentReferenceRoute);
+router48.put("/:id", updateDocumentReferenceRoute);
+router48.delete("/:id", deleteDocumentReferenceRoute);
 
 // src/data/rest-api/routes/data/effectevidencesynthesis/effectevidencesynthesis.ts
-var import_express48 = __toESM(require("express"));
+var import_express49 = __toESM(require("express"));
 
 // src/data/operations/data/effectevidencesynthesis/effectevidencesynthesis-create-operation.ts
 var import_ulid42 = require("ulid");
@@ -14053,15 +14400,15 @@ async function updateEffectEvidenceSynthesisRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/effectevidencesynthesis/effectevidencesynthesis.ts
-var router48 = import_express48.default.Router();
-router48.get("/", listEffectEvidenceSynthesissRoute);
-router48.get("/:id", getEffectEvidenceSynthesisByIdRoute);
-router48.post("/", createEffectEvidenceSynthesisRoute);
-router48.put("/:id", updateEffectEvidenceSynthesisRoute);
-router48.delete("/:id", deleteEffectEvidenceSynthesisRoute);
+var router49 = import_express49.default.Router();
+router49.get("/", listEffectEvidenceSynthesissRoute);
+router49.get("/:id", getEffectEvidenceSynthesisByIdRoute);
+router49.post("/", createEffectEvidenceSynthesisRoute);
+router49.put("/:id", updateEffectEvidenceSynthesisRoute);
+router49.delete("/:id", deleteEffectEvidenceSynthesisRoute);
 
 // src/data/rest-api/routes/data/encounter/encounter.ts
-var import_express49 = __toESM(require("express"));
+var import_express50 = __toESM(require("express"));
 
 // src/data/operations/data/encounter/encounter-create-operation.ts
 var import_ulid43 = require("ulid");
@@ -14483,15 +14830,15 @@ async function updateEncounterRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/encounter/encounter.ts
-var router49 = import_express49.default.Router();
-router49.get("/", listEncountersRoute);
-router49.get("/:id", getEncounterByIdRoute);
-router49.post("/", createEncounterRoute);
-router49.put("/:id", updateEncounterRoute);
-router49.delete("/:id", deleteEncounterRoute);
+var router50 = import_express50.default.Router();
+router50.get("/", listEncountersRoute);
+router50.get("/:id", getEncounterByIdRoute);
+router50.post("/", createEncounterRoute);
+router50.put("/:id", updateEncounterRoute);
+router50.delete("/:id", deleteEncounterRoute);
 
 // src/data/rest-api/routes/data/endpoint/endpoint.ts
-var import_express50 = __toESM(require("express"));
+var import_express51 = __toESM(require("express"));
 
 // src/data/operations/data/endpoint/endpoint-create-operation.ts
 var import_ulid44 = require("ulid");
@@ -14683,15 +15030,15 @@ async function updateEndpointRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/endpoint/endpoint.ts
-var router50 = import_express50.default.Router();
-router50.get("/", listEndpointsRoute);
-router50.get("/:id", getEndpointByIdRoute);
-router50.post("/", createEndpointRoute);
-router50.put("/:id", updateEndpointRoute);
-router50.delete("/:id", deleteEndpointRoute);
+var router51 = import_express51.default.Router();
+router51.get("/", listEndpointsRoute);
+router51.get("/:id", getEndpointByIdRoute);
+router51.post("/", createEndpointRoute);
+router51.put("/:id", updateEndpointRoute);
+router51.delete("/:id", deleteEndpointRoute);
 
 // src/data/rest-api/routes/data/enrollmentrequest/enrollmentrequest.ts
-var import_express51 = __toESM(require("express"));
+var import_express52 = __toESM(require("express"));
 
 // src/data/operations/data/enrollmentrequest/enrollmentrequest-create-operation.ts
 var import_ulid45 = require("ulid");
@@ -14886,15 +15233,15 @@ async function updateEnrollmentRequestRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/enrollmentrequest/enrollmentrequest.ts
-var router51 = import_express51.default.Router();
-router51.get("/", listEnrollmentRequestsRoute);
-router51.get("/:id", getEnrollmentRequestByIdRoute);
-router51.post("/", createEnrollmentRequestRoute);
-router51.put("/:id", updateEnrollmentRequestRoute);
-router51.delete("/:id", deleteEnrollmentRequestRoute);
+var router52 = import_express52.default.Router();
+router52.get("/", listEnrollmentRequestsRoute);
+router52.get("/:id", getEnrollmentRequestByIdRoute);
+router52.post("/", createEnrollmentRequestRoute);
+router52.put("/:id", updateEnrollmentRequestRoute);
+router52.delete("/:id", deleteEnrollmentRequestRoute);
 
 // src/data/rest-api/routes/data/enrollmentresponse/enrollmentresponse.ts
-var import_express52 = __toESM(require("express"));
+var import_express53 = __toESM(require("express"));
 
 // src/data/operations/data/enrollmentresponse/enrollmentresponse-create-operation.ts
 var import_ulid46 = require("ulid");
@@ -15093,15 +15440,15 @@ async function updateEnrollmentResponseRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/enrollmentresponse/enrollmentresponse.ts
-var router52 = import_express52.default.Router();
-router52.get("/", listEnrollmentResponsesRoute);
-router52.get("/:id", getEnrollmentResponseByIdRoute);
-router52.post("/", createEnrollmentResponseRoute);
-router52.put("/:id", updateEnrollmentResponseRoute);
-router52.delete("/:id", deleteEnrollmentResponseRoute);
+var router53 = import_express53.default.Router();
+router53.get("/", listEnrollmentResponsesRoute);
+router53.get("/:id", getEnrollmentResponseByIdRoute);
+router53.post("/", createEnrollmentResponseRoute);
+router53.put("/:id", updateEnrollmentResponseRoute);
+router53.delete("/:id", deleteEnrollmentResponseRoute);
 
 // src/data/rest-api/routes/data/episodeofcare/episodeofcare.ts
-var import_express53 = __toESM(require("express"));
+var import_express54 = __toESM(require("express"));
 
 // src/data/operations/data/episodeofcare/episodeofcare-create-operation.ts
 var import_ulid47 = require("ulid");
@@ -15293,15 +15640,15 @@ async function updateEpisodeOfCareRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/episodeofcare/episodeofcare.ts
-var router53 = import_express53.default.Router();
-router53.get("/", listEpisodeOfCaresRoute);
-router53.get("/:id", getEpisodeOfCareByIdRoute);
-router53.post("/", createEpisodeOfCareRoute);
-router53.put("/:id", updateEpisodeOfCareRoute);
-router53.delete("/:id", deleteEpisodeOfCareRoute);
+var router54 = import_express54.default.Router();
+router54.get("/", listEpisodeOfCaresRoute);
+router54.get("/:id", getEpisodeOfCareByIdRoute);
+router54.post("/", createEpisodeOfCareRoute);
+router54.put("/:id", updateEpisodeOfCareRoute);
+router54.delete("/:id", deleteEpisodeOfCareRoute);
 
 // src/data/rest-api/routes/data/eventdefinition/eventdefinition.ts
-var import_express54 = __toESM(require("express"));
+var import_express55 = __toESM(require("express"));
 
 // src/data/operations/data/eventdefinition/eventdefinition-create-operation.ts
 var import_ulid48 = require("ulid");
@@ -15493,15 +15840,15 @@ async function updateEventDefinitionRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/eventdefinition/eventdefinition.ts
-var router54 = import_express54.default.Router();
-router54.get("/", listEventDefinitionsRoute);
-router54.get("/:id", getEventDefinitionByIdRoute);
-router54.post("/", createEventDefinitionRoute);
-router54.put("/:id", updateEventDefinitionRoute);
-router54.delete("/:id", deleteEventDefinitionRoute);
+var router55 = import_express55.default.Router();
+router55.get("/", listEventDefinitionsRoute);
+router55.get("/:id", getEventDefinitionByIdRoute);
+router55.post("/", createEventDefinitionRoute);
+router55.put("/:id", updateEventDefinitionRoute);
+router55.delete("/:id", deleteEventDefinitionRoute);
 
 // src/data/rest-api/routes/data/evidence/evidence.ts
-var import_express55 = __toESM(require("express"));
+var import_express56 = __toESM(require("express"));
 
 // src/data/operations/data/evidence/evidence-create-operation.ts
 var import_ulid49 = require("ulid");
@@ -15693,15 +16040,15 @@ async function updateEvidenceRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/evidence/evidence.ts
-var router55 = import_express55.default.Router();
-router55.get("/", listEvidencesRoute);
-router55.get("/:id", getEvidenceByIdRoute);
-router55.post("/", createEvidenceRoute);
-router55.put("/:id", updateEvidenceRoute);
-router55.delete("/:id", deleteEvidenceRoute);
+var router56 = import_express56.default.Router();
+router56.get("/", listEvidencesRoute);
+router56.get("/:id", getEvidenceByIdRoute);
+router56.post("/", createEvidenceRoute);
+router56.put("/:id", updateEvidenceRoute);
+router56.delete("/:id", deleteEvidenceRoute);
 
 // src/data/rest-api/routes/data/evidencevariable/evidencevariable.ts
-var import_express56 = __toESM(require("express"));
+var import_express57 = __toESM(require("express"));
 
 // src/data/operations/data/evidencevariable/evidencevariable-create-operation.ts
 var import_ulid50 = require("ulid");
@@ -15893,15 +16240,15 @@ async function updateEvidenceVariableRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/evidencevariable/evidencevariable.ts
-var router56 = import_express56.default.Router();
-router56.get("/", listEvidenceVariablesRoute);
-router56.get("/:id", getEvidenceVariableByIdRoute);
-router56.post("/", createEvidenceVariableRoute);
-router56.put("/:id", updateEvidenceVariableRoute);
-router56.delete("/:id", deleteEvidenceVariableRoute);
+var router57 = import_express57.default.Router();
+router57.get("/", listEvidenceVariablesRoute);
+router57.get("/:id", getEvidenceVariableByIdRoute);
+router57.post("/", createEvidenceVariableRoute);
+router57.put("/:id", updateEvidenceVariableRoute);
+router57.delete("/:id", deleteEvidenceVariableRoute);
 
 // src/data/rest-api/routes/data/examplescenario/examplescenario.ts
-var import_express57 = __toESM(require("express"));
+var import_express58 = __toESM(require("express"));
 
 // src/data/operations/data/examplescenario/examplescenario-create-operation.ts
 var import_ulid51 = require("ulid");
@@ -16093,15 +16440,15 @@ async function updateExampleScenarioRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/examplescenario/examplescenario.ts
-var router57 = import_express57.default.Router();
-router57.get("/", listExampleScenariosRoute);
-router57.get("/:id", getExampleScenarioByIdRoute);
-router57.post("/", createExampleScenarioRoute);
-router57.put("/:id", updateExampleScenarioRoute);
-router57.delete("/:id", deleteExampleScenarioRoute);
+var router58 = import_express58.default.Router();
+router58.get("/", listExampleScenariosRoute);
+router58.get("/:id", getExampleScenarioByIdRoute);
+router58.post("/", createExampleScenarioRoute);
+router58.put("/:id", updateExampleScenarioRoute);
+router58.delete("/:id", deleteExampleScenarioRoute);
 
 // src/data/rest-api/routes/data/explanationofbenefit/explanationofbenefit.ts
-var import_express58 = __toESM(require("express"));
+var import_express59 = __toESM(require("express"));
 
 // src/data/operations/data/explanationofbenefit/explanationofbenefit-create-operation.ts
 var import_ulid52 = require("ulid");
@@ -16304,15 +16651,15 @@ async function updateExplanationOfBenefitRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/explanationofbenefit/explanationofbenefit.ts
-var router58 = import_express58.default.Router();
-router58.get("/", listExplanationOfBenefitsRoute);
-router58.get("/:id", getExplanationOfBenefitByIdRoute);
-router58.post("/", createExplanationOfBenefitRoute);
-router58.put("/:id", updateExplanationOfBenefitRoute);
-router58.delete("/:id", deleteExplanationOfBenefitRoute);
+var router59 = import_express59.default.Router();
+router59.get("/", listExplanationOfBenefitsRoute);
+router59.get("/:id", getExplanationOfBenefitByIdRoute);
+router59.post("/", createExplanationOfBenefitRoute);
+router59.put("/:id", updateExplanationOfBenefitRoute);
+router59.delete("/:id", deleteExplanationOfBenefitRoute);
 
 // src/data/rest-api/routes/data/familymemberhistory/familymemberhistory.ts
-var import_express59 = __toESM(require("express"));
+var import_express60 = __toESM(require("express"));
 
 // src/data/operations/data/familymemberhistory/familymemberhistory-create-operation.ts
 var import_ulid53 = require("ulid");
@@ -16511,15 +16858,15 @@ async function updateFamilyMemberHistoryRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/familymemberhistory/familymemberhistory.ts
-var router59 = import_express59.default.Router();
-router59.get("/", listFamilyMemberHistorysRoute);
-router59.get("/:id", getFamilyMemberHistoryByIdRoute);
-router59.post("/", createFamilyMemberHistoryRoute);
-router59.put("/:id", updateFamilyMemberHistoryRoute);
-router59.delete("/:id", deleteFamilyMemberHistoryRoute);
+var router60 = import_express60.default.Router();
+router60.get("/", listFamilyMemberHistorysRoute);
+router60.get("/:id", getFamilyMemberHistoryByIdRoute);
+router60.post("/", createFamilyMemberHistoryRoute);
+router60.put("/:id", updateFamilyMemberHistoryRoute);
+router60.delete("/:id", deleteFamilyMemberHistoryRoute);
 
 // src/data/rest-api/routes/data/flag/flag.ts
-var import_express60 = __toESM(require("express"));
+var import_express61 = __toESM(require("express"));
 
 // src/data/operations/data/flag/flag-create-operation.ts
 var import_ulid54 = require("ulid");
@@ -16711,15 +17058,15 @@ async function updateFlagRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/flag/flag.ts
-var router60 = import_express60.default.Router();
-router60.get("/", listFlagsRoute);
-router60.get("/:id", getFlagByIdRoute);
-router60.post("/", createFlagRoute);
-router60.put("/:id", updateFlagRoute);
-router60.delete("/:id", deleteFlagRoute);
+var router61 = import_express61.default.Router();
+router61.get("/", listFlagsRoute);
+router61.get("/:id", getFlagByIdRoute);
+router61.post("/", createFlagRoute);
+router61.put("/:id", updateFlagRoute);
+router61.delete("/:id", deleteFlagRoute);
 
 // src/data/rest-api/routes/data/goal/goal.ts
-var import_express61 = __toESM(require("express"));
+var import_express62 = __toESM(require("express"));
 
 // src/data/operations/data/goal/goal-create-operation.ts
 var import_ulid55 = require("ulid");
@@ -16911,15 +17258,15 @@ async function updateGoalRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/goal/goal.ts
-var router61 = import_express61.default.Router();
-router61.get("/", listGoalsRoute);
-router61.get("/:id", getGoalByIdRoute);
-router61.post("/", createGoalRoute);
-router61.put("/:id", updateGoalRoute);
-router61.delete("/:id", deleteGoalRoute);
+var router62 = import_express62.default.Router();
+router62.get("/", listGoalsRoute);
+router62.get("/:id", getGoalByIdRoute);
+router62.post("/", createGoalRoute);
+router62.put("/:id", updateGoalRoute);
+router62.delete("/:id", deleteGoalRoute);
 
 // src/data/rest-api/routes/data/graphdefinition/graphdefinition.ts
-var import_express62 = __toESM(require("express"));
+var import_express63 = __toESM(require("express"));
 
 // src/data/operations/data/graphdefinition/graphdefinition-create-operation.ts
 var import_ulid56 = require("ulid");
@@ -17111,15 +17458,15 @@ async function updateGraphDefinitionRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/graphdefinition/graphdefinition.ts
-var router62 = import_express62.default.Router();
-router62.get("/", listGraphDefinitionsRoute);
-router62.get("/:id", getGraphDefinitionByIdRoute);
-router62.post("/", createGraphDefinitionRoute);
-router62.put("/:id", updateGraphDefinitionRoute);
-router62.delete("/:id", deleteGraphDefinitionRoute);
+var router63 = import_express63.default.Router();
+router63.get("/", listGraphDefinitionsRoute);
+router63.get("/:id", getGraphDefinitionByIdRoute);
+router63.post("/", createGraphDefinitionRoute);
+router63.put("/:id", updateGraphDefinitionRoute);
+router63.delete("/:id", deleteGraphDefinitionRoute);
 
 // src/data/rest-api/routes/data/group/group.ts
-var import_express63 = __toESM(require("express"));
+var import_express64 = __toESM(require("express"));
 
 // src/data/operations/data/group/group-create-operation.ts
 var import_ulid57 = require("ulid");
@@ -17311,15 +17658,15 @@ async function updateGroupRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/group/group.ts
-var router63 = import_express63.default.Router();
-router63.get("/", listGroupsRoute);
-router63.get("/:id", getGroupByIdRoute);
-router63.post("/", createGroupRoute);
-router63.put("/:id", updateGroupRoute);
-router63.delete("/:id", deleteGroupRoute);
+var router64 = import_express64.default.Router();
+router64.get("/", listGroupsRoute);
+router64.get("/:id", getGroupByIdRoute);
+router64.post("/", createGroupRoute);
+router64.put("/:id", updateGroupRoute);
+router64.delete("/:id", deleteGroupRoute);
 
 // src/data/rest-api/routes/data/guidanceresponse/guidanceresponse.ts
-var import_express64 = __toESM(require("express"));
+var import_express65 = __toESM(require("express"));
 
 // src/data/operations/data/guidanceresponse/guidanceresponse-create-operation.ts
 var import_ulid58 = require("ulid");
@@ -17511,15 +17858,15 @@ async function updateGuidanceResponseRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/guidanceresponse/guidanceresponse.ts
-var router64 = import_express64.default.Router();
-router64.get("/", listGuidanceResponsesRoute);
-router64.get("/:id", getGuidanceResponseByIdRoute);
-router64.post("/", createGuidanceResponseRoute);
-router64.put("/:id", updateGuidanceResponseRoute);
-router64.delete("/:id", deleteGuidanceResponseRoute);
+var router65 = import_express65.default.Router();
+router65.get("/", listGuidanceResponsesRoute);
+router65.get("/:id", getGuidanceResponseByIdRoute);
+router65.post("/", createGuidanceResponseRoute);
+router65.put("/:id", updateGuidanceResponseRoute);
+router65.delete("/:id", deleteGuidanceResponseRoute);
 
 // src/data/rest-api/routes/data/healthcareservice/healthcareservice.ts
-var import_express65 = __toESM(require("express"));
+var import_express66 = __toESM(require("express"));
 
 // src/data/operations/data/healthcareservice/healthcareservice-create-operation.ts
 var import_ulid59 = require("ulid");
@@ -17714,15 +18061,15 @@ async function updateHealthcareServiceRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/healthcareservice/healthcareservice.ts
-var router65 = import_express65.default.Router();
-router65.get("/", listHealthcareServicesRoute);
-router65.get("/:id", getHealthcareServiceByIdRoute);
-router65.post("/", createHealthcareServiceRoute);
-router65.put("/:id", updateHealthcareServiceRoute);
-router65.delete("/:id", deleteHealthcareServiceRoute);
+var router66 = import_express66.default.Router();
+router66.get("/", listHealthcareServicesRoute);
+router66.get("/:id", getHealthcareServiceByIdRoute);
+router66.post("/", createHealthcareServiceRoute);
+router66.put("/:id", updateHealthcareServiceRoute);
+router66.delete("/:id", deleteHealthcareServiceRoute);
 
 // src/data/rest-api/routes/data/imagingstudy/imagingstudy.ts
-var import_express66 = __toESM(require("express"));
+var import_express67 = __toESM(require("express"));
 
 // src/data/operations/data/imagingstudy/imagingstudy-create-operation.ts
 var import_ulid60 = require("ulid");
@@ -17914,15 +18261,15 @@ async function updateImagingStudyRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/imagingstudy/imagingstudy.ts
-var router66 = import_express66.default.Router();
-router66.get("/", listImagingStudysRoute);
-router66.get("/:id", getImagingStudyByIdRoute);
-router66.post("/", createImagingStudyRoute);
-router66.put("/:id", updateImagingStudyRoute);
-router66.delete("/:id", deleteImagingStudyRoute);
+var router67 = import_express67.default.Router();
+router67.get("/", listImagingStudysRoute);
+router67.get("/:id", getImagingStudyByIdRoute);
+router67.post("/", createImagingStudyRoute);
+router67.put("/:id", updateImagingStudyRoute);
+router67.delete("/:id", deleteImagingStudyRoute);
 
 // src/data/rest-api/routes/data/immunization/immunization.ts
-var import_express67 = __toESM(require("express"));
+var import_express68 = __toESM(require("express"));
 
 // src/data/operations/data/immunization/immunization-create-operation.ts
 var import_ulid61 = require("ulid");
@@ -18114,15 +18461,15 @@ async function updateImmunizationRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/immunization/immunization.ts
-var router67 = import_express67.default.Router();
-router67.get("/", listImmunizationsRoute);
-router67.get("/:id", getImmunizationByIdRoute);
-router67.post("/", createImmunizationRoute);
-router67.put("/:id", updateImmunizationRoute);
-router67.delete("/:id", deleteImmunizationRoute);
+var router68 = import_express68.default.Router();
+router68.get("/", listImmunizationsRoute);
+router68.get("/:id", getImmunizationByIdRoute);
+router68.post("/", createImmunizationRoute);
+router68.put("/:id", updateImmunizationRoute);
+router68.delete("/:id", deleteImmunizationRoute);
 
 // src/data/rest-api/routes/data/immunizationevaluation/immunizationevaluation.ts
-var import_express68 = __toESM(require("express"));
+var import_express69 = __toESM(require("express"));
 
 // src/data/operations/data/immunizationevaluation/immunizationevaluation-create-operation.ts
 var import_ulid62 = require("ulid");
@@ -18333,15 +18680,15 @@ async function updateImmunizationEvaluationRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/immunizationevaluation/immunizationevaluation.ts
-var router68 = import_express68.default.Router();
-router68.get("/", listImmunizationEvaluationsRoute);
-router68.get("/:id", getImmunizationEvaluationByIdRoute);
-router68.post("/", createImmunizationEvaluationRoute);
-router68.put("/:id", updateImmunizationEvaluationRoute);
-router68.delete("/:id", deleteImmunizationEvaluationRoute);
+var router69 = import_express69.default.Router();
+router69.get("/", listImmunizationEvaluationsRoute);
+router69.get("/:id", getImmunizationEvaluationByIdRoute);
+router69.post("/", createImmunizationEvaluationRoute);
+router69.put("/:id", updateImmunizationEvaluationRoute);
+router69.delete("/:id", deleteImmunizationEvaluationRoute);
 
 // src/data/rest-api/routes/data/immunizationrecommendation/immunizationrecommendation.ts
-var import_express69 = __toESM(require("express"));
+var import_express70 = __toESM(require("express"));
 
 // src/data/operations/data/immunizationrecommendation/immunizationrecommendation-create-operation.ts
 var import_ulid63 = require("ulid");
@@ -18552,15 +18899,15 @@ async function updateImmunizationRecommendationRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/immunizationrecommendation/immunizationrecommendation.ts
-var router69 = import_express69.default.Router();
-router69.get("/", listImmunizationRecommendationsRoute);
-router69.get("/:id", getImmunizationRecommendationByIdRoute);
-router69.post("/", createImmunizationRecommendationRoute);
-router69.put("/:id", updateImmunizationRecommendationRoute);
-router69.delete("/:id", deleteImmunizationRecommendationRoute);
+var router70 = import_express70.default.Router();
+router70.get("/", listImmunizationRecommendationsRoute);
+router70.get("/:id", getImmunizationRecommendationByIdRoute);
+router70.post("/", createImmunizationRecommendationRoute);
+router70.put("/:id", updateImmunizationRecommendationRoute);
+router70.delete("/:id", deleteImmunizationRecommendationRoute);
 
 // src/data/rest-api/routes/data/implementationguide/implementationguide.ts
-var import_express70 = __toESM(require("express"));
+var import_express71 = __toESM(require("express"));
 
 // src/data/operations/data/implementationguide/implementationguide-create-operation.ts
 var import_ulid64 = require("ulid");
@@ -18759,15 +19106,15 @@ async function updateImplementationGuideRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/implementationguide/implementationguide.ts
-var router70 = import_express70.default.Router();
-router70.get("/", listImplementationGuidesRoute);
-router70.get("/:id", getImplementationGuideByIdRoute);
-router70.post("/", createImplementationGuideRoute);
-router70.put("/:id", updateImplementationGuideRoute);
-router70.delete("/:id", deleteImplementationGuideRoute);
+var router71 = import_express71.default.Router();
+router71.get("/", listImplementationGuidesRoute);
+router71.get("/:id", getImplementationGuideByIdRoute);
+router71.post("/", createImplementationGuideRoute);
+router71.put("/:id", updateImplementationGuideRoute);
+router71.delete("/:id", deleteImplementationGuideRoute);
 
 // src/data/rest-api/routes/data/insuranceplan/insuranceplan.ts
-var import_express71 = __toESM(require("express"));
+var import_express72 = __toESM(require("express"));
 
 // src/data/operations/data/insuranceplan/insuranceplan-create-operation.ts
 var import_ulid65 = require("ulid");
@@ -18959,15 +19306,15 @@ async function updateInsurancePlanRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/insuranceplan/insuranceplan.ts
-var router71 = import_express71.default.Router();
-router71.get("/", listInsurancePlansRoute);
-router71.get("/:id", getInsurancePlanByIdRoute);
-router71.post("/", createInsurancePlanRoute);
-router71.put("/:id", updateInsurancePlanRoute);
-router71.delete("/:id", deleteInsurancePlanRoute);
+var router72 = import_express72.default.Router();
+router72.get("/", listInsurancePlansRoute);
+router72.get("/:id", getInsurancePlanByIdRoute);
+router72.post("/", createInsurancePlanRoute);
+router72.put("/:id", updateInsurancePlanRoute);
+router72.delete("/:id", deleteInsurancePlanRoute);
 
 // src/data/rest-api/routes/data/invoice/invoice.ts
-var import_express72 = __toESM(require("express"));
+var import_express73 = __toESM(require("express"));
 
 // src/data/operations/data/invoice/invoice-create-operation.ts
 var import_ulid66 = require("ulid");
@@ -19159,15 +19506,15 @@ async function updateInvoiceRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/invoice/invoice.ts
-var router72 = import_express72.default.Router();
-router72.get("/", listInvoicesRoute);
-router72.get("/:id", getInvoiceByIdRoute);
-router72.post("/", createInvoiceRoute);
-router72.put("/:id", updateInvoiceRoute);
-router72.delete("/:id", deleteInvoiceRoute);
+var router73 = import_express73.default.Router();
+router73.get("/", listInvoicesRoute);
+router73.get("/:id", getInvoiceByIdRoute);
+router73.post("/", createInvoiceRoute);
+router73.put("/:id", updateInvoiceRoute);
+router73.delete("/:id", deleteInvoiceRoute);
 
 // src/data/rest-api/routes/data/library/library.ts
-var import_express73 = __toESM(require("express"));
+var import_express74 = __toESM(require("express"));
 
 // src/data/operations/data/library/library-create-operation.ts
 var import_ulid67 = require("ulid");
@@ -19359,15 +19706,15 @@ async function updateLibraryRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/library/library.ts
-var router73 = import_express73.default.Router();
-router73.get("/", listLibrarysRoute);
-router73.get("/:id", getLibraryByIdRoute);
-router73.post("/", createLibraryRoute);
-router73.put("/:id", updateLibraryRoute);
-router73.delete("/:id", deleteLibraryRoute);
+var router74 = import_express74.default.Router();
+router74.get("/", listLibrarysRoute);
+router74.get("/:id", getLibraryByIdRoute);
+router74.post("/", createLibraryRoute);
+router74.put("/:id", updateLibraryRoute);
+router74.delete("/:id", deleteLibraryRoute);
 
 // src/data/rest-api/routes/data/linkage/linkage.ts
-var import_express74 = __toESM(require("express"));
+var import_express75 = __toESM(require("express"));
 
 // src/data/operations/data/linkage/linkage-create-operation.ts
 var import_ulid68 = require("ulid");
@@ -19559,15 +19906,15 @@ async function updateLinkageRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/linkage/linkage.ts
-var router74 = import_express74.default.Router();
-router74.get("/", listLinkagesRoute);
-router74.get("/:id", getLinkageByIdRoute);
-router74.post("/", createLinkageRoute);
-router74.put("/:id", updateLinkageRoute);
-router74.delete("/:id", deleteLinkageRoute);
+var router75 = import_express75.default.Router();
+router75.get("/", listLinkagesRoute);
+router75.get("/:id", getLinkageByIdRoute);
+router75.post("/", createLinkageRoute);
+router75.put("/:id", updateLinkageRoute);
+router75.delete("/:id", deleteLinkageRoute);
 
 // src/data/rest-api/routes/data/list/list.ts
-var import_express75 = __toESM(require("express"));
+var import_express76 = __toESM(require("express"));
 
 // src/data/operations/data/list/list-create-operation.ts
 var import_ulid69 = require("ulid");
@@ -19759,15 +20106,15 @@ async function updateListRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/list/list.ts
-var router75 = import_express75.default.Router();
-router75.get("/", listListsRoute);
-router75.get("/:id", getListByIdRoute);
-router75.post("/", createListRoute);
-router75.put("/:id", updateListRoute);
-router75.delete("/:id", deleteListRoute);
+var router76 = import_express76.default.Router();
+router76.get("/", listListsRoute);
+router76.get("/:id", getListByIdRoute);
+router76.post("/", createListRoute);
+router76.put("/:id", updateListRoute);
+router76.delete("/:id", deleteListRoute);
 
 // src/data/rest-api/routes/data/location/location.ts
-var import_express76 = __toESM(require("express"));
+var import_express77 = __toESM(require("express"));
 
 // src/data/operations/data/location/location-create-operation.ts
 var import_ulid70 = require("ulid");
@@ -19959,15 +20306,15 @@ async function updateLocationRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/location/location.ts
-var router76 = import_express76.default.Router();
-router76.get("/", listLocationsRoute);
-router76.get("/:id", getLocationByIdRoute);
-router76.post("/", createLocationRoute);
-router76.put("/:id", updateLocationRoute);
-router76.delete("/:id", deleteLocationRoute);
+var router77 = import_express77.default.Router();
+router77.get("/", listLocationsRoute);
+router77.get("/:id", getLocationByIdRoute);
+router77.post("/", createLocationRoute);
+router77.put("/:id", updateLocationRoute);
+router77.delete("/:id", deleteLocationRoute);
 
 // src/data/rest-api/routes/data/measure/measure.ts
-var import_express77 = __toESM(require("express"));
+var import_express78 = __toESM(require("express"));
 
 // src/data/operations/data/measure/measure-create-operation.ts
 var import_ulid71 = require("ulid");
@@ -20159,15 +20506,15 @@ async function updateMeasureRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/measure/measure.ts
-var router77 = import_express77.default.Router();
-router77.get("/", listMeasuresRoute);
-router77.get("/:id", getMeasureByIdRoute);
-router77.post("/", createMeasureRoute);
-router77.put("/:id", updateMeasureRoute);
-router77.delete("/:id", deleteMeasureRoute);
+var router78 = import_express78.default.Router();
+router78.get("/", listMeasuresRoute);
+router78.get("/:id", getMeasureByIdRoute);
+router78.post("/", createMeasureRoute);
+router78.put("/:id", updateMeasureRoute);
+router78.delete("/:id", deleteMeasureRoute);
 
 // src/data/rest-api/routes/data/measurereport/measurereport.ts
-var import_express78 = __toESM(require("express"));
+var import_express79 = __toESM(require("express"));
 
 // src/data/operations/data/measurereport/measurereport-create-operation.ts
 var import_ulid72 = require("ulid");
@@ -20359,15 +20706,15 @@ async function updateMeasureReportRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/measurereport/measurereport.ts
-var router78 = import_express78.default.Router();
-router78.get("/", listMeasureReportsRoute);
-router78.get("/:id", getMeasureReportByIdRoute);
-router78.post("/", createMeasureReportRoute);
-router78.put("/:id", updateMeasureReportRoute);
-router78.delete("/:id", deleteMeasureReportRoute);
+var router79 = import_express79.default.Router();
+router79.get("/", listMeasureReportsRoute);
+router79.get("/:id", getMeasureReportByIdRoute);
+router79.post("/", createMeasureReportRoute);
+router79.put("/:id", updateMeasureReportRoute);
+router79.delete("/:id", deleteMeasureReportRoute);
 
 // src/data/rest-api/routes/data/media/media.ts
-var import_express79 = __toESM(require("express"));
+var import_express80 = __toESM(require("express"));
 
 // src/data/operations/data/media/media-create-operation.ts
 var import_ulid73 = require("ulid");
@@ -20559,15 +20906,15 @@ async function updateMediaRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/media/media.ts
-var router79 = import_express79.default.Router();
-router79.get("/", listMediasRoute);
-router79.get("/:id", getMediaByIdRoute);
-router79.post("/", createMediaRoute);
-router79.put("/:id", updateMediaRoute);
-router79.delete("/:id", deleteMediaRoute);
+var router80 = import_express80.default.Router();
+router80.get("/", listMediasRoute);
+router80.get("/:id", getMediaByIdRoute);
+router80.post("/", createMediaRoute);
+router80.put("/:id", updateMediaRoute);
+router80.delete("/:id", deleteMediaRoute);
 
 // src/data/rest-api/routes/data/medication/medication.ts
-var import_express80 = __toESM(require("express"));
+var import_express81 = __toESM(require("express"));
 
 // src/data/operations/data/medication/medication-create-operation.ts
 var import_ulid74 = require("ulid");
@@ -20759,15 +21106,15 @@ async function updateMedicationRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/medication/medication.ts
-var router80 = import_express80.default.Router();
-router80.get("/", listMedicationsRoute);
-router80.get("/:id", getMedicationByIdRoute);
-router80.post("/", createMedicationRoute);
-router80.put("/:id", updateMedicationRoute);
-router80.delete("/:id", deleteMedicationRoute);
+var router81 = import_express81.default.Router();
+router81.get("/", listMedicationsRoute);
+router81.get("/:id", getMedicationByIdRoute);
+router81.post("/", createMedicationRoute);
+router81.put("/:id", updateMedicationRoute);
+router81.delete("/:id", deleteMedicationRoute);
 
 // src/data/rest-api/routes/data/medicationadministration/medicationadministration.ts
-var import_express81 = __toESM(require("express"));
+var import_express82 = __toESM(require("express"));
 
 // src/data/operations/data/medicationadministration/medicationadministration-create-operation.ts
 var import_ulid75 = require("ulid");
@@ -20978,15 +21325,15 @@ async function updateMedicationAdministrationRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/medicationadministration/medicationadministration.ts
-var router81 = import_express81.default.Router();
-router81.get("/", listMedicationAdministrationsRoute);
-router81.get("/:id", getMedicationAdministrationByIdRoute);
-router81.post("/", createMedicationAdministrationRoute);
-router81.put("/:id", updateMedicationAdministrationRoute);
-router81.delete("/:id", deleteMedicationAdministrationRoute);
+var router82 = import_express82.default.Router();
+router82.get("/", listMedicationAdministrationsRoute);
+router82.get("/:id", getMedicationAdministrationByIdRoute);
+router82.post("/", createMedicationAdministrationRoute);
+router82.put("/:id", updateMedicationAdministrationRoute);
+router82.delete("/:id", deleteMedicationAdministrationRoute);
 
 // src/data/rest-api/routes/data/medicationdispense/medicationdispense.ts
-var import_express82 = __toESM(require("express"));
+var import_express83 = __toESM(require("express"));
 
 // src/data/operations/data/medicationdispense/medicationdispense-create-operation.ts
 var import_ulid76 = require("ulid");
@@ -21185,15 +21532,15 @@ async function updateMedicationDispenseRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/medicationdispense/medicationdispense.ts
-var router82 = import_express82.default.Router();
-router82.get("/", listMedicationDispensesRoute);
-router82.get("/:id", getMedicationDispenseByIdRoute);
-router82.post("/", createMedicationDispenseRoute);
-router82.put("/:id", updateMedicationDispenseRoute);
-router82.delete("/:id", deleteMedicationDispenseRoute);
+var router83 = import_express83.default.Router();
+router83.get("/", listMedicationDispensesRoute);
+router83.get("/:id", getMedicationDispenseByIdRoute);
+router83.post("/", createMedicationDispenseRoute);
+router83.put("/:id", updateMedicationDispenseRoute);
+router83.delete("/:id", deleteMedicationDispenseRoute);
 
 // src/data/rest-api/routes/data/medicationknowledge/medicationknowledge.ts
-var import_express83 = __toESM(require("express"));
+var import_express84 = __toESM(require("express"));
 
 // src/data/operations/data/medicationknowledge/medicationknowledge-create-operation.ts
 var import_ulid77 = require("ulid");
@@ -21392,15 +21739,15 @@ async function updateMedicationKnowledgeRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/medicationknowledge/medicationknowledge.ts
-var router83 = import_express83.default.Router();
-router83.get("/", listMedicationKnowledgesRoute);
-router83.get("/:id", getMedicationKnowledgeByIdRoute);
-router83.post("/", createMedicationKnowledgeRoute);
-router83.put("/:id", updateMedicationKnowledgeRoute);
-router83.delete("/:id", deleteMedicationKnowledgeRoute);
+var router84 = import_express84.default.Router();
+router84.get("/", listMedicationKnowledgesRoute);
+router84.get("/:id", getMedicationKnowledgeByIdRoute);
+router84.post("/", createMedicationKnowledgeRoute);
+router84.put("/:id", updateMedicationKnowledgeRoute);
+router84.delete("/:id", deleteMedicationKnowledgeRoute);
 
 // src/data/rest-api/routes/data/medicationrequest/medicationrequest.ts
-var import_express84 = __toESM(require("express"));
+var import_express85 = __toESM(require("express"));
 
 // src/data/operations/data/medicationrequest/medicationrequest-create-operation.ts
 var import_ulid78 = require("ulid");
@@ -21595,15 +21942,15 @@ async function updateMedicationRequestRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/medicationrequest/medicationrequest.ts
-var router84 = import_express84.default.Router();
-router84.get("/", listMedicationRequestsRoute);
-router84.get("/:id", getMedicationRequestByIdRoute);
-router84.post("/", createMedicationRequestRoute);
-router84.put("/:id", updateMedicationRequestRoute);
-router84.delete("/:id", deleteMedicationRequestRoute);
+var router85 = import_express85.default.Router();
+router85.get("/", listMedicationRequestsRoute);
+router85.get("/:id", getMedicationRequestByIdRoute);
+router85.post("/", createMedicationRequestRoute);
+router85.put("/:id", updateMedicationRequestRoute);
+router85.delete("/:id", deleteMedicationRequestRoute);
 
 // src/data/rest-api/routes/data/medicationstatement/medicationstatement.ts
-var import_express85 = __toESM(require("express"));
+var import_express86 = __toESM(require("express"));
 
 // src/data/operations/data/medicationstatement/medicationstatement-create-operation.ts
 var import_ulid79 = require("ulid");
@@ -21802,15 +22149,15 @@ async function updateMedicationStatementRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/medicationstatement/medicationstatement.ts
-var router85 = import_express85.default.Router();
-router85.get("/", listMedicationStatementsRoute);
-router85.get("/:id", getMedicationStatementByIdRoute);
-router85.post("/", createMedicationStatementRoute);
-router85.put("/:id", updateMedicationStatementRoute);
-router85.delete("/:id", deleteMedicationStatementRoute);
+var router86 = import_express86.default.Router();
+router86.get("/", listMedicationStatementsRoute);
+router86.get("/:id", getMedicationStatementByIdRoute);
+router86.post("/", createMedicationStatementRoute);
+router86.put("/:id", updateMedicationStatementRoute);
+router86.delete("/:id", deleteMedicationStatementRoute);
 
 // src/data/rest-api/routes/data/medicinalproduct/medicinalproduct.ts
-var import_express86 = __toESM(require("express"));
+var import_express87 = __toESM(require("express"));
 
 // src/data/operations/data/medicinalproduct/medicinalproduct-create-operation.ts
 var import_ulid80 = require("ulid");
@@ -22002,15 +22349,15 @@ async function updateMedicinalProductRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/medicinalproduct/medicinalproduct.ts
-var router86 = import_express86.default.Router();
-router86.get("/", listMedicinalProductsRoute);
-router86.get("/:id", getMedicinalProductByIdRoute);
-router86.post("/", createMedicinalProductRoute);
-router86.put("/:id", updateMedicinalProductRoute);
-router86.delete("/:id", deleteMedicinalProductRoute);
+var router87 = import_express87.default.Router();
+router87.get("/", listMedicinalProductsRoute);
+router87.get("/:id", getMedicinalProductByIdRoute);
+router87.post("/", createMedicinalProductRoute);
+router87.put("/:id", updateMedicinalProductRoute);
+router87.delete("/:id", deleteMedicinalProductRoute);
 
 // src/data/rest-api/routes/data/medicinalproductauthorization/medicinalproductauthorization.ts
-var import_express87 = __toESM(require("express"));
+var import_express88 = __toESM(require("express"));
 
 // src/data/operations/data/medicinalproductauthorization/medicinalproductauthorization-create-operation.ts
 var import_ulid81 = require("ulid");
@@ -22221,15 +22568,15 @@ async function updateMedicinalProductAuthorizationRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/medicinalproductauthorization/medicinalproductauthorization.ts
-var router87 = import_express87.default.Router();
-router87.get("/", listMedicinalProductAuthorizationsRoute);
-router87.get("/:id", getMedicinalProductAuthorizationByIdRoute);
-router87.post("/", createMedicinalProductAuthorizationRoute);
-router87.put("/:id", updateMedicinalProductAuthorizationRoute);
-router87.delete("/:id", deleteMedicinalProductAuthorizationRoute);
+var router88 = import_express88.default.Router();
+router88.get("/", listMedicinalProductAuthorizationsRoute);
+router88.get("/:id", getMedicinalProductAuthorizationByIdRoute);
+router88.post("/", createMedicinalProductAuthorizationRoute);
+router88.put("/:id", updateMedicinalProductAuthorizationRoute);
+router88.delete("/:id", deleteMedicinalProductAuthorizationRoute);
 
 // src/data/rest-api/routes/data/medicinalproductcontraindication/medicinalproductcontraindication.ts
-var import_express88 = __toESM(require("express"));
+var import_express89 = __toESM(require("express"));
 
 // src/data/operations/data/medicinalproductcontraindication/medicinalproductcontraindication-create-operation.ts
 var import_ulid82 = require("ulid");
@@ -22446,15 +22793,15 @@ async function updateMedicinalProductContraindicationRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/medicinalproductcontraindication/medicinalproductcontraindication.ts
-var router88 = import_express88.default.Router();
-router88.get("/", listMedicinalProductContraindicationsRoute);
-router88.get("/:id", getMedicinalProductContraindicationByIdRoute);
-router88.post("/", createMedicinalProductContraindicationRoute);
-router88.put("/:id", updateMedicinalProductContraindicationRoute);
-router88.delete("/:id", deleteMedicinalProductContraindicationRoute);
+var router89 = import_express89.default.Router();
+router89.get("/", listMedicinalProductContraindicationsRoute);
+router89.get("/:id", getMedicinalProductContraindicationByIdRoute);
+router89.post("/", createMedicinalProductContraindicationRoute);
+router89.put("/:id", updateMedicinalProductContraindicationRoute);
+router89.delete("/:id", deleteMedicinalProductContraindicationRoute);
 
 // src/data/rest-api/routes/data/medicinalproductindication/medicinalproductindication.ts
-var import_express89 = __toESM(require("express"));
+var import_express90 = __toESM(require("express"));
 
 // src/data/operations/data/medicinalproductindication/medicinalproductindication-create-operation.ts
 var import_ulid83 = require("ulid");
@@ -22665,15 +23012,15 @@ async function updateMedicinalProductIndicationRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/medicinalproductindication/medicinalproductindication.ts
-var router89 = import_express89.default.Router();
-router89.get("/", listMedicinalProductIndicationsRoute);
-router89.get("/:id", getMedicinalProductIndicationByIdRoute);
-router89.post("/", createMedicinalProductIndicationRoute);
-router89.put("/:id", updateMedicinalProductIndicationRoute);
-router89.delete("/:id", deleteMedicinalProductIndicationRoute);
+var router90 = import_express90.default.Router();
+router90.get("/", listMedicinalProductIndicationsRoute);
+router90.get("/:id", getMedicinalProductIndicationByIdRoute);
+router90.post("/", createMedicinalProductIndicationRoute);
+router90.put("/:id", updateMedicinalProductIndicationRoute);
+router90.delete("/:id", deleteMedicinalProductIndicationRoute);
 
 // src/data/rest-api/routes/data/medicinalproductingredient/medicinalproductingredient.ts
-var import_express90 = __toESM(require("express"));
+var import_express91 = __toESM(require("express"));
 
 // src/data/operations/data/medicinalproductingredient/medicinalproductingredient-create-operation.ts
 var import_ulid84 = require("ulid");
@@ -22884,15 +23231,15 @@ async function updateMedicinalProductIngredientRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/medicinalproductingredient/medicinalproductingredient.ts
-var router90 = import_express90.default.Router();
-router90.get("/", listMedicinalProductIngredientsRoute);
-router90.get("/:id", getMedicinalProductIngredientByIdRoute);
-router90.post("/", createMedicinalProductIngredientRoute);
-router90.put("/:id", updateMedicinalProductIngredientRoute);
-router90.delete("/:id", deleteMedicinalProductIngredientRoute);
+var router91 = import_express91.default.Router();
+router91.get("/", listMedicinalProductIngredientsRoute);
+router91.get("/:id", getMedicinalProductIngredientByIdRoute);
+router91.post("/", createMedicinalProductIngredientRoute);
+router91.put("/:id", updateMedicinalProductIngredientRoute);
+router91.delete("/:id", deleteMedicinalProductIngredientRoute);
 
 // src/data/rest-api/routes/data/medicinalproductinteraction/medicinalproductinteraction.ts
-var import_express91 = __toESM(require("express"));
+var import_express92 = __toESM(require("express"));
 
 // src/data/operations/data/medicinalproductinteraction/medicinalproductinteraction-create-operation.ts
 var import_ulid85 = require("ulid");
@@ -23103,15 +23450,15 @@ async function updateMedicinalProductInteractionRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/medicinalproductinteraction/medicinalproductinteraction.ts
-var router91 = import_express91.default.Router();
-router91.get("/", listMedicinalProductInteractionsRoute);
-router91.get("/:id", getMedicinalProductInteractionByIdRoute);
-router91.post("/", createMedicinalProductInteractionRoute);
-router91.put("/:id", updateMedicinalProductInteractionRoute);
-router91.delete("/:id", deleteMedicinalProductInteractionRoute);
+var router92 = import_express92.default.Router();
+router92.get("/", listMedicinalProductInteractionsRoute);
+router92.get("/:id", getMedicinalProductInteractionByIdRoute);
+router92.post("/", createMedicinalProductInteractionRoute);
+router92.put("/:id", updateMedicinalProductInteractionRoute);
+router92.delete("/:id", deleteMedicinalProductInteractionRoute);
 
 // src/data/rest-api/routes/data/medicinalproductmanufactured/medicinalproductmanufactured.ts
-var import_express92 = __toESM(require("express"));
+var import_express93 = __toESM(require("express"));
 
 // src/data/operations/data/medicinalproductmanufactured/medicinalproductmanufactured-create-operation.ts
 var import_ulid86 = require("ulid");
@@ -23322,15 +23669,15 @@ async function updateMedicinalProductManufacturedRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/medicinalproductmanufactured/medicinalproductmanufactured.ts
-var router92 = import_express92.default.Router();
-router92.get("/", listMedicinalProductManufacturedsRoute);
-router92.get("/:id", getMedicinalProductManufacturedByIdRoute);
-router92.post("/", createMedicinalProductManufacturedRoute);
-router92.put("/:id", updateMedicinalProductManufacturedRoute);
-router92.delete("/:id", deleteMedicinalProductManufacturedRoute);
+var router93 = import_express93.default.Router();
+router93.get("/", listMedicinalProductManufacturedsRoute);
+router93.get("/:id", getMedicinalProductManufacturedByIdRoute);
+router93.post("/", createMedicinalProductManufacturedRoute);
+router93.put("/:id", updateMedicinalProductManufacturedRoute);
+router93.delete("/:id", deleteMedicinalProductManufacturedRoute);
 
 // src/data/rest-api/routes/data/medicinalproductpackaged/medicinalproductpackaged.ts
-var import_express93 = __toESM(require("express"));
+var import_express94 = __toESM(require("express"));
 
 // src/data/operations/data/medicinalproductpackaged/medicinalproductpackaged-create-operation.ts
 var import_ulid87 = require("ulid");
@@ -23541,15 +23888,15 @@ async function updateMedicinalProductPackagedRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/medicinalproductpackaged/medicinalproductpackaged.ts
-var router93 = import_express93.default.Router();
-router93.get("/", listMedicinalProductPackagedsRoute);
-router93.get("/:id", getMedicinalProductPackagedByIdRoute);
-router93.post("/", createMedicinalProductPackagedRoute);
-router93.put("/:id", updateMedicinalProductPackagedRoute);
-router93.delete("/:id", deleteMedicinalProductPackagedRoute);
+var router94 = import_express94.default.Router();
+router94.get("/", listMedicinalProductPackagedsRoute);
+router94.get("/:id", getMedicinalProductPackagedByIdRoute);
+router94.post("/", createMedicinalProductPackagedRoute);
+router94.put("/:id", updateMedicinalProductPackagedRoute);
+router94.delete("/:id", deleteMedicinalProductPackagedRoute);
 
 // src/data/rest-api/routes/data/medicinalproductpharmaceutical/medicinalproductpharmaceutical.ts
-var import_express94 = __toESM(require("express"));
+var import_express95 = __toESM(require("express"));
 
 // src/data/operations/data/medicinalproductpharmaceutical/medicinalproductpharmaceutical-create-operation.ts
 var import_ulid88 = require("ulid");
@@ -23766,15 +24113,15 @@ async function updateMedicinalProductPharmaceuticalRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/medicinalproductpharmaceutical/medicinalproductpharmaceutical.ts
-var router94 = import_express94.default.Router();
-router94.get("/", listMedicinalProductPharmaceuticalsRoute);
-router94.get("/:id", getMedicinalProductPharmaceuticalByIdRoute);
-router94.post("/", createMedicinalProductPharmaceuticalRoute);
-router94.put("/:id", updateMedicinalProductPharmaceuticalRoute);
-router94.delete("/:id", deleteMedicinalProductPharmaceuticalRoute);
+var router95 = import_express95.default.Router();
+router95.get("/", listMedicinalProductPharmaceuticalsRoute);
+router95.get("/:id", getMedicinalProductPharmaceuticalByIdRoute);
+router95.post("/", createMedicinalProductPharmaceuticalRoute);
+router95.put("/:id", updateMedicinalProductPharmaceuticalRoute);
+router95.delete("/:id", deleteMedicinalProductPharmaceuticalRoute);
 
 // src/data/rest-api/routes/data/medicinalproductundesirableeffect/medicinalproductundesirableeffect.ts
-var import_express95 = __toESM(require("express"));
+var import_express96 = __toESM(require("express"));
 
 // src/data/operations/data/medicinalproductundesirableeffect/medicinalproductundesirableeffect-create-operation.ts
 var import_ulid89 = require("ulid");
@@ -23994,15 +24341,15 @@ async function updateMedicinalProductUndesirableEffectRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/medicinalproductundesirableeffect/medicinalproductundesirableeffect.ts
-var router95 = import_express95.default.Router();
-router95.get("/", listMedicinalProductUndesirableEffectsRoute);
-router95.get("/:id", getMedicinalProductUndesirableEffectByIdRoute);
-router95.post("/", createMedicinalProductUndesirableEffectRoute);
-router95.put("/:id", updateMedicinalProductUndesirableEffectRoute);
-router95.delete("/:id", deleteMedicinalProductUndesirableEffectRoute);
+var router96 = import_express96.default.Router();
+router96.get("/", listMedicinalProductUndesirableEffectsRoute);
+router96.get("/:id", getMedicinalProductUndesirableEffectByIdRoute);
+router96.post("/", createMedicinalProductUndesirableEffectRoute);
+router96.put("/:id", updateMedicinalProductUndesirableEffectRoute);
+router96.delete("/:id", deleteMedicinalProductUndesirableEffectRoute);
 
 // src/data/rest-api/routes/data/messagedefinition/messagedefinition.ts
-var import_express96 = __toESM(require("express"));
+var import_express97 = __toESM(require("express"));
 
 // src/data/operations/data/messagedefinition/messagedefinition-create-operation.ts
 var import_ulid90 = require("ulid");
@@ -24197,15 +24544,15 @@ async function updateMessageDefinitionRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/messagedefinition/messagedefinition.ts
-var router96 = import_express96.default.Router();
-router96.get("/", listMessageDefinitionsRoute);
-router96.get("/:id", getMessageDefinitionByIdRoute);
-router96.post("/", createMessageDefinitionRoute);
-router96.put("/:id", updateMessageDefinitionRoute);
-router96.delete("/:id", deleteMessageDefinitionRoute);
+var router97 = import_express97.default.Router();
+router97.get("/", listMessageDefinitionsRoute);
+router97.get("/:id", getMessageDefinitionByIdRoute);
+router97.post("/", createMessageDefinitionRoute);
+router97.put("/:id", updateMessageDefinitionRoute);
+router97.delete("/:id", deleteMessageDefinitionRoute);
 
 // src/data/rest-api/routes/data/messageheader/messageheader.ts
-var import_express97 = __toESM(require("express"));
+var import_express98 = __toESM(require("express"));
 
 // src/data/operations/data/messageheader/messageheader-create-operation.ts
 var import_ulid91 = require("ulid");
@@ -24397,15 +24744,15 @@ async function updateMessageHeaderRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/messageheader/messageheader.ts
-var router97 = import_express97.default.Router();
-router97.get("/", listMessageHeadersRoute);
-router97.get("/:id", getMessageHeaderByIdRoute);
-router97.post("/", createMessageHeaderRoute);
-router97.put("/:id", updateMessageHeaderRoute);
-router97.delete("/:id", deleteMessageHeaderRoute);
+var router98 = import_express98.default.Router();
+router98.get("/", listMessageHeadersRoute);
+router98.get("/:id", getMessageHeaderByIdRoute);
+router98.post("/", createMessageHeaderRoute);
+router98.put("/:id", updateMessageHeaderRoute);
+router98.delete("/:id", deleteMessageHeaderRoute);
 
 // src/data/rest-api/routes/data/molecularsequence/molecularsequence.ts
-var import_express98 = __toESM(require("express"));
+var import_express99 = __toESM(require("express"));
 
 // src/data/operations/data/molecularsequence/molecularsequence-create-operation.ts
 var import_ulid92 = require("ulid");
@@ -24600,15 +24947,15 @@ async function updateMolecularSequenceRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/molecularsequence/molecularsequence.ts
-var router98 = import_express98.default.Router();
-router98.get("/", listMolecularSequencesRoute);
-router98.get("/:id", getMolecularSequenceByIdRoute);
-router98.post("/", createMolecularSequenceRoute);
-router98.put("/:id", updateMolecularSequenceRoute);
-router98.delete("/:id", deleteMolecularSequenceRoute);
+var router99 = import_express99.default.Router();
+router99.get("/", listMolecularSequencesRoute);
+router99.get("/:id", getMolecularSequenceByIdRoute);
+router99.post("/", createMolecularSequenceRoute);
+router99.put("/:id", updateMolecularSequenceRoute);
+router99.delete("/:id", deleteMolecularSequenceRoute);
 
 // src/data/rest-api/routes/data/namingsystem/namingsystem.ts
-var import_express99 = __toESM(require("express"));
+var import_express100 = __toESM(require("express"));
 
 // src/data/operations/data/namingsystem/namingsystem-create-operation.ts
 var import_ulid93 = require("ulid");
@@ -24800,15 +25147,15 @@ async function updateNamingSystemRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/namingsystem/namingsystem.ts
-var router99 = import_express99.default.Router();
-router99.get("/", listNamingSystemsRoute);
-router99.get("/:id", getNamingSystemByIdRoute);
-router99.post("/", createNamingSystemRoute);
-router99.put("/:id", updateNamingSystemRoute);
-router99.delete("/:id", deleteNamingSystemRoute);
+var router100 = import_express100.default.Router();
+router100.get("/", listNamingSystemsRoute);
+router100.get("/:id", getNamingSystemByIdRoute);
+router100.post("/", createNamingSystemRoute);
+router100.put("/:id", updateNamingSystemRoute);
+router100.delete("/:id", deleteNamingSystemRoute);
 
 // src/data/rest-api/routes/data/nutritionorder/nutritionorder.ts
-var import_express100 = __toESM(require("express"));
+var import_express101 = __toESM(require("express"));
 
 // src/data/operations/data/nutritionorder/nutritionorder-create-operation.ts
 var import_ulid94 = require("ulid");
@@ -25000,15 +25347,15 @@ async function updateNutritionOrderRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/nutritionorder/nutritionorder.ts
-var router100 = import_express100.default.Router();
-router100.get("/", listNutritionOrdersRoute);
-router100.get("/:id", getNutritionOrderByIdRoute);
-router100.post("/", createNutritionOrderRoute);
-router100.put("/:id", updateNutritionOrderRoute);
-router100.delete("/:id", deleteNutritionOrderRoute);
+var router101 = import_express101.default.Router();
+router101.get("/", listNutritionOrdersRoute);
+router101.get("/:id", getNutritionOrderByIdRoute);
+router101.post("/", createNutritionOrderRoute);
+router101.put("/:id", updateNutritionOrderRoute);
+router101.delete("/:id", deleteNutritionOrderRoute);
 
 // src/data/rest-api/routes/data/observation/observation.ts
-var import_express101 = __toESM(require("express"));
+var import_express102 = __toESM(require("express"));
 
 // src/data/operations/data/observation/observation-create-operation.ts
 var import_ulid95 = require("ulid");
@@ -25200,15 +25547,15 @@ async function updateObservationRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/observation/observation.ts
-var router101 = import_express101.default.Router();
-router101.get("/", listObservationsRoute);
-router101.get("/:id", getObservationByIdRoute);
-router101.post("/", createObservationRoute);
-router101.put("/:id", updateObservationRoute);
-router101.delete("/:id", deleteObservationRoute);
+var router102 = import_express102.default.Router();
+router102.get("/", listObservationsRoute);
+router102.get("/:id", getObservationByIdRoute);
+router102.post("/", createObservationRoute);
+router102.put("/:id", updateObservationRoute);
+router102.delete("/:id", deleteObservationRoute);
 
 // src/data/rest-api/routes/data/observationdefinition/observationdefinition.ts
-var import_express102 = __toESM(require("express"));
+var import_express103 = __toESM(require("express"));
 
 // src/data/operations/data/observationdefinition/observationdefinition-create-operation.ts
 var import_ulid96 = require("ulid");
@@ -25419,15 +25766,15 @@ async function updateObservationDefinitionRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/observationdefinition/observationdefinition.ts
-var router102 = import_express102.default.Router();
-router102.get("/", listObservationDefinitionsRoute);
-router102.get("/:id", getObservationDefinitionByIdRoute);
-router102.post("/", createObservationDefinitionRoute);
-router102.put("/:id", updateObservationDefinitionRoute);
-router102.delete("/:id", deleteObservationDefinitionRoute);
+var router103 = import_express103.default.Router();
+router103.get("/", listObservationDefinitionsRoute);
+router103.get("/:id", getObservationDefinitionByIdRoute);
+router103.post("/", createObservationDefinitionRoute);
+router103.put("/:id", updateObservationDefinitionRoute);
+router103.delete("/:id", deleteObservationDefinitionRoute);
 
 // src/data/rest-api/routes/data/operationdefinition/operationdefinition.ts
-var import_express103 = __toESM(require("express"));
+var import_express104 = __toESM(require("express"));
 
 // src/data/operations/data/operationdefinition/operationdefinition-create-operation.ts
 var import_ulid97 = require("ulid");
@@ -25626,15 +25973,15 @@ async function updateOperationDefinitionRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/operationdefinition/operationdefinition.ts
-var router103 = import_express103.default.Router();
-router103.get("/", listOperationDefinitionsRoute);
-router103.get("/:id", getOperationDefinitionByIdRoute);
-router103.post("/", createOperationDefinitionRoute);
-router103.put("/:id", updateOperationDefinitionRoute);
-router103.delete("/:id", deleteOperationDefinitionRoute);
+var router104 = import_express104.default.Router();
+router104.get("/", listOperationDefinitionsRoute);
+router104.get("/:id", getOperationDefinitionByIdRoute);
+router104.post("/", createOperationDefinitionRoute);
+router104.put("/:id", updateOperationDefinitionRoute);
+router104.delete("/:id", deleteOperationDefinitionRoute);
 
 // src/data/rest-api/routes/data/organization/organization.ts
-var import_express104 = __toESM(require("express"));
+var import_express105 = __toESM(require("express"));
 
 // src/data/operations/data/organization/organization-create-operation.ts
 var import_ulid98 = require("ulid");
@@ -25799,15 +26146,15 @@ async function updateOrganizationRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/organization/organization.ts
-var router104 = import_express104.default.Router();
-router104.get("/", listOrganizationsRoute);
-router104.get("/:id", getOrganizationByIdRoute);
-router104.post("/", createOrganizationRoute);
-router104.put("/:id", updateOrganizationRoute);
-router104.delete("/:id", deleteOrganizationRoute);
+var router105 = import_express105.default.Router();
+router105.get("/", listOrganizationsRoute);
+router105.get("/:id", getOrganizationByIdRoute);
+router105.post("/", createOrganizationRoute);
+router105.put("/:id", updateOrganizationRoute);
+router105.delete("/:id", deleteOrganizationRoute);
 
 // src/data/rest-api/routes/data/organizationaffiliation/organizationaffiliation.ts
-var import_express105 = __toESM(require("express"));
+var import_express106 = __toESM(require("express"));
 
 // src/data/operations/data/organizationaffiliation/organizationaffiliation-create-operation.ts
 var import_ulid99 = require("ulid");
@@ -26018,15 +26365,15 @@ async function updateOrganizationAffiliationRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/organizationaffiliation/organizationaffiliation.ts
-var router105 = import_express105.default.Router();
-router105.get("/", listOrganizationAffiliationsRoute);
-router105.get("/:id", getOrganizationAffiliationByIdRoute);
-router105.post("/", createOrganizationAffiliationRoute);
-router105.put("/:id", updateOrganizationAffiliationRoute);
-router105.delete("/:id", deleteOrganizationAffiliationRoute);
+var router106 = import_express106.default.Router();
+router106.get("/", listOrganizationAffiliationsRoute);
+router106.get("/:id", getOrganizationAffiliationByIdRoute);
+router106.post("/", createOrganizationAffiliationRoute);
+router106.put("/:id", updateOrganizationAffiliationRoute);
+router106.delete("/:id", deleteOrganizationAffiliationRoute);
 
 // src/data/rest-api/routes/data/patient/patient.ts
-var import_express106 = __toESM(require("express"));
+var import_express107 = __toESM(require("express"));
 
 // src/data/operations/data/patient/patient-create-operation.ts
 var import_ulid100 = require("ulid");
@@ -26301,15 +26648,15 @@ async function updatePatientRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/patient/patient.ts
-var router106 = import_express106.default.Router();
-router106.get("/", listPatientsRoute);
-router106.get("/:id", getPatientByIdRoute);
-router106.post("/", createPatientRoute);
-router106.put("/:id", updatePatientRoute);
-router106.delete("/:id", deletePatientRoute);
+var router107 = import_express107.default.Router();
+router107.get("/", listPatientsRoute);
+router107.get("/:id", getPatientByIdRoute);
+router107.post("/", createPatientRoute);
+router107.put("/:id", updatePatientRoute);
+router107.delete("/:id", deletePatientRoute);
 
 // src/data/rest-api/routes/data/paymentnotice/paymentnotice.ts
-var import_express107 = __toESM(require("express"));
+var import_express108 = __toESM(require("express"));
 
 // src/data/operations/data/paymentnotice/paymentnotice-create-operation.ts
 var import_ulid101 = require("ulid");
@@ -26501,15 +26848,15 @@ async function updatePaymentNoticeRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/paymentnotice/paymentnotice.ts
-var router107 = import_express107.default.Router();
-router107.get("/", listPaymentNoticesRoute);
-router107.get("/:id", getPaymentNoticeByIdRoute);
-router107.post("/", createPaymentNoticeRoute);
-router107.put("/:id", updatePaymentNoticeRoute);
-router107.delete("/:id", deletePaymentNoticeRoute);
+var router108 = import_express108.default.Router();
+router108.get("/", listPaymentNoticesRoute);
+router108.get("/:id", getPaymentNoticeByIdRoute);
+router108.post("/", createPaymentNoticeRoute);
+router108.put("/:id", updatePaymentNoticeRoute);
+router108.delete("/:id", deletePaymentNoticeRoute);
 
 // src/data/rest-api/routes/data/paymentreconciliation/paymentreconciliation.ts
-var import_express108 = __toESM(require("express"));
+var import_express109 = __toESM(require("express"));
 
 // src/data/operations/data/paymentreconciliation/paymentreconciliation-create-operation.ts
 var import_ulid102 = require("ulid");
@@ -26720,15 +27067,15 @@ async function updatePaymentReconciliationRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/paymentreconciliation/paymentreconciliation.ts
-var router108 = import_express108.default.Router();
-router108.get("/", listPaymentReconciliationsRoute);
-router108.get("/:id", getPaymentReconciliationByIdRoute);
-router108.post("/", createPaymentReconciliationRoute);
-router108.put("/:id", updatePaymentReconciliationRoute);
-router108.delete("/:id", deletePaymentReconciliationRoute);
+var router109 = import_express109.default.Router();
+router109.get("/", listPaymentReconciliationsRoute);
+router109.get("/:id", getPaymentReconciliationByIdRoute);
+router109.post("/", createPaymentReconciliationRoute);
+router109.put("/:id", updatePaymentReconciliationRoute);
+router109.delete("/:id", deletePaymentReconciliationRoute);
 
 // src/data/rest-api/routes/data/person/person.ts
-var import_express109 = __toESM(require("express"));
+var import_express110 = __toESM(require("express"));
 
 // src/data/operations/data/person/person-create-operation.ts
 var import_ulid103 = require("ulid");
@@ -26920,15 +27267,15 @@ async function updatePersonRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/person/person.ts
-var router109 = import_express109.default.Router();
-router109.get("/", listPersonsRoute);
-router109.get("/:id", getPersonByIdRoute);
-router109.post("/", createPersonRoute);
-router109.put("/:id", updatePersonRoute);
-router109.delete("/:id", deletePersonRoute);
+var router110 = import_express110.default.Router();
+router110.get("/", listPersonsRoute);
+router110.get("/:id", getPersonByIdRoute);
+router110.post("/", createPersonRoute);
+router110.put("/:id", updatePersonRoute);
+router110.delete("/:id", deletePersonRoute);
 
 // src/data/rest-api/routes/data/plandefinition/plandefinition.ts
-var import_express110 = __toESM(require("express"));
+var import_express111 = __toESM(require("express"));
 
 // src/data/operations/data/plandefinition/plandefinition-create-operation.ts
 var import_ulid104 = require("ulid");
@@ -27120,15 +27467,15 @@ async function updatePlanDefinitionRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/plandefinition/plandefinition.ts
-var router110 = import_express110.default.Router();
-router110.get("/", listPlanDefinitionsRoute);
-router110.get("/:id", getPlanDefinitionByIdRoute);
-router110.post("/", createPlanDefinitionRoute);
-router110.put("/:id", updatePlanDefinitionRoute);
-router110.delete("/:id", deletePlanDefinitionRoute);
+var router111 = import_express111.default.Router();
+router111.get("/", listPlanDefinitionsRoute);
+router111.get("/:id", getPlanDefinitionByIdRoute);
+router111.post("/", createPlanDefinitionRoute);
+router111.put("/:id", updatePlanDefinitionRoute);
+router111.delete("/:id", deletePlanDefinitionRoute);
 
 // src/data/rest-api/routes/data/practitioner/practitioner.ts
-var import_express111 = __toESM(require("express"));
+var import_express112 = __toESM(require("express"));
 
 // src/data/operations/data/practitioner/practitioner-create-operation.ts
 var import_ulid105 = require("ulid");
@@ -27325,15 +27672,15 @@ async function updatePractitionerRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/practitioner/practitioner.ts
-var router111 = import_express111.default.Router();
-router111.get("/", listPractitionersRoute);
-router111.get("/:id", getPractitionerByIdRoute);
-router111.post("/", createPractitionerRoute);
-router111.put("/:id", updatePractitionerRoute);
-router111.delete("/:id", deletePractitionerRoute);
+var router112 = import_express112.default.Router();
+router112.get("/", listPractitionersRoute);
+router112.get("/:id", getPractitionerByIdRoute);
+router112.post("/", createPractitionerRoute);
+router112.put("/:id", updatePractitionerRoute);
+router112.delete("/:id", deletePractitionerRoute);
 
 // src/data/rest-api/routes/data/practitionerrole/practitionerrole.ts
-var import_express112 = __toESM(require("express"));
+var import_express113 = __toESM(require("express"));
 
 // src/data/rest-api/routes/data/practitionerrole/practitionerrole-create-route.ts
 async function createPractitionerRoleRoute(req, res) {
@@ -27464,15 +27811,15 @@ async function updatePractitionerRoleRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/practitionerrole/practitionerrole.ts
-var router112 = import_express112.default.Router();
-router112.get("/", listPractitionerRolesRoute);
-router112.get("/:id", getPractitionerRoleByIdRoute);
-router112.post("/", createPractitionerRoleRoute);
-router112.put("/:id", updatePractitionerRoleRoute);
-router112.delete("/:id", deletePractitionerRoleRoute);
+var router113 = import_express113.default.Router();
+router113.get("/", listPractitionerRolesRoute);
+router113.get("/:id", getPractitionerRoleByIdRoute);
+router113.post("/", createPractitionerRoleRoute);
+router113.put("/:id", updatePractitionerRoleRoute);
+router113.delete("/:id", deletePractitionerRoleRoute);
 
 // src/data/rest-api/routes/data/procedure/procedure.ts
-var import_express113 = __toESM(require("express"));
+var import_express114 = __toESM(require("express"));
 
 // src/data/operations/data/procedure/procedure-create-operation.ts
 var import_ulid106 = require("ulid");
@@ -27664,15 +28011,15 @@ async function updateProcedureRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/procedure/procedure.ts
-var router113 = import_express113.default.Router();
-router113.get("/", listProceduresRoute);
-router113.get("/:id", getProcedureByIdRoute);
-router113.post("/", createProcedureRoute);
-router113.put("/:id", updateProcedureRoute);
-router113.delete("/:id", deleteProcedureRoute);
+var router114 = import_express114.default.Router();
+router114.get("/", listProceduresRoute);
+router114.get("/:id", getProcedureByIdRoute);
+router114.post("/", createProcedureRoute);
+router114.put("/:id", updateProcedureRoute);
+router114.delete("/:id", deleteProcedureRoute);
 
 // src/data/rest-api/routes/data/provenance/provenance.ts
-var import_express114 = __toESM(require("express"));
+var import_express115 = __toESM(require("express"));
 
 // src/data/operations/data/provenance/provenance-create-operation.ts
 var import_ulid107 = require("ulid");
@@ -27864,15 +28211,15 @@ async function updateProvenanceRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/provenance/provenance.ts
-var router114 = import_express114.default.Router();
-router114.get("/", listProvenancesRoute);
-router114.get("/:id", getProvenanceByIdRoute);
-router114.post("/", createProvenanceRoute);
-router114.put("/:id", updateProvenanceRoute);
-router114.delete("/:id", deleteProvenanceRoute);
+var router115 = import_express115.default.Router();
+router115.get("/", listProvenancesRoute);
+router115.get("/:id", getProvenanceByIdRoute);
+router115.post("/", createProvenanceRoute);
+router115.put("/:id", updateProvenanceRoute);
+router115.delete("/:id", deleteProvenanceRoute);
 
 // src/data/rest-api/routes/data/questionnaire/questionnaire.ts
-var import_express115 = __toESM(require("express"));
+var import_express116 = __toESM(require("express"));
 
 // src/data/operations/data/questionnaire/questionnaire-create-operation.ts
 var import_ulid108 = require("ulid");
@@ -28064,15 +28411,15 @@ async function updateQuestionnaireRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/questionnaire/questionnaire.ts
-var router115 = import_express115.default.Router();
-router115.get("/", listQuestionnairesRoute);
-router115.get("/:id", getQuestionnaireByIdRoute);
-router115.post("/", createQuestionnaireRoute);
-router115.put("/:id", updateQuestionnaireRoute);
-router115.delete("/:id", deleteQuestionnaireRoute);
+var router116 = import_express116.default.Router();
+router116.get("/", listQuestionnairesRoute);
+router116.get("/:id", getQuestionnaireByIdRoute);
+router116.post("/", createQuestionnaireRoute);
+router116.put("/:id", updateQuestionnaireRoute);
+router116.delete("/:id", deleteQuestionnaireRoute);
 
 // src/data/rest-api/routes/data/questionnaireresponse/questionnaireresponse.ts
-var import_express116 = __toESM(require("express"));
+var import_express117 = __toESM(require("express"));
 
 // src/data/operations/data/questionnaireresponse/questionnaireresponse-create-operation.ts
 var import_ulid109 = require("ulid");
@@ -28283,15 +28630,15 @@ async function updateQuestionnaireResponseRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/questionnaireresponse/questionnaireresponse.ts
-var router116 = import_express116.default.Router();
-router116.get("/", listQuestionnaireResponsesRoute);
-router116.get("/:id", getQuestionnaireResponseByIdRoute);
-router116.post("/", createQuestionnaireResponseRoute);
-router116.put("/:id", updateQuestionnaireResponseRoute);
-router116.delete("/:id", deleteQuestionnaireResponseRoute);
+var router117 = import_express117.default.Router();
+router117.get("/", listQuestionnaireResponsesRoute);
+router117.get("/:id", getQuestionnaireResponseByIdRoute);
+router117.post("/", createQuestionnaireResponseRoute);
+router117.put("/:id", updateQuestionnaireResponseRoute);
+router117.delete("/:id", deleteQuestionnaireResponseRoute);
 
 // src/data/rest-api/routes/data/relatedperson/relatedperson.ts
-var import_express117 = __toESM(require("express"));
+var import_express118 = __toESM(require("express"));
 
 // src/data/operations/data/relatedperson/relatedperson-create-operation.ts
 var import_ulid110 = require("ulid");
@@ -28483,15 +28830,15 @@ async function updateRelatedPersonRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/relatedperson/relatedperson.ts
-var router117 = import_express117.default.Router();
-router117.get("/", listRelatedPersonsRoute);
-router117.get("/:id", getRelatedPersonByIdRoute);
-router117.post("/", createRelatedPersonRoute);
-router117.put("/:id", updateRelatedPersonRoute);
-router117.delete("/:id", deleteRelatedPersonRoute);
+var router118 = import_express118.default.Router();
+router118.get("/", listRelatedPersonsRoute);
+router118.get("/:id", getRelatedPersonByIdRoute);
+router118.post("/", createRelatedPersonRoute);
+router118.put("/:id", updateRelatedPersonRoute);
+router118.delete("/:id", deleteRelatedPersonRoute);
 
 // src/data/rest-api/routes/data/requestgroup/requestgroup.ts
-var import_express118 = __toESM(require("express"));
+var import_express119 = __toESM(require("express"));
 
 // src/data/operations/data/requestgroup/requestgroup-create-operation.ts
 var import_ulid111 = require("ulid");
@@ -28683,15 +29030,15 @@ async function updateRequestGroupRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/requestgroup/requestgroup.ts
-var router118 = import_express118.default.Router();
-router118.get("/", listRequestGroupsRoute);
-router118.get("/:id", getRequestGroupByIdRoute);
-router118.post("/", createRequestGroupRoute);
-router118.put("/:id", updateRequestGroupRoute);
-router118.delete("/:id", deleteRequestGroupRoute);
+var router119 = import_express119.default.Router();
+router119.get("/", listRequestGroupsRoute);
+router119.get("/:id", getRequestGroupByIdRoute);
+router119.post("/", createRequestGroupRoute);
+router119.put("/:id", updateRequestGroupRoute);
+router119.delete("/:id", deleteRequestGroupRoute);
 
 // src/data/rest-api/routes/data/researchdefinition/researchdefinition.ts
-var import_express119 = __toESM(require("express"));
+var import_express120 = __toESM(require("express"));
 
 // src/data/operations/data/researchdefinition/researchdefinition-create-operation.ts
 var import_ulid112 = require("ulid");
@@ -28890,15 +29237,15 @@ async function updateResearchDefinitionRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/researchdefinition/researchdefinition.ts
-var router119 = import_express119.default.Router();
-router119.get("/", listResearchDefinitionsRoute);
-router119.get("/:id", getResearchDefinitionByIdRoute);
-router119.post("/", createResearchDefinitionRoute);
-router119.put("/:id", updateResearchDefinitionRoute);
-router119.delete("/:id", deleteResearchDefinitionRoute);
+var router120 = import_express120.default.Router();
+router120.get("/", listResearchDefinitionsRoute);
+router120.get("/:id", getResearchDefinitionByIdRoute);
+router120.post("/", createResearchDefinitionRoute);
+router120.put("/:id", updateResearchDefinitionRoute);
+router120.delete("/:id", deleteResearchDefinitionRoute);
 
 // src/data/rest-api/routes/data/researchelementdefinition/researchelementdefinition.ts
-var import_express120 = __toESM(require("express"));
+var import_express121 = __toESM(require("express"));
 
 // src/data/operations/data/researchelementdefinition/researchelementdefinition-create-operation.ts
 var import_ulid113 = require("ulid");
@@ -29109,15 +29456,15 @@ async function updateResearchElementDefinitionRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/researchelementdefinition/researchelementdefinition.ts
-var router120 = import_express120.default.Router();
-router120.get("/", listResearchElementDefinitionsRoute);
-router120.get("/:id", getResearchElementDefinitionByIdRoute);
-router120.post("/", createResearchElementDefinitionRoute);
-router120.put("/:id", updateResearchElementDefinitionRoute);
-router120.delete("/:id", deleteResearchElementDefinitionRoute);
+var router121 = import_express121.default.Router();
+router121.get("/", listResearchElementDefinitionsRoute);
+router121.get("/:id", getResearchElementDefinitionByIdRoute);
+router121.post("/", createResearchElementDefinitionRoute);
+router121.put("/:id", updateResearchElementDefinitionRoute);
+router121.delete("/:id", deleteResearchElementDefinitionRoute);
 
 // src/data/rest-api/routes/data/researchstudy/researchstudy.ts
-var import_express121 = __toESM(require("express"));
+var import_express122 = __toESM(require("express"));
 
 // src/data/operations/data/researchstudy/researchstudy-create-operation.ts
 var import_ulid114 = require("ulid");
@@ -29309,15 +29656,15 @@ async function updateResearchStudyRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/researchstudy/researchstudy.ts
-var router121 = import_express121.default.Router();
-router121.get("/", listResearchStudysRoute);
-router121.get("/:id", getResearchStudyByIdRoute);
-router121.post("/", createResearchStudyRoute);
-router121.put("/:id", updateResearchStudyRoute);
-router121.delete("/:id", deleteResearchStudyRoute);
+var router122 = import_express122.default.Router();
+router122.get("/", listResearchStudysRoute);
+router122.get("/:id", getResearchStudyByIdRoute);
+router122.post("/", createResearchStudyRoute);
+router122.put("/:id", updateResearchStudyRoute);
+router122.delete("/:id", deleteResearchStudyRoute);
 
 // src/data/rest-api/routes/data/researchsubject/researchsubject.ts
-var import_express122 = __toESM(require("express"));
+var import_express123 = __toESM(require("express"));
 
 // src/data/operations/data/researchsubject/researchsubject-create-operation.ts
 var import_ulid115 = require("ulid");
@@ -29509,15 +29856,15 @@ async function updateResearchSubjectRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/researchsubject/researchsubject.ts
-var router122 = import_express122.default.Router();
-router122.get("/", listResearchSubjectsRoute);
-router122.get("/:id", getResearchSubjectByIdRoute);
-router122.post("/", createResearchSubjectRoute);
-router122.put("/:id", updateResearchSubjectRoute);
-router122.delete("/:id", deleteResearchSubjectRoute);
+var router123 = import_express123.default.Router();
+router123.get("/", listResearchSubjectsRoute);
+router123.get("/:id", getResearchSubjectByIdRoute);
+router123.post("/", createResearchSubjectRoute);
+router123.put("/:id", updateResearchSubjectRoute);
+router123.delete("/:id", deleteResearchSubjectRoute);
 
 // src/data/rest-api/routes/data/riskassessment/riskassessment.ts
-var import_express123 = __toESM(require("express"));
+var import_express124 = __toESM(require("express"));
 
 // src/data/operations/data/riskassessment/riskassessment-create-operation.ts
 var import_ulid116 = require("ulid");
@@ -29709,15 +30056,15 @@ async function updateRiskAssessmentRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/riskassessment/riskassessment.ts
-var router123 = import_express123.default.Router();
-router123.get("/", listRiskAssessmentsRoute);
-router123.get("/:id", getRiskAssessmentByIdRoute);
-router123.post("/", createRiskAssessmentRoute);
-router123.put("/:id", updateRiskAssessmentRoute);
-router123.delete("/:id", deleteRiskAssessmentRoute);
+var router124 = import_express124.default.Router();
+router124.get("/", listRiskAssessmentsRoute);
+router124.get("/:id", getRiskAssessmentByIdRoute);
+router124.post("/", createRiskAssessmentRoute);
+router124.put("/:id", updateRiskAssessmentRoute);
+router124.delete("/:id", deleteRiskAssessmentRoute);
 
 // src/data/rest-api/routes/data/riskevidencesynthesis/riskevidencesynthesis.ts
-var import_express124 = __toESM(require("express"));
+var import_express125 = __toESM(require("express"));
 
 // src/data/operations/data/riskevidencesynthesis/riskevidencesynthesis-create-operation.ts
 var import_ulid117 = require("ulid");
@@ -29928,15 +30275,15 @@ async function updateRiskEvidenceSynthesisRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/riskevidencesynthesis/riskevidencesynthesis.ts
-var router124 = import_express124.default.Router();
-router124.get("/", listRiskEvidenceSynthesissRoute);
-router124.get("/:id", getRiskEvidenceSynthesisByIdRoute);
-router124.post("/", createRiskEvidenceSynthesisRoute);
-router124.put("/:id", updateRiskEvidenceSynthesisRoute);
-router124.delete("/:id", deleteRiskEvidenceSynthesisRoute);
+var router125 = import_express125.default.Router();
+router125.get("/", listRiskEvidenceSynthesissRoute);
+router125.get("/:id", getRiskEvidenceSynthesisByIdRoute);
+router125.post("/", createRiskEvidenceSynthesisRoute);
+router125.put("/:id", updateRiskEvidenceSynthesisRoute);
+router125.delete("/:id", deleteRiskEvidenceSynthesisRoute);
 
 // src/data/rest-api/routes/data/schedule/schedule.ts
-var import_express125 = __toESM(require("express"));
+var import_express126 = __toESM(require("express"));
 
 // src/data/operations/data/schedule/schedule-create-operation.ts
 var import_ulid118 = require("ulid");
@@ -30210,15 +30557,15 @@ async function updateScheduleRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/schedule/schedule.ts
-var router125 = import_express125.default.Router();
-router125.get("/", listSchedulesRoute);
-router125.get("/:id", getScheduleByIdRoute);
-router125.post("/", createScheduleRoute);
-router125.put("/:id", updateScheduleRoute);
-router125.delete("/:id", deleteScheduleRoute);
+var router126 = import_express126.default.Router();
+router126.get("/", listSchedulesRoute);
+router126.get("/:id", getScheduleByIdRoute);
+router126.post("/", createScheduleRoute);
+router126.put("/:id", updateScheduleRoute);
+router126.delete("/:id", deleteScheduleRoute);
 
 // src/data/rest-api/routes/data/searchparameter/searchparameter.ts
-var import_express126 = __toESM(require("express"));
+var import_express127 = __toESM(require("express"));
 
 // src/data/operations/data/searchparameter/searchparameter-create-operation.ts
 var import_ulid119 = require("ulid");
@@ -30410,15 +30757,15 @@ async function updateSearchParameterRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/searchparameter/searchparameter.ts
-var router126 = import_express126.default.Router();
-router126.get("/", listSearchParametersRoute);
-router126.get("/:id", getSearchParameterByIdRoute);
-router126.post("/", createSearchParameterRoute);
-router126.put("/:id", updateSearchParameterRoute);
-router126.delete("/:id", deleteSearchParameterRoute);
+var router127 = import_express127.default.Router();
+router127.get("/", listSearchParametersRoute);
+router127.get("/:id", getSearchParameterByIdRoute);
+router127.post("/", createSearchParameterRoute);
+router127.put("/:id", updateSearchParameterRoute);
+router127.delete("/:id", deleteSearchParameterRoute);
 
 // src/data/rest-api/routes/data/servicerequest/servicerequest.ts
-var import_express127 = __toESM(require("express"));
+var import_express128 = __toESM(require("express"));
 
 // src/data/operations/data/servicerequest/servicerequest-create-operation.ts
 var import_ulid120 = require("ulid");
@@ -30610,15 +30957,15 @@ async function updateServiceRequestRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/servicerequest/servicerequest.ts
-var router127 = import_express127.default.Router();
-router127.get("/", listServiceRequestsRoute);
-router127.get("/:id", getServiceRequestByIdRoute);
-router127.post("/", createServiceRequestRoute);
-router127.put("/:id", updateServiceRequestRoute);
-router127.delete("/:id", deleteServiceRequestRoute);
+var router128 = import_express128.default.Router();
+router128.get("/", listServiceRequestsRoute);
+router128.get("/:id", getServiceRequestByIdRoute);
+router128.post("/", createServiceRequestRoute);
+router128.put("/:id", updateServiceRequestRoute);
+router128.delete("/:id", deleteServiceRequestRoute);
 
 // src/data/rest-api/routes/data/slot/slot.ts
-var import_express128 = __toESM(require("express"));
+var import_express129 = __toESM(require("express"));
 
 // src/data/operations/data/slot/slot-create-operation.ts
 var import_ulid121 = require("ulid");
@@ -30810,15 +31157,15 @@ async function updateSlotRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/slot/slot.ts
-var router128 = import_express128.default.Router();
-router128.get("/", listSlotsRoute);
-router128.get("/:id", getSlotByIdRoute);
-router128.post("/", createSlotRoute);
-router128.put("/:id", updateSlotRoute);
-router128.delete("/:id", deleteSlotRoute);
+var router129 = import_express129.default.Router();
+router129.get("/", listSlotsRoute);
+router129.get("/:id", getSlotByIdRoute);
+router129.post("/", createSlotRoute);
+router129.put("/:id", updateSlotRoute);
+router129.delete("/:id", deleteSlotRoute);
 
 // src/data/rest-api/routes/data/specimen/specimen.ts
-var import_express129 = __toESM(require("express"));
+var import_express130 = __toESM(require("express"));
 
 // src/data/operations/data/specimen/specimen-create-operation.ts
 var import_ulid122 = require("ulid");
@@ -31010,15 +31357,15 @@ async function updateSpecimenRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/specimen/specimen.ts
-var router129 = import_express129.default.Router();
-router129.get("/", listSpecimensRoute);
-router129.get("/:id", getSpecimenByIdRoute);
-router129.post("/", createSpecimenRoute);
-router129.put("/:id", updateSpecimenRoute);
-router129.delete("/:id", deleteSpecimenRoute);
+var router130 = import_express130.default.Router();
+router130.get("/", listSpecimensRoute);
+router130.get("/:id", getSpecimenByIdRoute);
+router130.post("/", createSpecimenRoute);
+router130.put("/:id", updateSpecimenRoute);
+router130.delete("/:id", deleteSpecimenRoute);
 
 // src/data/rest-api/routes/data/specimendefinition/specimendefinition.ts
-var import_express130 = __toESM(require("express"));
+var import_express131 = __toESM(require("express"));
 
 // src/data/operations/data/specimendefinition/specimendefinition-create-operation.ts
 var import_ulid123 = require("ulid");
@@ -31217,15 +31564,15 @@ async function updateSpecimenDefinitionRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/specimendefinition/specimendefinition.ts
-var router130 = import_express130.default.Router();
-router130.get("/", listSpecimenDefinitionsRoute);
-router130.get("/:id", getSpecimenDefinitionByIdRoute);
-router130.post("/", createSpecimenDefinitionRoute);
-router130.put("/:id", updateSpecimenDefinitionRoute);
-router130.delete("/:id", deleteSpecimenDefinitionRoute);
+var router131 = import_express131.default.Router();
+router131.get("/", listSpecimenDefinitionsRoute);
+router131.get("/:id", getSpecimenDefinitionByIdRoute);
+router131.post("/", createSpecimenDefinitionRoute);
+router131.put("/:id", updateSpecimenDefinitionRoute);
+router131.delete("/:id", deleteSpecimenDefinitionRoute);
 
 // src/data/rest-api/routes/data/structuredefinition/structuredefinition.ts
-var import_express131 = __toESM(require("express"));
+var import_express132 = __toESM(require("express"));
 
 // src/data/operations/data/structuredefinition/structuredefinition-create-operation.ts
 var import_ulid124 = require("ulid");
@@ -31424,15 +31771,15 @@ async function updateStructureDefinitionRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/structuredefinition/structuredefinition.ts
-var router131 = import_express131.default.Router();
-router131.get("/", listStructureDefinitionsRoute);
-router131.get("/:id", getStructureDefinitionByIdRoute);
-router131.post("/", createStructureDefinitionRoute);
-router131.put("/:id", updateStructureDefinitionRoute);
-router131.delete("/:id", deleteStructureDefinitionRoute);
+var router132 = import_express132.default.Router();
+router132.get("/", listStructureDefinitionsRoute);
+router132.get("/:id", getStructureDefinitionByIdRoute);
+router132.post("/", createStructureDefinitionRoute);
+router132.put("/:id", updateStructureDefinitionRoute);
+router132.delete("/:id", deleteStructureDefinitionRoute);
 
 // src/data/rest-api/routes/data/structuremap/structuremap.ts
-var import_express132 = __toESM(require("express"));
+var import_express133 = __toESM(require("express"));
 
 // src/data/operations/data/structuremap/structuremap-create-operation.ts
 var import_ulid125 = require("ulid");
@@ -31624,15 +31971,15 @@ async function updateStructureMapRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/structuremap/structuremap.ts
-var router132 = import_express132.default.Router();
-router132.get("/", listStructureMapsRoute);
-router132.get("/:id", getStructureMapByIdRoute);
-router132.post("/", createStructureMapRoute);
-router132.put("/:id", updateStructureMapRoute);
-router132.delete("/:id", deleteStructureMapRoute);
+var router133 = import_express133.default.Router();
+router133.get("/", listStructureMapsRoute);
+router133.get("/:id", getStructureMapByIdRoute);
+router133.post("/", createStructureMapRoute);
+router133.put("/:id", updateStructureMapRoute);
+router133.delete("/:id", deleteStructureMapRoute);
 
 // src/data/rest-api/routes/data/subscription/subscription.ts
-var import_express133 = __toESM(require("express"));
+var import_express134 = __toESM(require("express"));
 
 // src/data/operations/data/subscription/subscription-create-operation.ts
 var import_ulid126 = require("ulid");
@@ -31824,15 +32171,15 @@ async function updateSubscriptionRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/subscription/subscription.ts
-var router133 = import_express133.default.Router();
-router133.get("/", listSubscriptionsRoute);
-router133.get("/:id", getSubscriptionByIdRoute);
-router133.post("/", createSubscriptionRoute);
-router133.put("/:id", updateSubscriptionRoute);
-router133.delete("/:id", deleteSubscriptionRoute);
+var router134 = import_express134.default.Router();
+router134.get("/", listSubscriptionsRoute);
+router134.get("/:id", getSubscriptionByIdRoute);
+router134.post("/", createSubscriptionRoute);
+router134.put("/:id", updateSubscriptionRoute);
+router134.delete("/:id", deleteSubscriptionRoute);
 
 // src/data/rest-api/routes/data/substance/substance.ts
-var import_express134 = __toESM(require("express"));
+var import_express135 = __toESM(require("express"));
 
 // src/data/operations/data/substance/substance-create-operation.ts
 var import_ulid127 = require("ulid");
@@ -32024,15 +32371,15 @@ async function updateSubstanceRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/substance/substance.ts
-var router134 = import_express134.default.Router();
-router134.get("/", listSubstancesRoute);
-router134.get("/:id", getSubstanceByIdRoute);
-router134.post("/", createSubstanceRoute);
-router134.put("/:id", updateSubstanceRoute);
-router134.delete("/:id", deleteSubstanceRoute);
+var router135 = import_express135.default.Router();
+router135.get("/", listSubstancesRoute);
+router135.get("/:id", getSubstanceByIdRoute);
+router135.post("/", createSubstanceRoute);
+router135.put("/:id", updateSubstanceRoute);
+router135.delete("/:id", deleteSubstanceRoute);
 
 // src/data/rest-api/routes/data/substancenucleicacid/substancenucleicacid.ts
-var import_express135 = __toESM(require("express"));
+var import_express136 = __toESM(require("express"));
 
 // src/data/operations/data/substancenucleicacid/substancenucleicacid-create-operation.ts
 var import_ulid128 = require("ulid");
@@ -32235,15 +32582,15 @@ async function updateSubstanceNucleicAcidRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/substancenucleicacid/substancenucleicacid.ts
-var router135 = import_express135.default.Router();
-router135.get("/", listSubstanceNucleicAcidsRoute);
-router135.get("/:id", getSubstanceNucleicAcidByIdRoute);
-router135.post("/", createSubstanceNucleicAcidRoute);
-router135.put("/:id", updateSubstanceNucleicAcidRoute);
-router135.delete("/:id", deleteSubstanceNucleicAcidRoute);
+var router136 = import_express136.default.Router();
+router136.get("/", listSubstanceNucleicAcidsRoute);
+router136.get("/:id", getSubstanceNucleicAcidByIdRoute);
+router136.post("/", createSubstanceNucleicAcidRoute);
+router136.put("/:id", updateSubstanceNucleicAcidRoute);
+router136.delete("/:id", deleteSubstanceNucleicAcidRoute);
 
 // src/data/rest-api/routes/data/substancepolymer/substancepolymer.ts
-var import_express136 = __toESM(require("express"));
+var import_express137 = __toESM(require("express"));
 
 // src/data/operations/data/substancepolymer/substancepolymer-create-operation.ts
 var import_ulid129 = require("ulid");
@@ -32435,15 +32782,15 @@ async function updateSubstancePolymerRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/substancepolymer/substancepolymer.ts
-var router136 = import_express136.default.Router();
-router136.get("/", listSubstancePolymersRoute);
-router136.get("/:id", getSubstancePolymerByIdRoute);
-router136.post("/", createSubstancePolymerRoute);
-router136.put("/:id", updateSubstancePolymerRoute);
-router136.delete("/:id", deleteSubstancePolymerRoute);
+var router137 = import_express137.default.Router();
+router137.get("/", listSubstancePolymersRoute);
+router137.get("/:id", getSubstancePolymerByIdRoute);
+router137.post("/", createSubstancePolymerRoute);
+router137.put("/:id", updateSubstancePolymerRoute);
+router137.delete("/:id", deleteSubstancePolymerRoute);
 
 // src/data/rest-api/routes/data/substanceprotein/substanceprotein.ts
-var import_express137 = __toESM(require("express"));
+var import_express138 = __toESM(require("express"));
 
 // src/data/operations/data/substanceprotein/substanceprotein-create-operation.ts
 var import_ulid130 = require("ulid");
@@ -32635,15 +32982,15 @@ async function updateSubstanceProteinRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/substanceprotein/substanceprotein.ts
-var router137 = import_express137.default.Router();
-router137.get("/", listSubstanceProteinsRoute);
-router137.get("/:id", getSubstanceProteinByIdRoute);
-router137.post("/", createSubstanceProteinRoute);
-router137.put("/:id", updateSubstanceProteinRoute);
-router137.delete("/:id", deleteSubstanceProteinRoute);
+var router138 = import_express138.default.Router();
+router138.get("/", listSubstanceProteinsRoute);
+router138.get("/:id", getSubstanceProteinByIdRoute);
+router138.post("/", createSubstanceProteinRoute);
+router138.put("/:id", updateSubstanceProteinRoute);
+router138.delete("/:id", deleteSubstanceProteinRoute);
 
 // src/data/rest-api/routes/data/substancereferenceinformation/substancereferenceinformation.ts
-var import_express138 = __toESM(require("express"));
+var import_express139 = __toESM(require("express"));
 
 // src/data/operations/data/substancereferenceinformation/substancereferenceinformation-create-operation.ts
 var import_ulid131 = require("ulid");
@@ -32854,15 +33201,15 @@ async function updateSubstanceReferenceInformationRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/substancereferenceinformation/substancereferenceinformation.ts
-var router138 = import_express138.default.Router();
-router138.get("/", listSubstanceReferenceInformationsRoute);
-router138.get("/:id", getSubstanceReferenceInformationByIdRoute);
-router138.post("/", createSubstanceReferenceInformationRoute);
-router138.put("/:id", updateSubstanceReferenceInformationRoute);
-router138.delete("/:id", deleteSubstanceReferenceInformationRoute);
+var router139 = import_express139.default.Router();
+router139.get("/", listSubstanceReferenceInformationsRoute);
+router139.get("/:id", getSubstanceReferenceInformationByIdRoute);
+router139.post("/", createSubstanceReferenceInformationRoute);
+router139.put("/:id", updateSubstanceReferenceInformationRoute);
+router139.delete("/:id", deleteSubstanceReferenceInformationRoute);
 
 // src/data/rest-api/routes/data/substancesourcematerial/substancesourcematerial.ts
-var import_express139 = __toESM(require("express"));
+var import_express140 = __toESM(require("express"));
 
 // src/data/operations/data/substancesourcematerial/substancesourcematerial-create-operation.ts
 var import_ulid132 = require("ulid");
@@ -33073,15 +33420,15 @@ async function updateSubstanceSourceMaterialRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/substancesourcematerial/substancesourcematerial.ts
-var router139 = import_express139.default.Router();
-router139.get("/", listSubstanceSourceMaterialsRoute);
-router139.get("/:id", getSubstanceSourceMaterialByIdRoute);
-router139.post("/", createSubstanceSourceMaterialRoute);
-router139.put("/:id", updateSubstanceSourceMaterialRoute);
-router139.delete("/:id", deleteSubstanceSourceMaterialRoute);
+var router140 = import_express140.default.Router();
+router140.get("/", listSubstanceSourceMaterialsRoute);
+router140.get("/:id", getSubstanceSourceMaterialByIdRoute);
+router140.post("/", createSubstanceSourceMaterialRoute);
+router140.put("/:id", updateSubstanceSourceMaterialRoute);
+router140.delete("/:id", deleteSubstanceSourceMaterialRoute);
 
 // src/data/rest-api/routes/data/substancespecification/substancespecification.ts
-var import_express140 = __toESM(require("express"));
+var import_express141 = __toESM(require("express"));
 
 // src/data/operations/data/substancespecification/substancespecification-create-operation.ts
 var import_ulid133 = require("ulid");
@@ -33292,15 +33639,15 @@ async function updateSubstanceSpecificationRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/substancespecification/substancespecification.ts
-var router140 = import_express140.default.Router();
-router140.get("/", listSubstanceSpecificationsRoute);
-router140.get("/:id", getSubstanceSpecificationByIdRoute);
-router140.post("/", createSubstanceSpecificationRoute);
-router140.put("/:id", updateSubstanceSpecificationRoute);
-router140.delete("/:id", deleteSubstanceSpecificationRoute);
+var router141 = import_express141.default.Router();
+router141.get("/", listSubstanceSpecificationsRoute);
+router141.get("/:id", getSubstanceSpecificationByIdRoute);
+router141.post("/", createSubstanceSpecificationRoute);
+router141.put("/:id", updateSubstanceSpecificationRoute);
+router141.delete("/:id", deleteSubstanceSpecificationRoute);
 
 // src/data/rest-api/routes/data/supplydelivery/supplydelivery.ts
-var import_express141 = __toESM(require("express"));
+var import_express142 = __toESM(require("express"));
 
 // src/data/operations/data/supplydelivery/supplydelivery-create-operation.ts
 var import_ulid134 = require("ulid");
@@ -33492,15 +33839,15 @@ async function updateSupplyDeliveryRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/supplydelivery/supplydelivery.ts
-var router141 = import_express141.default.Router();
-router141.get("/", listSupplyDeliverysRoute);
-router141.get("/:id", getSupplyDeliveryByIdRoute);
-router141.post("/", createSupplyDeliveryRoute);
-router141.put("/:id", updateSupplyDeliveryRoute);
-router141.delete("/:id", deleteSupplyDeliveryRoute);
+var router142 = import_express142.default.Router();
+router142.get("/", listSupplyDeliverysRoute);
+router142.get("/:id", getSupplyDeliveryByIdRoute);
+router142.post("/", createSupplyDeliveryRoute);
+router142.put("/:id", updateSupplyDeliveryRoute);
+router142.delete("/:id", deleteSupplyDeliveryRoute);
 
 // src/data/rest-api/routes/data/supplyrequest/supplyrequest.ts
-var import_express142 = __toESM(require("express"));
+var import_express143 = __toESM(require("express"));
 
 // src/data/operations/data/supplyrequest/supplyrequest-create-operation.ts
 var import_ulid135 = require("ulid");
@@ -33692,15 +34039,15 @@ async function updateSupplyRequestRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/supplyrequest/supplyrequest.ts
-var router142 = import_express142.default.Router();
-router142.get("/", listSupplyRequestsRoute);
-router142.get("/:id", getSupplyRequestByIdRoute);
-router142.post("/", createSupplyRequestRoute);
-router142.put("/:id", updateSupplyRequestRoute);
-router142.delete("/:id", deleteSupplyRequestRoute);
+var router143 = import_express143.default.Router();
+router143.get("/", listSupplyRequestsRoute);
+router143.get("/:id", getSupplyRequestByIdRoute);
+router143.post("/", createSupplyRequestRoute);
+router143.put("/:id", updateSupplyRequestRoute);
+router143.delete("/:id", deleteSupplyRequestRoute);
 
 // src/data/rest-api/routes/data/task/task.ts
-var import_express143 = __toESM(require("express"));
+var import_express144 = __toESM(require("express"));
 
 // src/data/operations/data/task/task-create-operation.ts
 var import_ulid136 = require("ulid");
@@ -34048,15 +34395,15 @@ async function updateTaskRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/task/task.ts
-var router143 = import_express143.default.Router();
-router143.get("/", listTasksRoute);
-router143.get("/:id", getTaskByIdRoute);
-router143.post("/", createTaskRoute);
-router143.put("/:id", updateTaskRoute);
-router143.delete("/:id", deleteTaskRoute);
+var router144 = import_express144.default.Router();
+router144.get("/", listTasksRoute);
+router144.get("/:id", getTaskByIdRoute);
+router144.post("/", createTaskRoute);
+router144.put("/:id", updateTaskRoute);
+router144.delete("/:id", deleteTaskRoute);
 
 // src/data/rest-api/routes/data/terminologycapabilities/terminologycapabilities.ts
-var import_express144 = __toESM(require("express"));
+var import_express145 = __toESM(require("express"));
 
 // src/data/operations/data/terminologycapabilities/terminologycapabilities-create-operation.ts
 var import_ulid137 = require("ulid");
@@ -34267,15 +34614,15 @@ async function updateTerminologyCapabilitiesRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/terminologycapabilities/terminologycapabilities.ts
-var router144 = import_express144.default.Router();
-router144.get("/", listTerminologyCapabilitiessRoute);
-router144.get("/:id", getTerminologyCapabilitiesByIdRoute);
-router144.post("/", createTerminologyCapabilitiesRoute);
-router144.put("/:id", updateTerminologyCapabilitiesRoute);
-router144.delete("/:id", deleteTerminologyCapabilitiesRoute);
+var router145 = import_express145.default.Router();
+router145.get("/", listTerminologyCapabilitiessRoute);
+router145.get("/:id", getTerminologyCapabilitiesByIdRoute);
+router145.post("/", createTerminologyCapabilitiesRoute);
+router145.put("/:id", updateTerminologyCapabilitiesRoute);
+router145.delete("/:id", deleteTerminologyCapabilitiesRoute);
 
 // src/data/rest-api/routes/data/testreport/testreport.ts
-var import_express145 = __toESM(require("express"));
+var import_express146 = __toESM(require("express"));
 
 // src/data/operations/data/testreport/testreport-create-operation.ts
 var import_ulid138 = require("ulid");
@@ -34467,15 +34814,15 @@ async function updateTestReportRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/testreport/testreport.ts
-var router145 = import_express145.default.Router();
-router145.get("/", listTestReportsRoute);
-router145.get("/:id", getTestReportByIdRoute);
-router145.post("/", createTestReportRoute);
-router145.put("/:id", updateTestReportRoute);
-router145.delete("/:id", deleteTestReportRoute);
+var router146 = import_express146.default.Router();
+router146.get("/", listTestReportsRoute);
+router146.get("/:id", getTestReportByIdRoute);
+router146.post("/", createTestReportRoute);
+router146.put("/:id", updateTestReportRoute);
+router146.delete("/:id", deleteTestReportRoute);
 
 // src/data/rest-api/routes/data/testscript/testscript.ts
-var import_express146 = __toESM(require("express"));
+var import_express147 = __toESM(require("express"));
 
 // src/data/operations/data/testscript/testscript-create-operation.ts
 var import_ulid139 = require("ulid");
@@ -34667,15 +35014,15 @@ async function updateTestScriptRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/testscript/testscript.ts
-var router146 = import_express146.default.Router();
-router146.get("/", listTestScriptsRoute);
-router146.get("/:id", getTestScriptByIdRoute);
-router146.post("/", createTestScriptRoute);
-router146.put("/:id", updateTestScriptRoute);
-router146.delete("/:id", deleteTestScriptRoute);
+var router147 = import_express147.default.Router();
+router147.get("/", listTestScriptsRoute);
+router147.get("/:id", getTestScriptByIdRoute);
+router147.post("/", createTestScriptRoute);
+router147.put("/:id", updateTestScriptRoute);
+router147.delete("/:id", deleteTestScriptRoute);
 
 // src/data/rest-api/routes/data/valueset/valueset.ts
-var import_express147 = __toESM(require("express"));
+var import_express148 = __toESM(require("express"));
 
 // src/data/operations/data/valueset/valueset-create-operation.ts
 var import_ulid140 = require("ulid");
@@ -34867,15 +35214,15 @@ async function updateValueSetRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/valueset/valueset.ts
-var router147 = import_express147.default.Router();
-router147.get("/", listValueSetsRoute);
-router147.get("/:id", getValueSetByIdRoute);
-router147.post("/", createValueSetRoute);
-router147.put("/:id", updateValueSetRoute);
-router147.delete("/:id", deleteValueSetRoute);
+var router148 = import_express148.default.Router();
+router148.get("/", listValueSetsRoute);
+router148.get("/:id", getValueSetByIdRoute);
+router148.post("/", createValueSetRoute);
+router148.put("/:id", updateValueSetRoute);
+router148.delete("/:id", deleteValueSetRoute);
 
 // src/data/rest-api/routes/data/verificationresult/verificationresult.ts
-var import_express148 = __toESM(require("express"));
+var import_express149 = __toESM(require("express"));
 
 // src/data/operations/data/verificationresult/verificationresult-create-operation.ts
 var import_ulid141 = require("ulid");
@@ -35074,15 +35421,15 @@ async function updateVerificationResultRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/verificationresult/verificationresult.ts
-var router148 = import_express148.default.Router();
-router148.get("/", listVerificationResultsRoute);
-router148.get("/:id", getVerificationResultByIdRoute);
-router148.post("/", createVerificationResultRoute);
-router148.put("/:id", updateVerificationResultRoute);
-router148.delete("/:id", deleteVerificationResultRoute);
+var router149 = import_express149.default.Router();
+router149.get("/", listVerificationResultsRoute);
+router149.get("/:id", getVerificationResultByIdRoute);
+router149.post("/", createVerificationResultRoute);
+router149.put("/:id", updateVerificationResultRoute);
+router149.delete("/:id", deleteVerificationResultRoute);
 
 // src/data/rest-api/routes/data/visionprescription/visionprescription.ts
-var import_express149 = __toESM(require("express"));
+var import_express150 = __toESM(require("express"));
 
 // src/data/operations/data/visionprescription/visionprescription-create-operation.ts
 var import_ulid142 = require("ulid");
@@ -35281,23 +35628,24 @@ async function updateVisionPrescriptionRoute(req, res) {
 }
 
 // src/data/rest-api/routes/data/visionprescription/visionprescription.ts
-var router149 = import_express149.default.Router();
-router149.get("/", listVisionPrescriptionsRoute);
-router149.get("/:id", getVisionPrescriptionByIdRoute);
-router149.post("/", createVisionPrescriptionRoute);
-router149.put("/:id", updateVisionPrescriptionRoute);
-router149.delete("/:id", deleteVisionPrescriptionRoute);
+var router150 = import_express150.default.Router();
+router150.get("/", listVisionPrescriptionsRoute);
+router150.get("/:id", getVisionPrescriptionByIdRoute);
+router150.post("/", createVisionPrescriptionRoute);
+router150.put("/:id", updateVisionPrescriptionRoute);
+router150.delete("/:id", deleteVisionPrescriptionRoute);
 
 // src/data/rest-api/rest-api.ts
-var app = (0, import_express150.default)();
+var app = (0, import_express151.default)();
 app.set("view engine", "ejs");
 app.set("views", import_node_path.default.join(__dirname, "views"));
-app.use(import_express150.default.json());
-app.use(import_express150.default.urlencoded({ extended: true }));
+app.use(import_express151.default.json());
+app.use(import_express151.default.urlencoded({ extended: true }));
 app.use(normalizeJsonBodyMiddleware);
 app.get("/", (_req, res) => {
   return res.status(200).json({ message: "POC App is running" });
 });
+app.use("/User", router7);
 app.use(
   [
     "/Account",
@@ -35452,164 +35800,164 @@ app.use(
   ],
   openHiContextMiddleware
 );
-app.use("/Account", router8);
-app.use("/ActivityDefinition", router9);
-app.use("/AdverseEvent", router10);
-app.use("/AllergyIntolerance", router11);
-app.use("/Appointment", router12);
-app.use("/AppointmentResponse", router13);
-app.use("/AuditEvent", router14);
-app.use("/Basic", router15);
-app.use("/BiologicallyDerivedProduct", router16);
-app.use("/BodyStructure", router17);
-app.use("/CapabilityStatement", router18);
-app.use("/CarePlan", router19);
-app.use("/CareTeam", router20);
-app.use("/CatalogEntry", router21);
-app.use("/ChargeItem", router22);
-app.use("/ChargeItemDefinition", router23);
-app.use("/Claim", router24);
-app.use("/ClaimResponse", router25);
-app.use("/ClinicalImpression", router26);
-app.use("/CodeSystem", router27);
-app.use("/CompartmentDefinition", router30);
-app.use("/Communication", router28);
-app.use("/CommunicationRequest", router29);
-app.use("/Composition", router31);
-app.use("/ConceptMap", router32);
-app.use("/Condition", router33);
-app.use("/Consent", router34);
-app.use("/Contract", router35);
-app.use("/Coverage", router36);
-app.use("/CoverageEligibilityRequest", router37);
-app.use("/CoverageEligibilityResponse", router38);
-app.use("/DetectedIssue", router39);
-app.use("/Device", router40);
-app.use("/DeviceDefinition", router41);
-app.use("/DeviceMetric", router42);
-app.use("/DeviceRequest", router43);
-app.use("/DeviceUseStatement", router44);
-app.use("/DiagnosticReport", router45);
-app.use("/DocumentManifest", router46);
-app.use("/DocumentReference", router47);
-app.use("/EffectEvidenceSynthesis", router48);
-app.use("/Encounter", router49);
-app.use("/Endpoint", router50);
-app.use("/EnrollmentRequest", router51);
-app.use("/EnrollmentResponse", router52);
-app.use("/EpisodeOfCare", router53);
-app.use("/EventDefinition", router54);
-app.use("/Evidence", router55);
-app.use("/EvidenceVariable", router56);
-app.use("/ExampleScenario", router57);
-app.use("/ExplanationOfBenefit", router58);
-app.use("/FamilyMemberHistory", router59);
-app.use("/Flag", router60);
-app.use("/Goal", router61);
-app.use("/GraphDefinition", router62);
-app.use("/Group", router63);
-app.use("/GuidanceResponse", router64);
-app.use("/HealthcareService", router65);
-app.use("/ImplementationGuide", router70);
-app.use("/ImagingStudy", router66);
-app.use("/Immunization", router67);
-app.use("/ImmunizationEvaluation", router68);
-app.use("/ImmunizationRecommendation", router69);
-app.use("/InsurancePlan", router71);
-app.use("/Invoice", router72);
-app.use("/Library", router73);
-app.use("/Linkage", router74);
-app.use("/List", router75);
-app.use("/Location", router76);
-app.use("/Measure", router77);
-app.use("/MeasureReport", router78);
-app.use("/Media", router79);
-app.use("/Medication", router80);
-app.use("/MedicationAdministration", router81);
-app.use("/MedicationDispense", router82);
-app.use("/MedicationKnowledge", router83);
-app.use("/MedicationRequest", router84);
-app.use("/MedicationStatement", router85);
-app.use("/MedicinalProduct", router86);
-app.use("/MedicinalProductAuthorization", router87);
+app.use("/Account", router9);
+app.use("/ActivityDefinition", router10);
+app.use("/AdverseEvent", router11);
+app.use("/AllergyIntolerance", router12);
+app.use("/Appointment", router13);
+app.use("/AppointmentResponse", router14);
+app.use("/AuditEvent", router15);
+app.use("/Basic", router16);
+app.use("/BiologicallyDerivedProduct", router17);
+app.use("/BodyStructure", router18);
+app.use("/CapabilityStatement", router19);
+app.use("/CarePlan", router20);
+app.use("/CareTeam", router21);
+app.use("/CatalogEntry", router22);
+app.use("/ChargeItem", router23);
+app.use("/ChargeItemDefinition", router24);
+app.use("/Claim", router25);
+app.use("/ClaimResponse", router26);
+app.use("/ClinicalImpression", router27);
+app.use("/CodeSystem", router28);
+app.use("/CompartmentDefinition", router31);
+app.use("/Communication", router29);
+app.use("/CommunicationRequest", router30);
+app.use("/Composition", router32);
+app.use("/ConceptMap", router33);
+app.use("/Condition", router34);
+app.use("/Consent", router35);
+app.use("/Contract", router36);
+app.use("/Coverage", router37);
+app.use("/CoverageEligibilityRequest", router38);
+app.use("/CoverageEligibilityResponse", router39);
+app.use("/DetectedIssue", router40);
+app.use("/Device", router41);
+app.use("/DeviceDefinition", router42);
+app.use("/DeviceMetric", router43);
+app.use("/DeviceRequest", router44);
+app.use("/DeviceUseStatement", router45);
+app.use("/DiagnosticReport", router46);
+app.use("/DocumentManifest", router47);
+app.use("/DocumentReference", router48);
+app.use("/EffectEvidenceSynthesis", router49);
+app.use("/Encounter", router50);
+app.use("/Endpoint", router51);
+app.use("/EnrollmentRequest", router52);
+app.use("/EnrollmentResponse", router53);
+app.use("/EpisodeOfCare", router54);
+app.use("/EventDefinition", router55);
+app.use("/Evidence", router56);
+app.use("/EvidenceVariable", router57);
+app.use("/ExampleScenario", router58);
+app.use("/ExplanationOfBenefit", router59);
+app.use("/FamilyMemberHistory", router60);
+app.use("/Flag", router61);
+app.use("/Goal", router62);
+app.use("/GraphDefinition", router63);
+app.use("/Group", router64);
+app.use("/GuidanceResponse", router65);
+app.use("/HealthcareService", router66);
+app.use("/ImplementationGuide", router71);
+app.use("/ImagingStudy", router67);
+app.use("/Immunization", router68);
+app.use("/ImmunizationEvaluation", router69);
+app.use("/ImmunizationRecommendation", router70);
+app.use("/InsurancePlan", router72);
+app.use("/Invoice", router73);
+app.use("/Library", router74);
+app.use("/Linkage", router75);
+app.use("/List", router76);
+app.use("/Location", router77);
+app.use("/Measure", router78);
+app.use("/MeasureReport", router79);
+app.use("/Media", router80);
+app.use("/Medication", router81);
+app.use("/MedicationAdministration", router82);
+app.use("/MedicationDispense", router83);
+app.use("/MedicationKnowledge", router84);
+app.use("/MedicationRequest", router85);
+app.use("/MedicationStatement", router86);
+app.use("/MedicinalProduct", router87);
+app.use("/MedicinalProductAuthorization", router88);
 app.use(
   "/MedicinalProductContraindication",
-  router88
+  router89
 );
-app.use("/MedicinalProductIngredient", router90);
-app.use("/MedicinalProductIndication", router89);
-app.use("/MedicinalProductInteraction", router91);
-app.use("/MedicinalProductManufactured", router92);
-app.use("/MedicinalProductPackaged", router93);
+app.use("/MedicinalProductIngredient", router91);
+app.use("/MedicinalProductIndication", router90);
+app.use("/MedicinalProductInteraction", router92);
+app.use("/MedicinalProductManufactured", router93);
+app.use("/MedicinalProductPackaged", router94);
 app.use(
   "/MedicinalProductPharmaceutical",
-  router94
+  router95
 );
 app.use(
   "/MedicinalProductUndesirableEffect",
-  router95
+  router96
 );
-app.use("/MessageDefinition", router96);
-app.use("/MessageHeader", router97);
-app.use("/MolecularSequence", router98);
-app.use("/NamingSystem", router99);
-app.use("/NutritionOrder", router100);
-app.use("/Observation", router101);
-app.use("/ObservationDefinition", router102);
-app.use("/OperationDefinition", router103);
-app.use("/Organization", router104);
-app.use("/OrganizationAffiliation", router105);
-app.use("/Patient", router106);
-app.use("/PaymentNotice", router107);
-app.use("/PaymentReconciliation", router108);
-app.use("/Person", router109);
-app.use("/PlanDefinition", router110);
-app.use("/Practitioner", router111);
-app.use("/PractitionerRole", router112);
-app.use("/Procedure", router113);
-app.use("/Provenance", router114);
-app.use("/Questionnaire", router115);
-app.use("/QuestionnaireResponse", router116);
-app.use("/RelatedPerson", router117);
-app.use("/RequestGroup", router118);
-app.use("/ResearchDefinition", router119);
-app.use("/ResearchElementDefinition", router120);
-app.use("/ResearchStudy", router121);
-app.use("/ResearchSubject", router122);
-app.use("/RiskAssessment", router123);
-app.use("/RiskEvidenceSynthesis", router124);
-app.use("/Schedule", router125);
-app.use("/ServiceRequest", router127);
-app.use("/SearchParameter", router126);
-app.use("/Slot", router128);
-app.use("/SpecimenDefinition", router130);
-app.use("/Specimen", router129);
-app.use("/StructureDefinition", router131);
-app.use("/StructureMap", router132);
-app.use("/Subscription", router133);
-app.use("/Substance", router134);
-app.use("/SubstanceNucleicAcid", router135);
-app.use("/SubstancePolymer", router136);
-app.use("/SubstanceProtein", router137);
-app.use("/SubstanceReferenceInformation", router138);
-app.use("/SubstanceSpecification", router140);
-app.use("/SubstanceSourceMaterial", router139);
-app.use("/SupplyDelivery", router141);
-app.use("/SupplyRequest", router142);
-app.use("/Task", router143);
-app.use("/TerminologyCapabilities", router144);
-app.use("/TestReport", router145);
-app.use("/TestScript", router146);
-app.use("/ValueSet", router147);
-app.use("/VerificationResult", router148);
-app.use("/VisionPrescription", router149);
+app.use("/MessageDefinition", router97);
+app.use("/MessageHeader", router98);
+app.use("/MolecularSequence", router99);
+app.use("/NamingSystem", router100);
+app.use("/NutritionOrder", router101);
+app.use("/Observation", router102);
+app.use("/ObservationDefinition", router103);
+app.use("/OperationDefinition", router104);
+app.use("/Organization", router105);
+app.use("/OrganizationAffiliation", router106);
+app.use("/Patient", router107);
+app.use("/PaymentNotice", router108);
+app.use("/PaymentReconciliation", router109);
+app.use("/Person", router110);
+app.use("/PlanDefinition", router111);
+app.use("/Practitioner", router112);
+app.use("/PractitionerRole", router113);
+app.use("/Procedure", router114);
+app.use("/Provenance", router115);
+app.use("/Questionnaire", router116);
+app.use("/QuestionnaireResponse", router117);
+app.use("/RelatedPerson", router118);
+app.use("/RequestGroup", router119);
+app.use("/ResearchDefinition", router120);
+app.use("/ResearchElementDefinition", router121);
+app.use("/ResearchStudy", router122);
+app.use("/ResearchSubject", router123);
+app.use("/RiskAssessment", router124);
+app.use("/RiskEvidenceSynthesis", router125);
+app.use("/Schedule", router126);
+app.use("/ServiceRequest", router128);
+app.use("/SearchParameter", router127);
+app.use("/Slot", router129);
+app.use("/SpecimenDefinition", router131);
+app.use("/Specimen", router130);
+app.use("/StructureDefinition", router132);
+app.use("/StructureMap", router133);
+app.use("/Subscription", router134);
+app.use("/Substance", router135);
+app.use("/SubstanceNucleicAcid", router136);
+app.use("/SubstancePolymer", router137);
+app.use("/SubstanceProtein", router138);
+app.use("/SubstanceReferenceInformation", router139);
+app.use("/SubstanceSpecification", router141);
+app.use("/SubstanceSourceMaterial", router140);
+app.use("/SupplyDelivery", router142);
+app.use("/SupplyRequest", router143);
+app.use("/Task", router144);
+app.use("/TerminologyCapabilities", router145);
+app.use("/TestReport", router146);
+app.use("/TestScript", router147);
+app.use("/ValueSet", router148);
+app.use("/VerificationResult", router149);
+app.use("/VisionPrescription", router150);
 app.use("/Configuration", router);
 app.use("/Membership", router2);
 app.use("/Role", router3);
 app.use("/RoleAssignment", router4);
 app.use("/Tenant", router5);
 app.use("/User", router6);
-app.use("/Workspace", router7);
+app.use("/Workspace", router8);
 app.use((_req, res) => {
   res.status(404).json({
     resourceType: "OperationOutcome",
@@ -35624,7 +35972,7 @@ app.use((_req, res) => {
 });
 
 // src/data/lambda/rest-api-lambda.handler.ts
-var handler = (0, import_serverless_express2.default)({ app });
+var handler = (0, import_serverless_express3.default)({ app });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   handler