hccinfhir 0.0.1__py3-none-any.whl → 0.0.2__py3-none-any.whl

hccinfhir/extractor.py

@@ -1,122 +1,51 @@
-from pydantic import BaseModel, ConfigDict
-from typing import List, Optional, Literal
-from datetime import date
-
-SYSTEMS = {
-    'dx': 'http://hl7.org/fhir/sid/icd-10-cm',
-    'pr': 'https://bluebutton.cms.gov/resources/codesystem/hcpcs',
-    'specialty': 'https://bluebutton.cms.gov/resources/variables/prvdr_spclty',
-    'role': 'http://hl7.org/fhir/us/carin-bb/CodeSystem/C4BBClaimCareTeamRole',
-    'claim_type': 'https://bluebutton.cms.gov/resources/variables/nch_clm_type_cd'
-}
-
-# Models
-class Coding(BaseModel):
-    system: Optional[str] = None
-    code: Optional[str] = None
-    display: Optional[str] = None
-
-class CodeableConcept(BaseModel):
-    coding: Optional[List[Coding]] = []
-
-class Period(BaseModel):
-    start: Optional[date] = None
-    end: Optional[date] = None
-
-class Diagnosis(BaseModel):
-    sequence: Optional[int] = None
-    diagnosisCodeableConcept: Optional[CodeableConcept] = None
-
-class CareTeamMember(BaseModel):
-    role: Optional[CodeableConcept] = None
-    qualification: Optional[CodeableConcept] = None
-
-class EoBItem(BaseModel):
-    productOrService: Optional[CodeableConcept] = None
-    diagnosisSequence: Optional[List[int]] = None
-    servicedPeriod: Optional[Period] = None
-
-class ExplanationOfBenefit(BaseModel):
-    model_config = ConfigDict(frozen=True)
-    resourceType: Literal["ExplanationOfBenefit"] = "ExplanationOfBenefit"
-    type: Optional[CodeableConcept] = None
-    diagnosis: Optional[List[Diagnosis]] = []
-    item: Optional[List[EoBItem]] = []
-    careTeam: Optional[List[CareTeamMember]] = []
-    billablePeriod: Optional[Period] = None
-
-def extract_mde(eob_data: dict) -> List[dict]:
-    """Extract medical data elements from FHIR ExplanationOfBenefit data."""
-    try:
-        eob = ExplanationOfBenefit.model_validate(eob_data)
-        
-        # Get codes from CodeableConcept
-        get_code = lambda concept, system: next((
-            c.code for c in (concept.coding or [])
-            if c and c.system == system and c.code
-        ), None)
-        
-        # Get date from Period
-        get_date = lambda period: (
-            period.end.isoformat() if period and period.end
-            else period.start.isoformat() if period and period.start
-            else None
-        )
+from typing import Union, List, Literal
+from .models import ServiceLevelData
+from .extractor_837 import extract_sld_837
+from .extractor_fhir import extract_sld_fhir
+
+def extract_sld(
+    data: Union[str, dict], 
+    format: Literal["837", "fhir"] = "fhir"
+) -> List[ServiceLevelData]:
+    """
+    Unified entry point for SLD extraction with explicit format specification
+    
+    Args:
+        data: Input data - string for 837, dict for FHIR
+        format: Data format - either "837" or "fhir"
         
-        # Create diagnosis lookup
-        dx_lookup = {
-            d.sequence: get_code(d.diagnosisCodeableConcept, SYSTEMS['dx'])
-            for d in (eob.diagnosis or [])
-            if d.sequence is not None and d.diagnosisCodeableConcept
-        }
+    Returns:
+        List of ServiceLevelData
         
-        # Get claim-level data
-        claim_type = get_code(eob.type, SYSTEMS['claim_type'])
+    Raises:
+        ValueError: If format and data type don't match or format is invalid
+        TypeError: If data is None or wrong type
+    """
+    if data is None:
+        raise TypeError("Input data cannot be None")
         
-        # Get provider specialty
-        specialty = next((
-            get_code(m.qualification, SYSTEMS['specialty'])
-            for m in (eob.careTeam or [])
-            if m.role and m.qualification
-            and get_code(m.role, SYSTEMS['role']) in {'performing', 'rendering'}
-        ), None)
-        
-        results = []
-        for item in (eob.item or []):
-            if not item.productOrService:
-                continue
-                
-            pr_code = get_code(item.productOrService, SYSTEMS['pr'])
-            if not pr_code:
-                continue
-            
-            # Get associated data
-            dos = get_date(item.servicedPeriod) or get_date(eob.billablePeriod)
-            dx_codes = [dx_lookup[seq] for seq in (item.diagnosisSequence or [])
-                       if seq in dx_lookup]
-            
-            # Build result
-            result = {k: v for k, v in {
-                'procedure_code': pr_code,
-                'diagnosis_codes': dx_codes,
-                'claim_type': claim_type,
-                'provider_specialty': specialty,
-                'service_date': dos
-            }.items()}
-            
-            results.append(result)
-            
-        return results
-        
-    except Exception as e:
-        raise ValueError(f"Error processing EOB: {str(e)}")
+    if format == "837":
+        if not isinstance(data, str) or data == "":
+            raise TypeError(f"837 format requires string input, got {type(data)}")
+        return extract_sld_837(data)
+    elif format == "fhir":
+        if not isinstance(data, dict) or data == {}:
+            raise TypeError(f"FHIR format requires dict input, got {type(data)}")   
+        return extract_sld_fhir(data)
+    else:
+        raise ValueError(f'Format must be either "837" or "fhir", got {format}')
+
+
+def extract_sld_list(data: Union[List[str], List[dict]], format: Literal["837", "fhir"] = "fhir") -> List[ServiceLevelData]:
+    """Extract SLDs from a list of FHIR EOBs"""
+    output = []
+    for item in data:
 
-def extract_mde_list(eob_data_list: List[dict]) -> List[dict]:
-    """Process a list of EOB data dictionaries."""
-    results = []
-    for eob_data in eob_data_list:
         try:
-            results.extend(extract_mde(eob_data))
+            output.extend(extract_sld(item, format))
+        except TypeError as e:
+            print(f"Warning: Skipping invalid types: {str(e)}")
         except ValueError as e:
-            print(f"Warning: Skipping invalid EOB: {str(e)}")
-    return results
+            print(f"Warning: Skipping invalid values: {str(e)}")
+    return output
+

hccinfhir/extractor_837.py

@@ -0,0 +1,175 @@
+from typing import List, Optional, Dict
+from pydantic import BaseModel
+from datetime import date
+from .models import ServiceLevelData
+
+CLAIM_TYPES = {
+    "005010X222A1": "837P",     # Professional
+    "005010X223A2": "837I"      # Institutional
+}
+
+class ClaimData(BaseModel):
+    """Container for claim-level data"""
+    claim_id: Optional[str] = None
+    patient_id: Optional[str] = None
+    performing_provider_npi: Optional[str] = None
+    billing_provider_npi: Optional[str] = None
+    provider_specialty: Optional[str] = None
+    facility_type: Optional[str] = None
+    service_type: Optional[str] = None
+    claim_type: str
+    dx_lookup: Dict[str, str] = {}
+
+def parse_date(date_str: str) -> Optional[str]:
+    """Convert 8-digit date string to ISO format YYYY-MM-DD"""
+    if not isinstance(date_str, str) or len(date_str) != 8:
+        return None
+    try:
+        year, month, day = int(date_str[:4]), int(date_str[4:6]), int(date_str[6:8])
+        if not (1900 <= year <= 2100 and 1 <= month <= 12 and 1 <= day <= 31):
+            return None
+        return f"{year:04d}-{month:02d}-{day:02d}"
+    except ValueError:
+        return None
+
+def parse_amount(amount_str: str) -> Optional[float]:
+    """Convert string to float, return None if invalid"""
+    try:
+        return float(amount_str)
+    except (ValueError, TypeError):
+        return None
+
+def get_segment_value(segment: List[str], index: int) -> Optional[str]:
+    """Safely get value from segment at given index"""
+    return segment[index] if len(segment) > index else None
+
+def parse_diagnosis_codes(segment: List[str]) -> Dict[str, str]:
+    """Extract diagnosis codes from HI segment"""
+    dx_lookup = {}
+    for pos, element in enumerate(segment[1:], 1):
+        if ':' not in element:
+            continue
+        qualifier, code = element.split(':')[:2]
+        if qualifier in ['ABK', 'ABF']:  # ICD-10 qualifiers
+            dx_lookup[str(pos)] = code
+    return dx_lookup
+
+def process_service_line(segments: List[List[str]], start_index: int) -> tuple[Optional[str], Optional[str]]:
+    """Extract NDC and service date from service line segments"""
+    ndc = None
+    service_date = None
+    
+    for seg in segments[start_index:]:
+        if seg[0] in ['LX', 'CLM', 'SE']:
+            break
+        if seg[0] == 'LIN' and len(seg) > 3 and seg[2] == 'N4':
+            ndc = seg[3]
+        elif seg[0] == 'DTP' and seg[1] == '472':
+            service_date = parse_date(seg[3])
+        if ndc and service_date:
+            break
+            
+    return ndc, service_date
+
+def extract_sld_837(content: str) -> List[ServiceLevelData]:
+    """Extract service level data from 837 Professional or Institutional claims"""
+    if not content:
+        raise ValueError("Input X12 data cannot be empty")
+    
+    # Split content into segments
+    segments = [seg.strip().split('*') for seg in content.split('~') if seg.strip()]
+    
+    # Detect claim type from GS segment
+    claim_type = None
+    for segment in segments:
+        if segment[0] == 'GS' and len(segment) > 8:
+            claim_type = CLAIM_TYPES.get(segment[8])
+            break
+    
+    if not claim_type:
+        raise ValueError("Invalid or unsupported 837 format")
+    
+    encounters = []
+    current_data = ClaimData(claim_type=claim_type)
+    in_claim_loop = False
+    in_rendering_provider_loop = False
+    
+    for i, segment in enumerate(segments):
+        if len(segment) < 2:
+            continue
+            
+        seg_id = segment[0]
+        
+        # Process NM1 segments (Provider and Patient info)
+        if seg_id == 'NM1':
+            if segment[1] == 'IL':  # Subscriber/Patient
+                current_data.patient_id = get_segment_value(segment, 9)
+                in_claim_loop = False
+                in_rendering_provider_loop = False
+            elif segment[1] == '82' and len(segment) > 8 and segment[8] == 'XX':  # Rendering Provider
+                current_data.performing_provider_npi = get_segment_value(segment, 9)
+                in_rendering_provider_loop = True
+            elif segment[1] == '85' and len(segment) > 8 and segment[8] == 'XX':  # Billing Provider
+                current_data.billing_provider_npi = get_segment_value(segment, 9)
+                
+        # Process Provider Specialty
+        elif seg_id == 'PRV' and segment[1] == 'PE' and in_rendering_provider_loop:
+            current_data.provider_specialty = get_segment_value(segment, 3)
+            
+        # Process Claim Information
+        elif seg_id == 'CLM':
+            in_claim_loop = True
+            in_rendering_provider_loop = False
+            current_data.claim_id = segment[1] if len(segment) > 1 else None
+            
+            # Parse facility and service type for institutional claims
+            if claim_type == "837I" and len(segment) > 5 and ':' in segment[5]:
+                current_data.facility_type = segment[5][0]
+                current_data.service_type = segment[5][1] if len(segment[5]) > 1 else None
+
+        # Process Diagnosis Codes
+        elif seg_id == 'HI' and in_claim_loop:
+            current_data.dx_lookup = parse_diagnosis_codes(segment)
+            
+        # Process Service Lines
+        elif seg_id in ['SV1', 'SV2'] and in_claim_loop:
+            # Parse procedure info
+            proc_info = segment[1].split(':')
+            procedure_code = proc_info[1] if len(proc_info) > 1 else None
+            modifiers = proc_info[2:] if len(proc_info) > 2 else []
+            
+            # Get diagnosis pointers and linked diagnoses
+            dx_pointer_pos = 7 if seg_id == 'SV1' else 11
+            dx_pointers = get_segment_value(segment, dx_pointer_pos)
+            linked_diagnoses = [
+                current_data.dx_lookup[pointer]
+                for pointer in (dx_pointers.split(',') if dx_pointers else [])
+                if pointer in current_data.dx_lookup
+            ]
+            
+            # Get service line details
+            ndc, service_date = process_service_line(segments, i)
+            
+            # Create service level data
+            service_data = ServiceLevelData(
+                claim_id=current_data.claim_id,
+                procedure_code=procedure_code,
+                linked_diagnosis_codes=linked_diagnoses,
+                claim_diagnosis_codes=list(current_data.dx_lookup.values()),
+                claim_type=current_data.claim_type,
+                provider_specialty=current_data.provider_specialty,
+                performing_provider_npi=current_data.performing_provider_npi,
+                billing_provider_npi=current_data.billing_provider_npi,
+                patient_id=current_data.patient_id,
+                facility_type=current_data.facility_type,
+                service_type=current_data.service_type,
+                service_date=service_date,
+                place_of_service=get_segment_value(segment, 6) if seg_id == 'SV1' else None,
+                quantity=parse_amount(get_segment_value(segment, 4)),
+                modifiers=modifiers,
+                ndc=ndc,
+                allowed_amount=None
+            )
+            encounters.append(service_data)
+    
+    return encounters

hccinfhir/extractor_fhir.py

@@ -0,0 +1,193 @@
+from pydantic import BaseModel, ConfigDict, Field, AliasChoices
+from typing import List, Optional, Literal, Dict
+from datetime import date
+from .models import ServiceLevelData
+
+SYSTEMS = {
+    'diagnosis': {
+        'icd10cm': 'http://hl7.org/fhir/sid/icd-10-cm',
+        'icd10': 'http://hl7.org/fhir/sid/icd-10'
+    },
+    'procedures': {
+        'hcpcs': 'https://bluebutton.cms.gov/resources/codesystem/hcpcs'
+    },
+    'identifiers': {
+        'npi': 'http://hl7.org/fhir/sid/us-npi',
+        'ndc': 'http://hl7.org/fhir/sid/ndc'
+    },
+    'context': {
+        'specialty': 'https://bluebutton.cms.gov/resources/variables/prvdr_spclty',
+        'role': 'http://hl7.org/fhir/us/carin-bb/CodeSystem/C4BBClaimCareTeamRole',
+        'claim_type': 'https://bluebutton.cms.gov/resources/variables/nch_clm_type_cd',
+        'facility': 'https://bluebutton.cms.gov/resources/variables/clm_fac_type_cd',
+        'service': 'https://bluebutton.cms.gov/resources/variables/clm_srvc_clsfctn_type_cd',
+        'place': 'https://bluebutton.cms.gov/resources/variables/line_place_of_srvc_cd'
+    }
+}
+
+class Coding(BaseModel):
+    system: Optional[str] = None
+    code: Optional[str] = None
+    display: Optional[str] = None
+
+class Extension(BaseModel):
+    url: str
+    valueCoding: Optional[dict] = None
+
+class ExtensionMixin(BaseModel):
+    extension: Optional[List[Extension]] = None
+
+    def get_extension_code(self, system_url: str) -> Optional[str]:
+        """Extract code from extensions for a specific system URL"""
+        if not self.extension:
+            return None
+        return next((
+            ext.valueCoding.get('code')
+            for ext in self.extension
+            if ext.url == system_url and ext.valueCoding
+        ), None)
+    
+class CodeableConcept(ExtensionMixin):
+    coding: Optional[List[Coding]] = None
+
+    def get_code(self, system: str) -> Optional[str]:
+        """Extract code for a specific coding system"""
+        if not self.coding:
+            return None
+        return next((c.code for c in self.coding if c and c.system == system and c.code), None)
+
+class Period(BaseModel):
+    start: Optional[date] = None
+    end: Optional[date] = None
+
+    def get_service_date(self) -> Optional[str]:
+        """Return the most specific date available"""
+        return self.end.isoformat() if self.end else self.start.isoformat() if self.start else None
+
+class Diagnosis(BaseModel):
+    sequence: int
+    diagnosisCodeableConcept: CodeableConcept
+
+class CareTeamMember(BaseModel):
+    role: CodeableConcept
+    qualification: Optional[CodeableConcept] = None
+    provider: Optional[dict] = None
+
+class EoBItem(BaseModel):
+    productOrService: Optional[CodeableConcept] = Field(None, validation_alias=AliasChoices('service', 'productOrService'))
+    quantity: Optional[dict] = None
+    diagnosisSequence: Optional[List[int]] = None
+    servicedPeriod: Optional[Period] = None
+    locationCodeableConcept: Optional[CodeableConcept] = None
+    modifier: Optional[List[CodeableConcept]] = None
+    adjudication: Optional[List[dict]] = None
+
+class Facility(ExtensionMixin):
+    pass
+
+class ExplanationOfBenefit(ExtensionMixin):
+    model_config = ConfigDict(frozen=True)
+    resourceType: Literal["ExplanationOfBenefit"] = "ExplanationOfBenefit"
+    id: Optional[str] = None
+    type: Optional[CodeableConcept] = None
+    diagnosis: Optional[List[Diagnosis]] = []
+    item: Optional[List[EoBItem]] = []
+    careTeam: Optional[List[CareTeamMember]] = []
+    billablePeriod: Optional[Period] = None
+    patient: Optional[dict] = None
+    facility: Optional[Facility] = None
+    contained: Optional[List[dict]] = None
+
+    def get_diagnosis_codes(self) -> Dict[int, str]:
+        """Extract all diagnosis codes with their sequences"""
+        dx_codes = {}
+        for dx in self.diagnosis or []:
+            code = (dx.diagnosisCodeableConcept.get_code(SYSTEMS['diagnosis']['icd10cm']) or 
+                   dx.diagnosisCodeableConcept.get_code(SYSTEMS['diagnosis']['icd10']))
+            if code:
+                dx_codes[dx.sequence] = code
+        return dx_codes
+
+    def get_rendering_provider(self) -> Optional[CareTeamMember]:
+        """Get the rendering provider from the care team"""
+        return next((
+            m for m in self.careTeam or []
+            if m.role.get_code(SYSTEMS['context']['role']) in {'performing', 'rendering'}
+        ), None)
+
+    def get_billing_npi(self) -> Optional[str]:
+        """Extract billing provider NPI from contained resources"""
+        return next((
+            i.get('value') 
+            for c in (self.contained or [])
+            for i in c.get('identifier', [])
+            if i.get('system') == SYSTEMS['identifiers']['npi']
+        ), None)
+
+def extract_sld_fhir(eob_data: dict) -> List[ServiceLevelData]:
+    try:
+        eob = ExplanationOfBenefit.model_validate(eob_data)
+        dx_lookup = eob.get_diagnosis_codes()
+        rendering_provider = eob.get_rendering_provider()
+        
+        common_data = {
+            'claim_id': eob.id,
+            'claim_type': eob.type.get_code(SYSTEMS['context']['claim_type']) if eob.type else None,
+            'provider_specialty': (rendering_provider.qualification.get_code(SYSTEMS['context']['specialty']) 
+                                 if rendering_provider and rendering_provider.qualification else None),
+            'performing_provider_npi': (rendering_provider.provider.get('identifier', {}).get('value') 
+                                      if rendering_provider else None),
+            'patient_id': eob.patient.get('reference', '').split('/')[-1] if eob.patient else None,
+            'facility_type': (eob.facility.get_extension_code(SYSTEMS['context']['facility'])
+                            if eob.facility else None),
+            'service_type': (eob.type.get_extension_code(SYSTEMS['context']['service']) or
+                           eob.type.get_code(SYSTEMS['context']['service']) if eob.type else None),
+            'billing_provider_npi': eob.get_billing_npi()
+        }
+
+        results = []
+        for item in eob.item or []:
+            if not item.productOrService:
+                continue
+
+            service_data = {
+                **common_data,
+                'procedure_code': item.productOrService.get_code(SYSTEMS['procedures']['hcpcs']),
+                'ndc': (item.productOrService.get_code(SYSTEMS['identifiers']['ndc']) or
+                       item.productOrService.get_extension_code(SYSTEMS['identifiers']['ndc'])),
+                'quantity': item.quantity.get('value') if item.quantity else None,
+                'linked_diagnosis_codes': [dx_lookup[seq] for seq in (item.diagnosisSequence or []) if seq in dx_lookup],
+                'claim_diagnosis_codes': list(dx_lookup.values()),
+                'service_date': (item.servicedPeriod.get_service_date() if item.servicedPeriod else
+                               eob.billablePeriod.get_service_date() if eob.billablePeriod else None),
+                'place_of_service': item.locationCodeableConcept.get_code(SYSTEMS['context']['place'])
+                                  if item.locationCodeableConcept else None,
+                'modifiers': [m.get_code(SYSTEMS['procedures']['hcpcs']) 
+                            for m in (item.modifier or []) if m],
+                'allowed_amount': next((adj.get('amount', {}).get('value')
+                                      for adj in (item.adjudication or [])
+                                      if any(c.get('code') == 'eligible'
+                                           for c in adj.get('category', {}).get('coding', []))), None)
+            }
+
+            if service_data['procedure_code'] or service_data['ndc']:
+                results.append(service_data)
+
+        if not results:
+            results.append({
+                **common_data,
+                'linked_diagnosis_codes': [],
+                'claim_diagnosis_codes': list(dx_lookup.values()),
+                'service_date': eob.billablePeriod.get_service_date() if eob.billablePeriod else None,
+                'procedure_code': None,
+                'ndc': None,
+                'quantity': None,
+                'place_of_service': None,
+                'modifiers': [],
+                'allowed_amount': None
+            })
+
+        return [ServiceLevelData.model_validate(r) for r in results]
+
+    except ValueError as e:
+        raise ValueError(f"Error processing EOB: {str(e)}")

hccinfhir/filter.py

@@ -0,0 +1,43 @@
+from typing import List, Set
+from .models import ServiceLevelData
+import importlib.resources
+
+# use import importlib.resources to load the professional_cpt_fn file as a list of strings
+professional_cpt_default_fn = 'ra_eligible_cpt_hcpcs_2023.csv'
+professional_cpt_default = []
+with importlib.resources.open_text('hccinfhir.data', professional_cpt_default_fn) as f:
+    professional_cpt_default = set(f.read().splitlines())
+
+def apply_filter(
+    data: List[ServiceLevelData], 
+    inpatient_tob: Set[str] = {'11X', '41X'},
+    outpatient_tob: Set[str] = {'12X', '13X', '43X', '71X', '73X', '76X', '77X', '85X'},
+    professional_cpt: Set[str] = professional_cpt_default
+) -> List[ServiceLevelData]:
+    # tob (Type of Bill) Filter is based on:
+    # https://www.hhs.gov/guidance/sites/default/files/hhs-guidance-documents/2012181486-wq-092916_ra_webinar_slides_5cr_092816.pdf
+    # https://www.hhs.gov/guidance/sites/default/files/hhs-guidance-documents/final%20industry%20memo%20medicare%20filtering%20logic%2012%2022%2015_85.pdf
+
+    # Break down the inpatient ToB into facility and service types
+    inpatient_facility_types = {tob[0] for tob in inpatient_tob}
+    inpatient_service_types = {tob[1] for tob in inpatient_tob}
+
+    # Break down the outpatient ToB into facility and service types
+    outpatient_facility_types = {tob[0] for tob in outpatient_tob}
+    outpatient_service_types = {tob[1] for tob in outpatient_tob}       
+
+    # If ServiceLevelData has a facility_type and service_type, then filter the data based on the facility_type and service_type
+    # If not, then filter the data based on the CPT code
+    filtered_data = []
+    for item in data:
+        if item.facility_type and item.service_type:
+            if item.facility_type in inpatient_facility_types and item.service_type in inpatient_service_types:
+                filtered_data.append(item)
+            elif (item.facility_type in outpatient_facility_types and 
+                  item.service_type in outpatient_service_types and
+                  item.procedure_code in professional_cpt):
+                filtered_data.append(item)
+        else:
+            if item.procedure_code in professional_cpt:
+                filtered_data.append(item)  
+    return filtered_data

hccinfhir/models.py

@@ -0,0 +1,44 @@
+from pydantic import BaseModel
+from typing import List, Optional
+
+class ServiceLevelData(BaseModel):
+    """
+    Represents standardized service-level data extracted from healthcare claims.
+    
+    Attributes:
+        claim_id: Unique identifier for the claim
+        procedure_code: Healthcare Common Procedure Coding System (HCPCS) code
+        ndc: National Drug Code
+        linked_diagnosis_codes: ICD-10 diagnosis codes linked to this service
+        claim_diagnosis_codes: All diagnosis codes on the claim
+        claim_type: Type of claim (e.g., NCH Claim Type Code, or 837I, 837P)
+        provider_specialty: Provider taxonomy or specialty code
+        performing_provider_npi: National Provider Identifier for performing provider
+        billing_provider_npi: National Provider Identifier for billing provider
+        patient_id: Unique identifier for the patient
+        facility_type: Type of facility where service was rendered
+        service_type: Type of service provided (facility type + service type = Type of Bill)
+        service_date: Date service was performed (YYYY-MM-DD)
+        place_of_service: Place of service code
+        quantity: Number of units provided
+        quantity_unit: Unit of measure for quantity
+        modifiers: List of procedure code modifiers
+        allowed_amount: Allowed amount for the service
+    """
+    claim_id: Optional[str] = None
+    procedure_code: Optional[str] = None
+    ndc: Optional[str] = None
+    linked_diagnosis_codes: List[str] = []
+    claim_diagnosis_codes: List[str] = []
+    claim_type: Optional[str] = None
+    provider_specialty: Optional[str] = None
+    performing_provider_npi: Optional[str] = None
+    billing_provider_npi: Optional[str] = None
+    patient_id: Optional[str] = None
+    facility_type: Optional[str] = None
+    service_type: Optional[str] = None
+    service_date: Optional[str] = None
+    place_of_service: Optional[str] = None
+    quantity: Optional[float] = None
+    modifiers: List[str] = []
+    allowed_amount: Optional[float] = None