@atomic-ehr/fhirpath 0.0.1 → 0.0.2-canary.2fee5d9.20250808110507

package/src/interpreter.ts

@@ -18,6 +18,8 @@ import { Registry } from './registry';
 import * as operations from './operations';
 import type { EvaluationResult, FunctionEvaluator, NodeEvaluator, OperationEvaluator, RuntimeContext } from './types';
 import { createQuantity } from './quantity-value';
+import { box, unbox, ensureBoxed, type FHIRPathValue } from './boxing';
+import { Errors } from './errors';
 
 /**
  * Runtime context manager that provides efficient prototype-based context operations
@@ -166,9 +168,11 @@ export class Interpreter {
   private nodeEvaluators: Record<NodeType, NodeEvaluator>;
   private operationEvaluators: Map<string, OperationEvaluator>;
   private functionEvaluators: Map<string, FunctionEvaluator>;
+  private modelProvider?: import('./types').ModelProvider<any>;
 
-  constructor(registry?: Registry) {
+  constructor(registry?: Registry, modelProvider?: import('./types').ModelProvider<any>) {
     this.registry = registry || new Registry();
+    this.modelProvider = modelProvider;
     this.operationEvaluators = new Map();
     this.functionEvaluators = new Map();
     
@@ -225,45 +229,171 @@ export class Interpreter {
       input = input === null || input === undefined ? [] : [input];
     }
 
+    // Box the initial input values
+    const boxedInput = input.map(value => ensureBoxed(value));
+
+    // Set current node in context
+    const contextWithNode = RuntimeContextManager.copy(context);
+    contextWithNode.currentNode = node;
+
     // Dispatch to appropriate evaluator
     const evaluator = this.nodeEvaluators[node.type];
     if (!evaluator) {
-      throw new Error(`Unknown node type: ${node.type}`);
+      throw Errors.unknownNodeType(node.type);
     }
 
-    return evaluator(node, input, context);
+    return evaluator(node, boxedInput, contextWithNode);
   }
 
   private createInitialContext(input: any[]): RuntimeContext {
     const context = RuntimeContextManager.create(input);
     // Set $this to initial input
     context.variables['$this'] = input;
+    // Add model provider if available
+    if (this.modelProvider) {
+      context.modelProvider = this.modelProvider;
+    }
     return context;
   }
 
   // Literal node evaluator
-  private evaluateLiteral(node: ASTNode, input: any[], context: RuntimeContext): EvaluationResult {
+  private evaluateLiteral(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): EvaluationResult {
     const literal = node as LiteralNode;
+    
+    // Box the literal value with appropriate type info
+    let typeInfo: import('./types').TypeInfo | undefined;
+    const value = literal.value;
+    
+    if (typeof value === 'string') {
+      typeInfo = { type: 'String', singleton: true };
+    } else if (typeof value === 'number') {
+      typeInfo = Number.isInteger(value) ? 
+        { type: 'Integer', singleton: true } : 
+        { type: 'Decimal', singleton: true };
+    } else if (typeof value === 'boolean') {
+      typeInfo = { type: 'Boolean', singleton: true };
+    }
+    
     return {
-      value: [literal.value],
+      value: [box(literal.value, typeInfo)],
       context
     };
   }
 
   // Identifier node evaluator
-  private evaluateIdentifier(node: ASTNode, input: any[], context: RuntimeContext): EvaluationResult {
+  private evaluateIdentifier(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): EvaluationResult {
     const identifier = node as IdentifierNode;
     const name = identifier.name;
 
-    // Navigate property on each item in input
-    const results: any[] = [];
-    for (const item of input) {
-      if (item && typeof item === 'object' && name in item) {
-        const value = item[name];
-        if (Array.isArray(value)) {
-          results.push(...value);
-        } else if (value !== null && value !== undefined) {
-          results.push(value);
+    // Navigate property on each boxed item in input
+    const results: FHIRPathValue[] = [];
+    
+    // Get the type info from the node (set by analyzer)
+    const nodeTypeInfo = node.typeInfo;
+    
+    for (const boxedItem of input) {
+      const item = unbox(boxedItem);
+      
+      // Special handling for primitive extension navigation
+      if (name === 'extension' && boxedItem.primitiveElement?.extension) {
+        // Navigation from a primitive value to its extensions
+        for (const ext of boxedItem.primitiveElement.extension) {
+          results.push(box(ext, nodeTypeInfo || { type: 'Any', singleton: false }));
+        }
+        continue;
+      }
+      
+      if (item && typeof item === 'object') {
+        // Check if this is a choice type navigation
+        if (nodeTypeInfo?.modelContext && typeof nodeTypeInfo.modelContext === 'object' &&
+            'isUnion' in nodeTypeInfo.modelContext && 
+            nodeTypeInfo.modelContext.isUnion && 'choices' in nodeTypeInfo.modelContext &&
+            Array.isArray(nodeTypeInfo.modelContext.choices)) {
+          // For choice types, look for any of the choice properties
+          for (const choice of nodeTypeInfo.modelContext.choices) {
+            const choiceName = choice.choiceName;
+            if (choiceName && choiceName in item) {
+              const value = item[choiceName];
+              const primitiveElementName = `_${choiceName}`;
+              const primitiveElement = (primitiveElementName in item) ? item[primitiveElementName] : undefined;
+              
+              // Box with the specific choice type
+              const choiceTypeInfo = {
+                type: choice.type,
+                singleton: !Array.isArray(value),
+                modelContext: choice
+              };
+              
+              if (Array.isArray(value)) {
+                for (const v of value) {
+                  results.push(box(v, { ...choiceTypeInfo, singleton: true }, primitiveElement));
+                }
+              } else if (value !== null && value !== undefined) {
+                results.push(box(value, choiceTypeInfo, primitiveElement));
+              }
+            }
+          }
+        } else if (name in item) {
+          // Regular property navigation
+          const value = item[name];
+          const primitiveElementName = `_${name}`;
+          const primitiveElement = (primitiveElementName in item) ? item[primitiveElementName] : undefined;
+          
+          if (Array.isArray(value)) {
+            // Box each array element with type info
+            // For arrays, make the type singleton since each element is a single value
+            const elementTypeInfo = nodeTypeInfo ? { ...nodeTypeInfo, singleton: true } : undefined;
+            for (const v of value) {
+              // Special handling for FHIR resources - use their resourceType
+              // Do this if the property navigation has type 'Any' (polymorphic reference) or no type info
+              if (v && typeof v === 'object' && 'resourceType' in v && typeof v.resourceType === 'string') {
+                // Get full type info from model provider if available
+                let resourceTypeInfo;
+                if (context.modelProvider) {
+                  resourceTypeInfo = context.modelProvider.getType(v.resourceType);
+                  if (resourceTypeInfo) {
+                    // Make it singleton since it's a single element in the array
+                    resourceTypeInfo = { ...resourceTypeInfo, singleton: true };
+                  }
+                }
+                if (!resourceTypeInfo) {
+                  // Fallback to basic type info
+                  resourceTypeInfo = {
+                    type: v.resourceType as import('./types').TypeName,
+                    singleton: true
+                  };
+                }
+                results.push(box(v, resourceTypeInfo, primitiveElement));
+              } else {
+                results.push(box(v, elementTypeInfo, primitiveElement));
+              }
+            }
+          } else if (value !== null && value !== undefined) {
+            // Special handling for FHIR resources - use their resourceType
+            // Do this if the property navigation has type 'Any' (polymorphic reference) or no type info
+            if (value && typeof value === 'object' && 'resourceType' in value && typeof value.resourceType === 'string') {
+              // Get full type info from model provider if available
+              let resourceTypeInfo;
+              if (context.modelProvider) {
+                resourceTypeInfo = context.modelProvider.getType(value.resourceType);
+                if (resourceTypeInfo) {
+                  // Preserve singleton status
+                  resourceTypeInfo = { ...resourceTypeInfo, singleton: !Array.isArray(value) };
+                }
+              }
+              if (!resourceTypeInfo) {
+                // Fallback to basic type info
+                resourceTypeInfo = {
+                  type: value.resourceType as import('./types').TypeName,
+                  singleton: !Array.isArray(value)
+                };
+              }
+              results.push(box(value, resourceTypeInfo, primitiveElement));
+            } else {
+              // Box single value with primitive element if available
+              results.push(box(value, nodeTypeInfo, primitiveElement));
+            }
+          }
         }
       }
     }
@@ -275,14 +405,15 @@ export class Interpreter {
   }
 
   // TypeOrIdentifier node evaluator (handles Patient, Observation, etc.)
-  private evaluateTypeOrIdentifier(node: ASTNode, input: any[], context: RuntimeContext): EvaluationResult {
+  private evaluateTypeOrIdentifier(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): EvaluationResult {
     const typeOrId = node as TypeOrIdentifierNode;
     const name = typeOrId.name;
 
     // First try as type filter
-    const filtered = input.filter(item => 
-      item && typeof item === 'object' && item.resourceType === name
-    );
+    const filtered = input.filter(boxedItem => {
+      const item = unbox(boxedItem);
+      return item && typeof item === 'object' && item.resourceType === name;
+    });
 
     if (filtered.length > 0) {
       return { value: filtered, context };
@@ -293,7 +424,7 @@ export class Interpreter {
   }
 
   // Binary operator evaluator
-  private evaluateBinary(node: ASTNode, input: any[], context: RuntimeContext): EvaluationResult {
+  private evaluateBinary(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): EvaluationResult {
     const binary = node as BinaryNode;
     const operator = binary.operator;
 
@@ -335,11 +466,11 @@ export class Interpreter {
     }
 
     // If no evaluator found, throw error
-    throw new Error(`No evaluator found for binary operator: ${operator}`);
+    throw Errors.noEvaluatorFound('binary operator', operator);
   }
 
   // Unary operator evaluator
-  private evaluateUnary(node: ASTNode, input: any[], context: RuntimeContext): EvaluationResult {
+  private evaluateUnary(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): EvaluationResult {
     const unary = node as UnaryNode;
     const operator = unary.operator;
     
@@ -358,11 +489,11 @@ export class Interpreter {
     }
 
     // If no evaluator found, throw error
-    throw new Error(`No evaluator found for unary operator: ${operator}`);
+    throw Errors.noEvaluatorFound('unary operator', operator);
   }
 
   // Variable evaluator
-  private evaluateVariable(node: ASTNode, input: any[], context: RuntimeContext): EvaluationResult {
+  private evaluateVariable(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): EvaluationResult {
     const variable = node as VariableNode;
     const name = variable.name;
 
@@ -371,17 +502,19 @@ export class Interpreter {
     if (value !== undefined) {
       // Ensure value is always an array
       const arrayValue = Array.isArray(value) ? value : [value];
-      return { value: arrayValue, context };
+      // Box each value in the array
+      const boxedValues = arrayValue.map(v => ensureBoxed(v));
+      return { value: boxedValues, context };
     }
 
     // According to FHIRPath spec: attempting to access an undefined environment variable will result in an error
-    throw new Error(`Variable '${name}' is not defined in the current scope`);
+    throw Errors.variableNotDefined(name);
   }
 
   // Collection evaluator
-  private evaluateCollection(node: ASTNode, input: any[], context: RuntimeContext): EvaluationResult {
+  private evaluateCollection(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): EvaluationResult {
     const collection = node as CollectionNode;
-    const results: any[] = [];
+    const results: FHIRPathValue[] = [];
 
     for (const element of collection.elements) {
       const result = this.evaluate(element, input, context);
@@ -403,11 +536,11 @@ export class Interpreter {
     }
 
     // No function found in registry
-    throw new Error(`Unknown function: ${funcName}`);
+    throw Errors.unknownFunction(funcName);
   }
 
   // Index evaluator
-  private evaluateIndex(node: ASTNode, input: any[], context: RuntimeContext): EvaluationResult {
+  private evaluateIndex(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): EvaluationResult {
     const indexNode = node as IndexNode;
     const exprResult = this.evaluate(indexNode.expression, input, context);
     const indexResult = this.evaluate(indexNode.index, input, context);
@@ -416,48 +549,166 @@ export class Interpreter {
       return { value: [], context };
     }
 
-    const index = indexResult.value[0];
-    if (typeof index === 'number' && index >= 0 && index < exprResult.value.length) {
-      return { value: [exprResult.value[index]], context };
+    const boxedIndex = indexResult.value[0];
+    if (boxedIndex) {
+      const index = unbox(boxedIndex);
+      if (typeof index === 'number' && index >= 0 && index < exprResult.value.length) {
+        const result = exprResult.value[index];
+        return { value: result ? [result] : [], context };
+      }
     }
 
     return { value: [], context };
   }
 
   // Type membership test (is operator)
-  private evaluateMembershipTest(node: ASTNode, input: any[], context: RuntimeContext): EvaluationResult {
+  private evaluateMembershipTest(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): EvaluationResult {
     const test = node as MembershipTestNode;
     const exprResult = this.evaluate(test.expression, input, context);
     
-    // Simple type checking
-    const results = exprResult.value.map(item => {
-      switch (test.targetType) {
-        case 'String': return typeof item === 'string';
-        case 'Boolean': return typeof item === 'boolean';
-        case 'Integer': return Number.isInteger(item);
-        case 'Decimal': return typeof item === 'number';
-        default: return false;
+    // If expression evaluates to empty, return empty
+    if (exprResult.value.length === 0) {
+      return { value: [], context };
+    }
+    
+    // If we have type information from analyzer (with ModelProvider), use it
+    if (context.currentNode?.typeInfo?.modelContext) {
+      const modelContext = context.currentNode.typeInfo.modelContext as any;
+      
+      // For union types, check if the target type is valid
+      if (modelContext.isUnion && modelContext.choices) {
+        const hasValidChoice = modelContext.choices.some((c: any) => 
+          c.type === test.targetType || c.elementType === test.targetType
+        );
+        
+        if (!hasValidChoice) {
+          // Type system knows this will always be false
+          return { 
+            value: exprResult.value.map(() => box(false, { type: 'Boolean', singleton: true })), 
+            context 
+          };
+        }
       }
+    }
+    
+    // Type checking with subtype support via ModelProvider
+    const results = exprResult.value.map(boxedItem => {
+      const item = unbox(boxedItem);
+      
+      // If we have a ModelProvider and typeInfo, use it for accurate subtype checking
+      if (context.modelProvider && boxedItem.typeInfo) {
+        const matchingType = context.modelProvider.ofType(boxedItem.typeInfo, test.targetType as import('./types').TypeName);
+        return box(matchingType !== undefined, { type: 'Boolean', singleton: true });
+      }
+      
+      // For FHIR resources without typeInfo, try to get it from modelProvider
+      if (context.modelProvider && item && typeof item === 'object' && 'resourceType' in item && typeof item.resourceType === 'string') {
+        const typeInfo = context.modelProvider.getType(item.resourceType);
+        if (typeInfo) {
+          const matchingType = context.modelProvider.ofType(typeInfo, test.targetType as import('./types').TypeName);
+          return box(matchingType !== undefined, { type: 'Boolean', singleton: true });
+        }
+        // Fall back to exact match
+        return box(item.resourceType === test.targetType, { type: 'Boolean', singleton: true });
+      }
+      
+      // Check for FHIR resource types (no ModelProvider available)
+      if (item && typeof item === 'object' && 'resourceType' in item) {
+        return box(item.resourceType === test.targetType, { type: 'Boolean', singleton: true });
+      }
+      
+      // Check primitive types
+      const isMatch = (() => {
+        switch (test.targetType) {
+          case 'String': return typeof item === 'string';
+          case 'Boolean': return typeof item === 'boolean';
+          case 'Integer': return Number.isInteger(item);
+          case 'Decimal': return typeof item === 'number';
+          case 'Date':
+          case 'DateTime':
+          case 'Time':
+            // Simple check for date-like strings
+            return typeof item === 'string' && !isNaN(Date.parse(item));
+          default: return false;
+        }
+      })();
+      return box(isMatch, { type: 'Boolean', singleton: true });
     });
 
     return { value: results, context };
   }
 
   // Type cast (as operator)
-  private evaluateTypeCast(node: ASTNode, input: any[], context: RuntimeContext): EvaluationResult {
+  private evaluateTypeCast(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): EvaluationResult {
     const cast = node as TypeCastNode;
     const exprResult = this.evaluate(cast.expression, input, context);
     
-    // For now, just return the values as-is
-    // In a real implementation, would perform type conversion
-    return { value: exprResult.value, context };
+    // If we have type information from analyzer (with ModelProvider), use it
+    if (context.currentNode?.typeInfo?.modelContext) {
+      const modelContext = context.currentNode.typeInfo.modelContext as any;
+      
+      // For union types, check if the cast is valid
+      if (modelContext.isUnion && modelContext.choices) {
+        const validChoice = modelContext.choices.find((c: any) => 
+          c.type === cast.targetType || c.elementType === cast.targetType
+        );
+        
+        if (!validChoice) {
+          // Invalid cast - return empty
+          return { value: [], context };
+        }
+      }
+    }
+    
+    // Filter values that match the target type with subtype support
+    const filtered = exprResult.value.filter(boxedItem => {
+      const item = unbox(boxedItem);
+      
+      // If we have a ModelProvider and typeInfo, use it for accurate subtype checking
+      if (context.modelProvider && boxedItem.typeInfo) {
+        const matchingType = context.modelProvider.ofType(boxedItem.typeInfo, cast.targetType as import('./types').TypeName);
+        return matchingType !== undefined;
+      }
+      
+      // For FHIR resources without typeInfo, try to get it from modelProvider
+      if (context.modelProvider && item && typeof item === 'object' && 'resourceType' in item && typeof item.resourceType === 'string') {
+        const typeInfo = context.modelProvider.getType(item.resourceType);
+        if (typeInfo) {
+          const matchingType = context.modelProvider.ofType(typeInfo, cast.targetType as import('./types').TypeName);
+          return matchingType !== undefined;
+        }
+        // Fall back to exact match
+        return item.resourceType === cast.targetType;
+      }
+      
+      // Check for FHIR resource types (no ModelProvider available)
+      if (item && typeof item === 'object' && 'resourceType' in item) {
+        return item.resourceType === cast.targetType;
+      }
+      
+      // Check primitive types
+      switch (cast.targetType) {
+        case 'String': return typeof item === 'string';
+        case 'Boolean': return typeof item === 'boolean';
+        case 'Integer': return Number.isInteger(item);
+        case 'Decimal': return typeof item === 'number';
+        case 'Date':
+        case 'DateTime':
+        case 'Time':
+          // Simple check for date-like strings
+          return typeof item === 'string' && !isNaN(Date.parse(item));
+        default: return false;
+      }
+    });
+    
+    return { value: filtered, context };
   }
   
-  private evaluateQuantity(node: ASTNode, input: any[], context: RuntimeContext): EvaluationResult {
+  private evaluateQuantity(node: ASTNode, input: FHIRPathValue[], context: RuntimeContext): EvaluationResult {
     const quantity = node as QuantityNode;
     const quantityValue = createQuantity(quantity.value, quantity.unit, quantity.isCalendarUnit);
     return {
-      value: [quantityValue],
+      value: [box(quantityValue, { type: 'Quantity', singleton: true })],
       context
     };
   }

package/src/model-provider.ts

@@ -76,14 +76,54 @@ export class FHIRModelProvider implements ModelProvider<FHIRModelContext> {
     'Count': 'Quantity'
   };
   
-  // Common FHIR types to preload
+  // Common FHIR types to preload - load all resource types and common data types
   private readonly commonTypes = [
-    'Patient', 'HumanName', 'Observation', 'CodeableConcept', 'Coding', 
-    'Extension', 'Reference', 'Identifier', 'Period', 'ContactPoint',
-    'Address', 'Attachment', 'Meta', 'Narrative'
+    // Base resources
+    'Resource', 'DomainResource',
+    // All FHIR R4 resources (alphabetical)
+    'Account', 'ActivityDefinition', 'AdverseEvent', 'AllergyIntolerance', 'Appointment',
+    'AppointmentResponse', 'AuditEvent', 'Basic', 'Binary', 'BiologicallyDerivedProduct',
+    'BodyStructure', 'Bundle', 'CapabilityStatement', 'CarePlan', 'CareTeam',
+    'CatalogEntry', 'ChargeItem', 'ChargeItemDefinition', 'Claim', 'ClaimResponse',
+    'ClinicalImpression', 'CodeSystem', 'Communication', 'CommunicationRequest', 'CompartmentDefinition',
+    'Composition', 'ConceptMap', 'Condition', 'Consent', 'Contract',
+    'Coverage', 'CoverageEligibilityRequest', 'CoverageEligibilityResponse', 'DetectedIssue', 'Device',
+    'DeviceDefinition', 'DeviceMetric', 'DeviceRequest', 'DeviceUseStatement', 'DiagnosticReport',
+    'DocumentManifest', 'DocumentReference', 'EffectEvidenceSynthesis', 'Encounter', 'Endpoint',
+    'EnrollmentRequest', 'EnrollmentResponse', 'EpisodeOfCare', 'EventDefinition', 'Evidence',
+    'EvidenceVariable', 'ExampleScenario', 'ExplanationOfBenefit', 'FamilyMemberHistory', 'Flag',
+    'Goal', 'GraphDefinition', 'Group', 'GuidanceResponse', 'HealthcareService',
+    'ImagingStudy', 'Immunization', 'ImmunizationEvaluation', 'ImmunizationRecommendation', 'ImplementationGuide',
+    'InsurancePlan', 'Invoice', 'Library', 'Linkage', 'List',
+    'Location', 'Measure', 'MeasureReport', 'Media', 'Medication',
+    'MedicationAdministration', 'MedicationDispense', 'MedicationKnowledge', 'MedicationRequest', 'MedicationStatement',
+    'MedicinalProduct', 'MedicinalProductAuthorization', 'MedicinalProductContraindication', 'MedicinalProductIndication', 'MedicinalProductIngredient',
+    'MedicinalProductInteraction', 'MedicinalProductManufactured', 'MedicinalProductPackaged', 'MedicinalProductPharmaceutical', 'MedicinalProductUndesirableEffect',
+    'MessageDefinition', 'MessageHeader', 'MolecularSequence', 'NamingSystem', 'NutritionOrder',
+    'Observation', 'ObservationDefinition', 'OperationDefinition', 'OperationOutcome', 'Organization',
+    'OrganizationAffiliation', 'Parameters', 'Patient', 'PaymentNotice', 'PaymentReconciliation',
+    'Person', 'PlanDefinition', 'Practitioner', 'PractitionerRole', 'Procedure',
+    'Provenance', 'Questionnaire', 'QuestionnaireResponse', 'RelatedPerson', 'RequestGroup',
+    'ResearchDefinition', 'ResearchElementDefinition', 'ResearchStudy', 'ResearchSubject', 'RiskAssessment',
+    'RiskEvidenceSynthesis', 'Schedule', 'SearchParameter', 'ServiceRequest', 'Slot',
+    'Specimen', 'SpecimenDefinition', 'StructureDefinition', 'StructureMap', 'Subscription',
+    'Substance', 'SubstanceNucleicAcid', 'SubstancePolymer', 'SubstanceProtein', 'SubstanceReferenceInformation',
+    'SubstanceSourceMaterial', 'SubstanceSpecification', 'SupplyDelivery', 'SupplyRequest', 'Task',
+    'TerminologyCapabilities', 'TestReport', 'TestScript', 'ValueSet', 'VerificationResult',
+    'VisionPrescription',
+    // Common data types
+    'HumanName', 'CodeableConcept', 'Coding', 'Extension', 'Reference', 
+    'Identifier', 'Period', 'ContactPoint', 'Address', 'Attachment', 
+    'Meta', 'Narrative', 'Quantity', 'SimpleQuantity', 'Age', 'Distance',
+    'Duration', 'Count', 'Money', 'Range', 'Ratio', 'SampledData',
+    'Timing', 'Annotation', 'Signature', 'ContactDetail', 'Contributor',
+    'DataRequirement', 'ParameterDefinition', 'RelatedArtifact', 'TriggerDefinition',
+    'UsageContext', 'Dosage', 'ElementDefinition'
   ];
   
-  constructor(private config: FHIRModelProviderConfig) {
+  constructor(private config: FHIRModelProviderConfig = {
+    packages: [{ name: 'hl7.fhir.r4.core', version: '4.0.1' }]
+  }) {
     const canonicalConfig: Config = {
       packages: config.packages.map(p => `${p.name}@${p.version}`),
       workingDir: config.cacheDir || './tmp/.fhir-cache'
@@ -203,7 +243,12 @@ export class FHIRModelProvider implements ModelProvider<FHIRModelContext> {
   }
   
   private mapToFHIRPathType(fhirType: string): TypeName {
-    return this.typeMapping[fhirType] || 'Any';
+    // If it's a mapped type (primitive or special types), use the mapping
+    if (this.typeMapping[fhirType]) {
+      return this.typeMapping[fhirType];
+    }
+    // Otherwise, keep the FHIR type name (for complex types like CodeableConcept)
+    return fhirType as TypeName;
   }
   
   private isChoiceType(element: any): boolean {
@@ -373,8 +418,27 @@ export class FHIRModelProvider implements ModelProvider<FHIRModelContext> {
       return undefined;
     }
     
-    // For non-union types, check direct match
-    return type.type === typeName ? type : undefined;
+    // For non-union types, check if the type matches or is a subtype
+    // First check direct match on FHIRPath type
+    if (type.type === typeName) {
+      return type;
+    }
+    
+    // Check if the type name matches
+    if (type.name === typeName) {
+      return type;
+    }
+    
+    // Check if any of the schemas in the hierarchy match
+    if (context?.schemaHierarchy) {
+      for (const schema of context.schemaHierarchy) {
+        if (schema.type === typeName || schema.name === typeName) {
+          return type;
+        }
+      }
+    }
+    
+    return undefined;
   }
   
   getElementNames(parentType: TypeInfo<FHIRModelContext>): string[] {
@@ -398,6 +462,44 @@ export class FHIRModelProvider implements ModelProvider<FHIRModelContext> {
     
     return Array.from(names);
   }
+
+  getChildrenType(parentType: TypeInfo<FHIRModelContext>): TypeInfo<FHIRModelContext> | undefined {
+    const elementNames = this.getElementNames(parentType);
+    if (elementNames.length === 0) return undefined;
+    
+    // Collect all unique child types
+    const childTypes = new Map<string, TypeInfo<FHIRModelContext>>();
+    
+    for (const elementName of elementNames) {
+      const elementType = this.getElementType(parentType, elementName);
+      if (elementType) {
+        // Use a combination of namespace and name as key to deduplicate
+        const key = `${elementType.namespace || ''}.${elementType.name || elementType.type}`;
+        childTypes.set(key, elementType);
+      }
+    }
+    
+    if (childTypes.size === 0) return undefined;
+    
+    // Create a union type representing all possible children
+    return {
+      type: 'Any',
+      namespace: parentType.namespace,
+      name: 'ChildrenUnion',
+      singleton: false, // children() always returns a collection
+      modelContext: {
+        path: `${parentType.modelContext?.path || ''}.children()`,
+        schemaHierarchy: [],
+        isUnion: true,
+        choices: Array.from(childTypes.values()).map(type => ({
+          type: type.type as TypeName,
+          code: type.name || type.type,
+          namespace: type.namespace,
+          modelContext: type.modelContext
+        }))
+      } as FHIRModelContext
+    };
+  }
   
   // Async helper methods for loading additional schemas
   async loadType(typeName: string): Promise<TypeInfo<FHIRModelContext> | undefined> {