Coverage.shex

ShEx statement for coverage

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 <Patient.shex>
IMPORT <boolean.shex>
IMPORT <Contract.shex>
IMPORT <Reference.shex>
IMPORT <Identifier.shex>
IMPORT <positiveInt.shex>
IMPORT <Organization.shex>
IMPORT <RelatedPerson.shex>
IMPORT <InsurancePlan.shex>
IMPORT <DomainResource.shex>
IMPORT <SimpleQuantity.shex>
IMPORT <CodeableConcept.shex>
IMPORT <BackboneElement.shex>

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

# Insurance or medical plan or a payment agreement
<Coverage> EXTENDS @<DomainResource> CLOSED {   
    a [fhir:Coverage]?;fhir:nodeRole [fhir:treeRoot]?;

    fhir:identifier @<OneOrMore_Identifier>?;  # Business identifier(s) for this 
                                            # coverage 
    fhir:status @<code> AND
    	{fhir:v @fhirvs:fm-status};  # active | cancelled | draft | 
                                            # entered-in-error 
    fhir:kind @<code> AND
    	{fhir:v @fhirvs:coverage-kind};  # insurance | self-pay | other
    fhir:paymentBy @<OneOrMore_Coverage.paymentBy>?;  # Self-pay parties and responsibility
    fhir:type @<CodeableConcept>?;          # Coverage category such as medical 
                                            # or accident 
    fhir:policyHolder @<Reference> AND {fhir:link 
    			@<Organization> OR 
    			@<Patient> OR 
    			@<RelatedPerson> ? }?;  # Owner of the policy
    fhir:subscriber @<Reference> AND {fhir:link 
    			@<Patient> OR 
    			@<RelatedPerson> ? }?;  # Subscriber to the policy
    fhir:subscriberId @<OneOrMore_Identifier>?;  # ID assigned to the subscriber
    fhir:beneficiary @<Reference> AND {fhir:link 
    			@<Patient> ? };  # Plan beneficiary
    fhir:dependent @<string>?;              # Dependent number
    fhir:relationship @<CodeableConcept>?;  # Beneficiary relationship to the 
                                            # subscriber 
    fhir:period @<Period>?;                 # Coverage start and end dates
    fhir:insurer @<Reference> AND {fhir:link 
    			@<Organization> ? }?;  # Issuer of the policy
    fhir:class @<OneOrMore_Coverage.class>?;  # Additional coverage classifications
    fhir:order @<positiveInt>?;             # Relative order of the coverage
    fhir:network @<string>?;                # Insurer network
    fhir:costToBeneficiary @<OneOrMore_Coverage.costToBeneficiary>?;  # Patient payments for 
                                            # services/products 
    fhir:subrogation @<boolean>?;           # Reimbursement to insurer
    fhir:contract @<OneOrMore_Reference_Contract>?;  # Contract details
    fhir:insurancePlan @<Reference> AND {fhir:link 
    			@<InsurancePlan> ? }?;  # Insurance plan details
}  

# Additional coverage classifications
<Coverage.class> EXTENDS @<BackboneElement> CLOSED {   
    fhir:type @<CodeableConcept>;           # Type of class such as 'group' or 
                                            # 'plan' 
    fhir:value @<Identifier>;               # Value associated with the type
    fhir:name @<string>?;                   # Human readable description of the 
                                            # type and value 
}  

# Self-pay parties and responsibility
<Coverage.paymentBy> EXTENDS @<BackboneElement> CLOSED {   
    fhir:party @<Reference> AND {fhir:link 
    			@<Organization> OR 
    			@<Patient> OR 
    			@<RelatedPerson> ? };  # Parties performing self-payment
    fhir:responsibility @<string>?;         # Party's responsibility
}  

# Exceptions for patient payments
<Coverage.costToBeneficiary.exception> EXTENDS @<BackboneElement> CLOSED {   
    fhir:type @<CodeableConcept>;           # Exception category
    fhir:period @<Period>?;                 # The effective period of the 
                                            # exception 
}  

# Patient payments for services/products
<Coverage.costToBeneficiary> EXTENDS @<BackboneElement> CLOSED {   
    fhir:type @<CodeableConcept>?;          # Cost category
    fhir:category @<CodeableConcept>?;      # Benefit classification
    fhir:network @<CodeableConcept>?;       # In or out of network
    fhir:unit @<CodeableConcept>?;          # Individual or family
    fhir:term @<CodeableConcept>?;          # Annual or lifetime
    fhir:value @<SimpleQuantity>  OR 
    			@<Money>  ?;  # The amount or percentage due from 
                                            # the beneficiary 
    fhir:exception @<OneOrMore_Coverage.costToBeneficiary.exception>?;  # Exceptions for patient payments
}  

#---------------------- Cardinality Types (OneOrMore) -------------------
<OneOrMore_Identifier> CLOSED {
    rdf:first @<Identifier>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_Identifier> 
}
<OneOrMore_Coverage.paymentBy> CLOSED {
    rdf:first @<Coverage.paymentBy>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_Coverage.paymentBy> 
}
<OneOrMore_Coverage.class> CLOSED {
    rdf:first @<Coverage.class>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_Coverage.class> 
}
<OneOrMore_Coverage.costToBeneficiary> CLOSED {
    rdf:first @<Coverage.costToBeneficiary>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_Coverage.costToBeneficiary> 
}
<OneOrMore_Reference_Contract> CLOSED {
    rdf:first @<Reference> AND {fhir:link 
			@<Contract> } ;
    rdf:rest [rdf:nil] OR @<OneOrMore_Reference_Contract> 
}
<OneOrMore_Coverage.costToBeneficiary.exception> CLOSED {
    rdf:first @<Coverage.costToBeneficiary.exception>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_Coverage.costToBeneficiary.exception> 
}

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

# The kind of coverage: insurance, selfpay or other.
fhirvs:coverage-kind ["insurance" "self-pay" "other"]

# This value set includes Status codes.
fhirvs:fm-status ["active" "cancelled" "draft" "entered-in-error"]