@peopl-health/nexus 6.0.0-dev.466 → 6.0.0-dev.619

package/lib/clinical/stores/CtcaeCatalog.js

@@ -0,0 +1,67 @@
+const { Config_ID } = require('../../config/airtableConfig');
+
+const { getRecordByFilter } = require('../../services/airtableService');
+
+const CTCAE_TABLE = 'ctcae_catalog';
+
+let instance = null;
+
+class CtcaeCatalog {
+  constructor() {
+    this.symptomsByTerm = null;
+  }
+
+  async initialize() {
+    const records = await getRecordByFilter(Config_ID, CTCAE_TABLE, 'TRUE()');
+    if (!records) throw new Error(`ctcae catalog not readable from Config base: table ${CTCAE_TABLE}`);
+    this.symptomsByTerm = new Map(records.map((record) => {
+      const symptom = deepFreeze(this._parseCuratedSymptom(record));
+      return [symptom.ctcaeTerm, symptom];
+    }));
+  }
+
+  getCuratedSymptomsByTerm() {
+    this._assertLoaded();
+    return new Map(this.symptomsByTerm);
+  }
+
+  getGradeScale(ctcaeTerm) {
+    this._assertLoaded();
+    if (!ctcaeTerm) return null;
+    const grades = this.symptomsByTerm.get(ctcaeTerm)?.grades;
+    return grades && Object.keys(grades).length ? grades : null;
+  }
+
+  _assertLoaded() {
+    if (this.symptomsByTerm === null) throw new Error('ctcae catalog not loaded: call initialize() at startup');
+  }
+
+  _parseCuratedSymptom(record) {
+    return {
+      ctcaeTerm: record.ctcae_term,
+      spanishLabel: record.spanish_label || null,
+      patientPhrasesValidated: JSON.parse(record.patient_phrases_validated),
+      observedFieldsSchema: JSON.parse(record.observed_fields_schema),
+      criticalField: record.critical_field || null,
+      grades: record.grades ? JSON.parse(record.grades) : null,
+    };
+  }
+}
+
+function deepFreeze(value) {
+  if (value && typeof value === 'object') {
+    for (const nested of Object.values(value)) deepFreeze(nested);
+    Object.freeze(value);
+  }
+  return value;
+}
+
+function getCtcaeCatalog() {
+  if (!instance) instance = new CtcaeCatalog();
+  return instance;
+}
+
+module.exports = {
+  CtcaeCatalog,
+  getCtcaeCatalog,
+};

package/lib/controllers/conversationController.js

@@ -15,6 +15,7 @@ const { getMessages, countMessages, aggregateMessages } = require('../services/m
 
 const { sendMessage } = require('../core/NexusMessaging');
 const { getProviderVariant } = require('../clinical');
+const { attachShadowReplies } = require('../clinical/services/shadowMessageService');
 
 const Message = mongoose.models.Message;
 
@@ -91,13 +92,14 @@ const getConversationMessagesController = async (req, res) => {
     const total = await countMessages(query);
     const messages = await getMessages(query, { sort: { createdAt: -1 }, skip, limit });
     messages.forEach(msg => { msg.body = msg.plainBody || msg.body; });
+    const orderedMessages = await attachShadowReplies(messages.reverse(), code);
     const totalPages = Math.ceil(total / limit);
 
     res.status(200).json({
       success: true,
       phoneNumber: code,
       code,
-      messages: messages.reverse(),
+      messages: orderedMessages,
       pagination: {
         page,
         limit,

package/lib/controllers/templateController.js

@@ -11,14 +11,23 @@ const { requireProvider } = require('../core/NexusMessaging');
 const { Template } = require('../templates/templateStructure');
 const predefinedTemplates = require('../templates/predefinedTemplates');
 
-const _formatTemplate = (t) => ({
-  id: t.sid, sid: t.sid, name: t.name, friendlyName: t.friendlyName,
-  status: t.status, language: t.language, category: t.category,
-  created: t.dateCreated, updated: t.lastUpdated,
-  body: t.body, footer: t.footer, variables: t.variables,
+const _canonicalTemplate = (t) => ({
+  id: t.sid, sid: t.sid,
+  name: t.name || t.friendlyName || `template_${t.sid}`, friendlyName: t.friendlyName,
+  status: t.status || 'UNSUBMITTED', language: t.language || 'es', category: t.category || 'UTILITY',
+  createdAt: t.dateCreated, updatedAt: t.lastUpdated,
+  bodyText: t.body, footerText: t.footer,
+  variables: t.variables,
   components: t.components, buttons: t.buttons, approvalRequest: t.approvalRequest
 });
 
+const _legacyAliases = (t) => ({
+  created: t.dateCreated, updated: t.lastUpdated,
+  body: t.body, footer: t.footer
+});
+
+const _formatTemplate = (t) => ({ ..._canonicalTemplate(t), ..._legacyAliases(t) });
+
 const createTemplate = async (req, res) => {
   try {
     const { name, category, language, body, variables, footer, buttons, templateId } = req.body;
@@ -203,13 +212,19 @@ const submitForApproval = async (req, res) => {
     
     await TemplateModel.updateOne(
       { sid: contentSid },
-      { 
-        status: 'PENDING',
-        approvalRequest: {
-          sid: response.sid,
-          dateSubmitted: validSubmittedDate,
-          dateUpdated: validUpdatedDate,
-          rejectionReason: response.rejection_reason || ''
+      {
+        $set: {
+          status: 'PENDING',
+          approvalRequest: {
+            sid: response.sid,
+            dateSubmitted: validSubmittedDate,
+            dateUpdated: validUpdatedDate,
+            rejectionReason: response.rejection_reason || ''
+          }
+        },
+        $setOnInsert: {
+          name: String(name || `template_${contentSid}`).replace(/[^a-zA-Z0-9_]/g, '_').toLowerCase(),
+          friendlyName: approvalName
         }
       },
       { upsert: true }

package/lib/core/BatchingManager.js

@@ -28,7 +28,8 @@ class BatchingManager {
   }
 
   isActiveRun(chatId, runId) {
-    return this.activeRequests.get(chatId) === runId && !this.abandonedRuns.has(runId);
+    const current = this.activeRequests.get(chatId);
+    return (current === undefined || current === runId) && !this.abandonedRuns.has(runId);
   }
 
   async handleBatchedProcessing(chatId, processingFn, sendResponseFn) {
@@ -106,7 +107,6 @@ class BatchingManager {
 
   _checkAbandoned(runId) {
     if (this.abandonedRuns.has(runId)) {
-      this.abandonedRuns.delete(runId);
       logger.debug('[BatchingManager] Run was abandoned', { runId });
       return true;
     }

package/lib/eval/EvalProvider.js

@@ -154,13 +154,14 @@ class EvalProvider {
             assistant,
             presetToolIds,
           });
-          const activeToolSchemas = filtered && toolIds.length > 0
+          const activeToolSchemas = filtered
             ? toolSchemas.filter(s => toolIds.includes(s.function?.name))
             : toolSchemas;
 
           toolSchemas = activeToolSchemas;
-          const toolNames = activeToolSchemas.map(s => s.function?.name).join(', ');
-          devContent += `\n\nYou only have access to these tools: ${toolNames}. Do not call or reference any tools not listed here.`;
+          if (activeToolSchemas.length > 0) {
+            devContent += `\n\nYou only have access to these tools: ${activeToolSchemas.map(s => s.function?.name).join(', ')}. Do not call or reference any tools not listed here.`;
+          }
         }
       } catch {
         logger.warn('[NexusEvalProvider] Failed to resolve assistant', { assistantId });

package/lib/fhir/config/catalogConfig.js

@@ -0,0 +1,46 @@
+const { Config_ID } = require('../../config/airtableConfig');
+
+const { getRecordByFilter } = require('../../services/airtableService');
+
+const MapCache = require('../../utils/MapCache');
+const { safeParse } = require('../../utils/jsonUtils');
+
+const CATALOG_TABLE = 'fhir_resources';
+const CACHE_TTL = 5 * 60 * 1000;
+const CACHE_KEY = 'fhirCatalog';
+
+const cache = new MapCache({ maxSize: 1, ttl: CACHE_TTL });
+
+async function load() {
+  const cached = cache.get(CACHE_KEY);
+  if (cached) return cached;
+
+  const records = await getRecordByFilter(Config_ID, CATALOG_TABLE, 'TRUE()');
+  if (!records || !records.length) {
+    throw new Error(`fhir catalog missing from Config base: table ${CATALOG_TABLE} is empty or unreachable`);
+  }
+
+  const catalog = Object.create(null);
+  for (const row of records) {
+    if (!row.resource) continue;
+    catalog[row.resource] = {
+      resourceType: row.resource,
+      collection: row.resource,
+      identifierSlugs: safeParse(row.identifierSlugs, []),
+      producers: safeParse(row.producers, []),
+    };
+  }
+
+  const resourceTypes = Object.keys(catalog);
+  if (!resourceTypes.length) {
+    throw new Error(`fhir catalog is empty: no rows in ${CATALOG_TABLE} carry a resource type`);
+  }
+
+  const result = { catalog, resourceTypes };
+  cache.set(CACHE_KEY, result);
+  return result;
+}
+
+module.exports = {
+  getCatalog: () => load(),
+};

package/lib/fhir/config/connection.js

@@ -0,0 +1,11 @@
+const { getDb, getModelDatabase } = require('../../config/mongoConfig');
+
+function fhirConnection() {
+  const name = getModelDatabase('Fhir');
+  if (!name) throw new Error('Fhir db not mapped (setModelDatabases)');
+  return getDb(name);
+}
+
+module.exports = {
+  fhirConnection,
+};

package/lib/fhir/config/fhirConfig.js

@@ -0,0 +1,41 @@
+const { Config_ID } = require('../../config/airtableConfig');
+
+const { getRecordByFilter } = require('../../services/airtableService');
+
+const { safeParse } = require('../../utils/jsonUtils');
+
+const FHIR_CONFIG_TABLE = 'fhir';
+const REQUIRED_KEYS = ['IDENT_BASE', 'EXT_BASE', 'SYSTEMS', 'DEVICE_ID', 'ORGANIZATION_ID'];
+
+const state = { identBase: null, extBase: null, systems: null, deviceId: null, organizationId: null };
+
+async function initialize() {
+  const records = await getRecordByFilter(Config_ID, FHIR_CONFIG_TABLE, 'TRUE()');
+  if (!records) throw new Error(`fhir config not readable from Config base: table ${FHIR_CONFIG_TABLE}`);
+  const byKey = Object.fromEntries(records.map((r) => [r.config, r.value]));
+
+  const missing = REQUIRED_KEYS.filter((k) => !byKey[k]);
+  if (missing.length) throw new Error(`fhir config missing from Config base: ${missing.join(', ')}`);
+
+  const systems = safeParse(byKey.SYSTEMS, null);
+  if (!systems) throw new Error('fhir config SYSTEMS is not valid JSON');
+
+  state.identBase = byKey.IDENT_BASE;
+  state.extBase = byKey.EXT_BASE;
+  state.systems = systems;
+  state.deviceId = byKey.DEVICE_ID;
+  state.organizationId = byKey.ORGANIZATION_ID;
+}
+
+function assertLoaded() {
+  if (state.systems === null) throw new Error('fhir config not loaded: call initialize() at startup');
+}
+
+module.exports = {
+  initialize,
+  getIdentBase: () => { assertLoaded(); return state.identBase; },
+  getExtBase: () => { assertLoaded(); return state.extBase; },
+  getSystems: () => { assertLoaded(); return state.systems; },
+  getDeviceId: () => { assertLoaded(); return state.deviceId; },
+  getOrganizationId: () => { assertLoaded(); return state.organizationId; },
+};

package/lib/fhir/constants/projectionSlugs.js

@@ -0,0 +1,3 @@
+const MENTION_SLUG = 'clinical-mention';
+
+module.exports = { MENTION_SLUG };

package/lib/fhir/helpers/elementHelper.js

@@ -0,0 +1,33 @@
+const { fhirId, identifierSystem, extensionUrl } = require('./fhirHelper');
+
+function identifier(slug, value) {
+  return { system: identifierSystem(slug), value };
+}
+
+function reference(resourceType, id) {
+  return { reference: `${resourceType}/${fhirId(id)}` };
+}
+
+function patientReference(patientId) {
+  return reference('Patient', patientId);
+}
+
+function codeableConcept(text, { code = null, system = null, display = null } = {}) {
+  const out = { text };
+  if (code !== null && system !== null) {
+    out.coding = [{ system, code, ...(display ? { display } : {}) }];
+  }
+  return out;
+}
+
+function extension(name, value) {
+  return { url: extensionUrl(name), ...value };
+}
+
+module.exports = {
+  identifier,
+  reference,
+  patientReference,
+  codeableConcept,
+  extension,
+};

package/lib/fhir/index.js

@@ -0,0 +1,21 @@
+const { registerProjector, project, storeResources } = require('./services/fhirService');
+const { storeClinicalMentions } = require('./services/clinicalMentionService');
+const { registerAllProjectors } = require('./projections/registerProjectors');
+const { getFhirStore, ensureFhirIndexes } = require('./stores/fhirStore');
+const fhirConfig = require('./config/fhirConfig');
+
+async function initialize() {
+  registerAllProjectors();
+  await fhirConfig.initialize();
+  await ensureFhirIndexes();
+}
+
+module.exports = {
+  initialize,
+  registerProjector,
+  project,
+  storeResources,
+  storeClinicalMentions,
+  getFhirStore,
+  ensureFhirIndexes,
+};

package/lib/fhir/models/envelopeModel.js

@@ -0,0 +1,132 @@
+const mongoose = require('mongoose');
+
+const SYMPTOM_SYSTEM_SUFFIX = '/pro-ctcae';
+
+const envelopeSchema = new mongoose.Schema(
+  {
+    resourceKey: { type: String, required: true, unique: true },
+    index: {
+      resourceType: { type: String, default: null },
+      patient: { type: String, default: null },
+      date: { type: Date, default: null },
+      reference: { type: String, default: null },
+      symptomTerm: { type: String, default: null },
+    },
+    resource: { type: mongoose.Schema.Types.Mixed, required: true },
+    meta: {
+      version: { type: Number, default: 1 },
+      deleted: { type: Boolean, default: false },
+    },
+  },
+  { minimize: false, versionKey: false, timestamps: true },
+);
+
+envelopeSchema.index({ 'index.patient': 1, 'index.date': -1 });
+envelopeSchema.index({ 'index.patient': 1, 'index.symptomTerm': 1, 'index.date': -1 });
+envelopeSchema.index({ 'index.reference': 1 }, { partialFilterExpression: { 'index.reference': { $type: 'string' } } });
+envelopeSchema.index({ 'resource.status': 1 }, { sparse: true });
+
+envelopeSchema.statics.resourceKeyOf = function resourceKeyOf(resource) {
+  const { resourceType } = resource;
+  if (!resourceType) throw new Error('resource has no resourceType');
+  const { system, value } = businessIdentifier(resource);
+  if (system && value) return `${resourceType}|${system}|${value}`;
+  if (resource.id) return `${resourceType}|id|${resource.id}`;
+  const targets = allReferences(resource.target);
+  if (targets.length) {
+    const recorded = resource.recorded ? `|${resource.recorded}` : '';
+    return `${resourceType}|target|${[...targets].sort().join(',')}${recorded}`;
+  }
+  throw new Error(`${resourceType} has no usable identifier (system+value), id, or target for a stable key`);
+};
+
+envelopeSchema.statics.deriveIndex = function deriveIndex(resource) {
+  const date =
+    resource.effectiveDateTime ||
+    resource.authored ||
+    resource.authoredOn ||
+    resource.date ||
+    resource.recorded ||
+    resource.recordedDate ||
+    resource.onsetDateTime ||
+    resource.occurrenceDateTime ||
+    resource.start ||
+    (resource.effectivePeriod || {}).start ||
+    (resource.period || {}).start ||
+    (resource.actualPeriod || {}).start ||
+    ((resource.requestedPeriod || [])[0] || {}).start ||
+    null;
+  return {
+    resourceType: resource.resourceType || null,
+    patient: patientReferenceOf(resource),
+    date: instantOf(date),
+    reference: resource.resourceType && resource.id ? `${resource.resourceType}/${resource.id}` : null,
+    symptomTerm: symptomTermOf(resource),
+  };
+};
+
+envelopeSchema.statics.buildEnvelope = function buildEnvelope(resource) {
+  return {
+    resourceKey: this.resourceKeyOf(resource),
+    index: this.deriveIndex(resource),
+    resource,
+    meta: { version: 1, deleted: false },
+  };
+};
+
+function instantOf(value) {
+  if (!value) return null;
+  const instant = new Date(value);
+  return Number.isNaN(instant.getTime()) ? null : instant;
+}
+
+function symptomTermOf(resource) {
+  for (const coding of (resource.code || {}).coding || []) {
+    const system = (coding || {}).system;
+    if (typeof system === 'string' && system.endsWith(SYMPTOM_SYSTEM_SUFFIX)) return coding.code || null;
+  }
+  return null;
+}
+
+function businessIdentifier(resource) {
+  for (const identifier of resource.identifier || []) {
+    const system = (identifier || {}).system;
+    const value = (identifier || {}).value;
+    if (system && value) return { system, value };
+  }
+  return { system: null, value: null };
+}
+
+function allReferences(node) {
+  if (Array.isArray(node)) return node.flatMap(allReferences);
+  if (node && typeof node === 'object' && typeof node.reference === 'string') return [node.reference];
+  return [];
+}
+
+const referenceOf = (node) => node?.reference || node?.[0]?.reference || null;
+
+function patientReferenceOf(resource) {
+  const patientRef = (node) => {
+    for (const entry of Array.isArray(node) ? node : [node]) {
+      if (entry?.reference && entry.reference.startsWith('Patient/')) return entry.reference;
+    }
+    return null;
+  };
+  const participantRef = () => {
+    for (const participant of resource.participant || []) {
+      const reference = referenceOf(participant.actor);
+      if (reference && reference.startsWith('Patient/')) return reference;
+    }
+    return null;
+  };
+  return (
+    patientRef(resource.subject) ||
+    patientRef(resource.patient) ||
+    patientRef(resource.performer) ||
+    participantRef()
+  );
+}
+
+module.exports = {
+  envelopeSchema,
+};

package/lib/fhir/models/historyModel.js

@@ -0,0 +1,19 @@
+const mongoose = require('mongoose');
+
+const historySchema = new mongoose.Schema(
+  {
+    resourceKey: { type: String, required: true },
+    resource: { type: mongoose.Schema.Types.Mixed, required: true },
+    meta: {
+      version: { type: Number, required: true },
+      deleted: { type: Boolean, default: false },
+    },
+  },
+  { minimize: false, versionKey: false, timestamps: true },
+);
+
+historySchema.index({ resourceKey: 1, 'meta.version': 1 }, { unique: true });
+
+module.exports = {
+  historySchema,
+};

package/lib/fhir/projections/clinicalMentionProjection.js

@@ -0,0 +1,65 @@
+const { getSystems } = require('../config/fhirConfig');
+const { codeableConcept, extension } = require('../helpers/elementHelper');
+const { MENTION_SLUG } = require('../constants/projectionSlugs');
+const { Observation } = require('../resources/Observation');
+const { Condition } = require('../resources/Condition');
+const { MedicationStatement } = require('../resources/MedicationStatement');
+const { Procedure } = require('../resources/Procedure');
+const { Appointment } = require('../resources/Appointment');
+const { Provenance } = require('../resources/Provenance');
+
+const PROJECTOR_NAME = 'clinicalMention';
+const ACTIVITY_TEXT = 'clinical-mention-extraction';
+
+const DEDICATED_AGGREGATE = new Set(['comorbidity', 'allergy', 'performance_status']);
+
+function projectClinicalMention(mention) {
+  const { fact, provenance } = mention;
+
+  if (DEDICATED_AGGREGATE.has(fact.category)) return [];
+
+  const assertion = fact.assertion;
+  const extensions = [
+    extension('mention-assertion-negated', { valueBoolean: assertion.negated }),
+    extension('mention-assertion-hedged', { valueBoolean: assertion.hedged }),
+    extension('mention-assertion-experiencer', { valueString: assertion.experiencer }),
+    extension('mention-assertion-temporal', { valueString: assertion.temporal }),
+    extension('mention-assertion-confidence', { valueDecimal: assertion.confidence }),
+  ];
+  if (fact.temporality) {
+    extensions.push(extension('mention-temporality', { valueString: fact.temporality }));
+  }
+
+  const code = fact.ctcaeTerm
+    ? codeableConcept(fact.canonicalTerm, { code: fact.ctcaeTerm, system: getSystems().ctcae, display: fact.ctcaeTerm })
+    : codeableConcept(fact.canonicalTerm);
+  const primary = primaryResource({ fact, provenance, code, extensions });
+  return [primary, Provenance.fromMentionProjection({ target: primary, provenance, activityText: ACTIVITY_TEXT })];
+}
+
+function primaryResource({ fact, provenance, code, extensions }) {
+  const assertion = fact.assertion;
+  const args = { fact, provenance, code, extensions, slug: MENTION_SLUG };
+  if (fact.category === 'medication' || fact.category === 'adherence') {
+    return MedicationStatement.fromMentionProjection(args);
+  }
+  if (fact.category === 'treatment') {
+    return Procedure.fromMentionProjection(args);
+  }
+  if (fact.category === 'appointment') {
+    return Appointment.fromMentionProjection(args);
+  }
+  const currentAffirmedDiagnosis =
+    (fact.category === 'diagnosis' || fact.category === 'indication') &&
+    assertion.temporal === 'current' &&
+    !assertion.negated;
+  if (currentAffirmedDiagnosis) {
+    return Condition.fromMentionProjection(args);
+  }
+  return Observation.fromMentionProjection(args);
+}
+
+module.exports = {
+  projectClinicalMention,
+  PROJECTOR_NAME,
+};

package/lib/fhir/projections/registerProjectors.js

@@ -0,0 +1,14 @@
+const { registerProjector } = require('../services/fhirService');
+const { projectClinicalMention, PROJECTOR_NAME: MENTION_PROJECTOR_NAME } = require('./clinicalMentionProjection');
+
+const PROJECTORS = [
+  { name: MENTION_PROJECTOR_NAME, project: projectClinicalMention },
+];
+
+function registerAllProjectors() {
+  for (const projector of PROJECTORS) {
+    registerProjector(projector.name, projector.project);
+  }
+}
+
+module.exports = { registerAllProjectors };

package/lib/fhir/resources/Appointment.js

@@ -0,0 +1,28 @@
+const { fhirId } = require('../helpers/fhirHelper');
+const { identifier, patientReference } = require('../helpers/elementHelper');
+
+class Appointment {
+  constructor(payload) {
+    Object.assign(this, payload);
+  }
+
+  static fromMentionProjection({ fact, provenance, extensions, slug }) {
+    const assertion = fact.assertion;
+    const notes = provenance.verbatimQuotes && provenance.verbatimQuotes.length
+      ? provenance.verbatimQuotes.map((text) => ({ text }))
+      : null;
+    const payload = {
+      resourceType: 'Appointment',
+      id: fhirId(fact.mentionId),
+      identifier: [identifier(slug, fact.mentionId)],
+      status: assertion.negated ? 'cancelled' : 'proposed',
+      description: fact.canonicalTerm,
+      participant: [{ actor: patientReference(fact.patientId), status: 'accepted' }],
+      extension: extensions,
+    };
+    if (notes) payload.note = notes;
+    return new Appointment(payload);
+  }
+}
+
+module.exports = { Appointment };

package/lib/fhir/resources/Condition.js

@@ -0,0 +1,34 @@
+const { getSystems } = require('../config/fhirConfig');
+const { fhirId } = require('../helpers/fhirHelper');
+const { identifier, patientReference, codeableConcept } = require('../helpers/elementHelper');
+
+class Condition {
+  constructor(payload) {
+    Object.assign(this, payload);
+  }
+
+  static fromMentionProjection({ fact, provenance, code, extensions, slug }) {
+    const assertion = fact.assertion;
+    const notes = provenance.verbatimQuotes && provenance.verbatimQuotes.length
+      ? provenance.verbatimQuotes.map((text) => ({ text }))
+      : null;
+    const verification = assertion.hedged ? 'unconfirmed' : 'provisional';
+    const systems = getSystems();
+    const payload = {
+      resourceType: 'Condition',
+      id: fhirId(fact.mentionId),
+      identifier: [identifier(slug, fact.mentionId)],
+      clinicalStatus: codeableConcept('active', { code: 'active', system: systems.conditionClinical }),
+      verificationStatus: codeableConcept(verification, { code: verification, system: systems.conditionVerStatus }),
+      category: [codeableConcept('problem-list-item', { code: 'problem-list-item', system: systems.conditionCategory })],
+      code,
+      subject: patientReference(fact.patientId),
+      recordedDate: new Date(provenance.recordedAt).toISOString(),
+      extension: extensions,
+    };
+    if (notes) payload.note = notes;
+    return new Condition(payload);
+  }
+}
+
+module.exports = { Condition };