Account.shex

ShEx statement for account

PREFIX fhir: <http://hl7.org/fhir/> 
PREFIX fhirvs: <http://hl7.org/fhir/ValueSet/>
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#> 
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> 

IMPORT <code.shex>
IMPORT <Money.shex>
IMPORT <string.shex>
IMPORT <Period.shex>
IMPORT <Device.shex>
IMPORT <instant.shex>
IMPORT <boolean.shex>
IMPORT <Patient.shex>
IMPORT <markdown.shex>
IMPORT <Coverage.shex>
IMPORT <dateTime.shex>
IMPORT <Location.shex>
IMPORT <Reference.shex>
IMPORT <Encounter.shex>
IMPORT <Identifier.shex>
IMPORT <positiveInt.shex>
IMPORT <Organization.shex>
IMPORT <Practitioner.shex>
IMPORT <RelatedPerson.shex>
IMPORT <EpisodeOfCare.shex>
IMPORT <DomainResource.shex>
IMPORT <CodeableConcept.shex>
IMPORT <BackboneElement.shex>
IMPORT <PractitionerRole.shex>
IMPORT <CodeableReference.shex>
IMPORT <HealthcareService.shex>

start=@<Account> AND {fhir:nodeRole [fhir:treeRoot]}

# Tracks balance, charges, for patient or cost center
<Account> EXTENDS @<DomainResource> CLOSED {   
    a [fhir:Account]?;fhir:nodeRole [fhir:treeRoot]?;

    fhir:identifier @<OneOrMore_Identifier>?;  # Account number
    fhir:status @<code> AND
    	{fhir:v @fhirvs:account-status};  # active | inactive | 
                                            # entered-in-error | on-hold | 
                                            # unknown 
    fhir:billingStatus @<CodeableConcept>?;  # Tracks the lifecycle of the 
                                            # account through the billing 
                                            # process 
    fhir:type @<CodeableConcept>?;          # E.g. patient, expense, depreciation
    fhir:name @<string>?;                   # Human-readable label
    fhir:subject @<OneOrMore_Reference_Device_OR_HealthcareService_OR_Location_OR_Organization_OR_Patient_OR_Practitioner_OR_PractitionerRole>?;  # The entity that caused the expenses
    fhir:servicePeriod @<Period>?;          # Transaction window
    fhir:covers @<OneOrMore_Reference_Encounter_OR_EpisodeOfCare>?;  # Episodic account covering these 
                                            # encounters/episodes of care 
    fhir:coverage @<OneOrMore_Account.coverage>?;  # The party(s) that are responsible 
                                            # for covering the payment of this 
                                            # account, and what order should 
                                            # they be applied to the account 
    fhir:owner @<Reference> AND {fhir:link 
    			@<Organization> ? }?;  # Entity managing the Account
    fhir:description @<markdown>?;          # Explanation of purpose/use
    fhir:guarantor @<OneOrMore_Account.guarantor>?;  # The parties ultimately responsible 
                                            # for balancing the Account 
    fhir:diagnosis @<OneOrMore_Account.diagnosis>?;  # The list of diagnoses relevant to 
                                            # this account 
    fhir:procedure @<OneOrMore_Account.procedure>?;  # The list of procedures relevant to 
                                            # this account 
    fhir:relatedAccount @<OneOrMore_Account.relatedAccount>?;  # Other associated accounts related 
                                            # to this account 
    fhir:currency @<CodeableConcept>?;      # The base or default currency
    fhir:balance @<OneOrMore_Account.balance>?;  # Calculated account balance(s)
    fhir:calculatedAt @<instant>?;          # Time the balance amount was 
                                            # calculated 
}  

# Calculated account balance(s)
<Account.balance> EXTENDS @<BackboneElement> CLOSED {   
    fhir:aggregate @<CodeableConcept>?;     # Who is expected to pay this part 
                                            # of the balance 
    fhir:term @<CodeableConcept>?;          # current | 30 | 60 | 90 | 120
    fhir:estimate @<boolean>?;              # Estimated balance
    fhir:amount @<Money>;                   # Calculated amount
}  

# The party(s) that are responsible for covering the payment of this account, and what order should they be applied to the account
<Account.coverage> EXTENDS @<BackboneElement> CLOSED {   
    fhir:coverage @<Reference> AND {fhir:link 
    			@<Coverage> ? };  # The party(s), such as insurances, 
                                            # that may contribute to the payment 
                                            # of this account 
    fhir:priority @<positiveInt>?;          # The priority of the coverage in 
                                            # the context of this account 
}  

# The list of procedures relevant to this account
<Account.procedure> EXTENDS @<BackboneElement> CLOSED {   
    fhir:sequence @<positiveInt>?;          # Ranking of the procedure (for each 
                                            # type) 
    fhir:code @<CodeableReference>;         # The procedure relevant to the 
                                            # account 
    fhir:dateOfService @<dateTime>?;        # Date of the procedure (when coded 
                                            # procedure) 
    fhir:type @<OneOrMore_CodeableConcept>?;  # How this procedure value should be 
                                            # used in charging the account 
    fhir:packageCode @<OneOrMore_CodeableConcept>?;  # Package Code specific for billing
    fhir:device @<OneOrMore_Reference_Device>?;  # Any devices that were associated 
                                            # with the procedure 
}  

# The parties ultimately responsible for balancing the Account
<Account.guarantor> EXTENDS @<BackboneElement> CLOSED {   
    fhir:party @<Reference> AND {fhir:link 
    			@<Organization> OR 
    			@<Patient> OR 
    			@<RelatedPerson> ? };  # Responsible entity
    fhir:onHold @<boolean>?;                # Credit or other hold applied
    fhir:period @<Period>?;                 # Guarantee account during
}  

# The list of diagnoses relevant to this account
<Account.diagnosis> EXTENDS @<BackboneElement> CLOSED {   
    fhir:sequence @<positiveInt>?;          # Ranking of the diagnosis (for each 
                                            # type) 
    fhir:condition @<CodeableReference>;    # The diagnosis relevant to the 
                                            # account 
    fhir:dateOfDiagnosis @<dateTime>?;      # Date of the diagnosis (when coded 
                                            # diagnosis) 
    fhir:type @<OneOrMore_CodeableConcept>?;  # Type that this diagnosis has 
                                            # relevant to the account (e.g. 
                                            # admission, billing, discharge …) 
    fhir:onAdmission @<boolean>?;           # Diagnosis present on Admission
    fhir:packageCode @<OneOrMore_CodeableConcept>?;  # Package Code specific for billing
}  

# Other associated accounts related to this account
<Account.relatedAccount> EXTENDS @<BackboneElement> CLOSED {   
    fhir:relationship @<CodeableConcept>?;  # Relationship of the associated 
                                            # Account 
    fhir:account @<Reference> AND {fhir:link 
    			@<Account> ? };  # Reference to an associated Account
}  

#---------------------- Cardinality Types (OneOrMore) -------------------
<OneOrMore_Identifier> CLOSED {
    rdf:first @<Identifier>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_Identifier> 
}
<OneOrMore_Reference_Device_OR_HealthcareService_OR_Location_OR_Organization_OR_Patient_OR_Practitioner_OR_PractitionerRole> CLOSED {
    rdf:first @<Reference> AND {fhir:link 
			@<Device> OR 
			@<HealthcareService> OR 
			@<Location> OR 
			@<Organization> OR 
			@<Patient> OR 
			@<Practitioner> OR 
			@<PractitionerRole> } ;
    rdf:rest [rdf:nil] OR @<OneOrMore_Reference_Device_OR_HealthcareService_OR_Location_OR_Organization_OR_Patient_OR_Practitioner_OR_PractitionerRole> 
}
<OneOrMore_Reference_Encounter_OR_EpisodeOfCare> CLOSED {
    rdf:first @<Reference> AND {fhir:link 
			@<Encounter> OR 
			@<EpisodeOfCare> } ;
    rdf:rest [rdf:nil] OR @<OneOrMore_Reference_Encounter_OR_EpisodeOfCare> 
}
<OneOrMore_Account.coverage> CLOSED {
    rdf:first @<Account.coverage>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_Account.coverage> 
}
<OneOrMore_Account.guarantor> CLOSED {
    rdf:first @<Account.guarantor>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_Account.guarantor> 
}
<OneOrMore_Account.diagnosis> CLOSED {
    rdf:first @<Account.diagnosis>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_Account.diagnosis> 
}
<OneOrMore_Account.procedure> CLOSED {
    rdf:first @<Account.procedure>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_Account.procedure> 
}
<OneOrMore_Account.relatedAccount> CLOSED {
    rdf:first @<Account.relatedAccount>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_Account.relatedAccount> 
}
<OneOrMore_Account.balance> CLOSED {
    rdf:first @<Account.balance>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_Account.balance> 
}
<OneOrMore_CodeableConcept> CLOSED {
    rdf:first @<CodeableConcept>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_CodeableConcept> 
}
<OneOrMore_Reference_Device> CLOSED {
    rdf:first @<Reference> AND {fhir:link 
			@<Device> } ;
    rdf:rest [rdf:nil] OR @<OneOrMore_Reference_Device> 
}

#---------------------- Value Sets ------------------------

# Indicates whether the account is available to be used.
fhirvs:account-status ["active" "inactive" "entered-in-error" "on-hold" "unknown"]