Coverageeligibilityresponse.shex

ShEx statement for coverageeligibilityresponse

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 <uri.shex>
IMPORT <code.shex>
IMPORT <date.shex>
IMPORT <Money.shex>
IMPORT <Period.shex>
IMPORT <string.shex>
IMPORT <Patient.shex>
IMPORT <boolean.shex>
IMPORT <dateTime.shex>
IMPORT <Coverage.shex>
IMPORT <Reference.shex>
IMPORT <Identifier.shex>
IMPORT <unsignedInt.shex>
IMPORT <Organization.shex>
IMPORT <Practitioner.shex>
IMPORT <DomainResource.shex>
IMPORT <CodeableConcept.shex>
IMPORT <BackboneElement.shex>
IMPORT <PractitionerRole.shex>
IMPORT <CoverageEligibilityRequest.shex>

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

# CoverageEligibilityResponse resource
<CoverageEligibilityResponse> EXTENDS @<DomainResource> CLOSED {   
    a [fhir:CoverageEligibilityResponse]?;fhir:nodeRole [fhir:treeRoot]?;

    fhir:identifier @<OneOrMore_Identifier>?;  # Business Identifier for coverage 
                                            # eligiblity request 
    fhir:status @<code> AND
    	{fhir:v @fhirvs:fm-status};  # active | cancelled | draft | 
                                            # entered-in-error 
    fhir:purpose @<OneOrMore_code> AND
    	{fhir:v @fhirvs:eligibilityresponse-purpose};  # auth-requirements | benefits | 
                                            # discovery | validation 
    fhir:patient @<Reference> AND {fhir:link 
    			@<Patient> ? };  # Intended recipient of products and 
                                            # services 
    fhir:event @<OneOrMore_CoverageEligibilityResponse.event>?;  # Event information
    fhir:serviced @<date>  OR 
    			@<Period>  ?;  # Estimated date or dates of service
    fhir:created @<dateTime>;               # Response creation date
    fhir:requestor @<Reference> AND {fhir:link 
    			@<Organization> OR 
    			@<Practitioner> OR 
    			@<PractitionerRole> ? }?;  # Party responsible for the request
    fhir:request @<Reference> AND {fhir:link 
    			@<CoverageEligibilityRequest> ? };  # Eligibility request reference
    fhir:outcome @<code> AND
    	{fhir:v @fhirvs:eligibility-outcome};  # queued | complete | error | partial
    fhir:disposition @<string>?;            # Disposition Message
    fhir:insurer @<Reference> AND {fhir:link 
    			@<Organization> ? };  # Coverage issuer
    fhir:insurance @<OneOrMore_CoverageEligibilityResponse.insurance>?;  # Patient insurance information
    fhir:preAuthRef @<string>?;             # Preauthorization reference
    fhir:form @<CodeableConcept>?;          # Printed form identifier
    fhir:error @<OneOrMore_CoverageEligibilityResponse.error>?;  # Processing errors
}  

# Event information
<CoverageEligibilityResponse.event> EXTENDS @<BackboneElement> CLOSED {   
    fhir:type @<CodeableConcept>;           # Specific event
    fhir:when @<dateTime>  OR 
    			@<Period>  ;  # Occurance date or period
}  

# Benefits and authorization details
<CoverageEligibilityResponse.insurance.item> EXTENDS @<BackboneElement> CLOSED {   
    fhir:category @<CodeableConcept>?;      # Benefit classification
    fhir:productOrService @<CodeableConcept>?;  # Billing, service, product, or drug 
                                            # code 
    fhir:modifier @<OneOrMore_CodeableConcept>?;  # Product or service billing 
                                            # modifiers 
    fhir:provider @<Reference> AND {fhir:link 
    			@<Practitioner> OR 
    			@<PractitionerRole> ? }?;  # Performing practitioner
    fhir:excluded @<boolean>?;              # Excluded from the plan
    fhir:name @<string>?;                   # Short name for the benefit
    fhir:description @<string>?;            # Description of the benefit or 
                                            # services covered 
    fhir:network @<CodeableConcept>?;       # In or out of network
    fhir:unit @<CodeableConcept>?;          # Individual or family
    fhir:term @<CodeableConcept>?;          # Annual or lifetime
    fhir:benefit @<OneOrMore_CoverageEligibilityResponse.insurance.item.benefit>?;  # Benefit Summary
    fhir:authorizationRequired @<boolean>?;  # Authorization required flag
    fhir:authorizationSupporting @<OneOrMore_CodeableConcept>?;  # Type of required supporting 
                                            # materials 
    fhir:authorizationUrl @<uri>?;          # Preauthorization requirements 
                                            # endpoint 
}  

# Processing errors
<CoverageEligibilityResponse.error> EXTENDS @<BackboneElement> CLOSED {   
    fhir:code @<CodeableConcept>;           # Error code detailing processing 
                                            # issues 
    fhir:expression @<OneOrMore_string>?;   # FHIRPath of element(s) related to 
                                            # issue 
}  

# Patient insurance information
<CoverageEligibilityResponse.insurance> EXTENDS @<BackboneElement> CLOSED {   
    fhir:coverage @<Reference> AND {fhir:link 
    			@<Coverage> ? };  # Insurance information
    fhir:inforce @<boolean>?;               # Coverage inforce indicator
    fhir:benefitPeriod @<Period>?;          # When the benefits are applicable
    fhir:item @<OneOrMore_CoverageEligibilityResponse.insurance.item>?;  # Benefits and authorization details
}  

# Benefit Summary
<CoverageEligibilityResponse.insurance.item.benefit> EXTENDS @<BackboneElement> CLOSED {   
    fhir:type @<CodeableConcept>;           # Benefit classification
    fhir:allowed @<unsignedInt>  OR 
    			@<string>  OR 
    			@<Money>  ?;  # Benefits allowed
    fhir:used @<unsignedInt>  OR 
    			@<string>  OR 
    			@<Money>  ?;  # Benefits used
}  

#---------------------- Cardinality Types (OneOrMore) -------------------
<OneOrMore_Identifier> CLOSED {
    rdf:first @<Identifier>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_Identifier> 
}
<OneOrMore_code> CLOSED {
    rdf:first @<code>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_code> 
}
<OneOrMore_CoverageEligibilityResponse.event> CLOSED {
    rdf:first @<CoverageEligibilityResponse.event>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_CoverageEligibilityResponse.event> 
}
<OneOrMore_CoverageEligibilityResponse.insurance> CLOSED {
    rdf:first @<CoverageEligibilityResponse.insurance>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_CoverageEligibilityResponse.insurance> 
}
<OneOrMore_CoverageEligibilityResponse.error> CLOSED {
    rdf:first @<CoverageEligibilityResponse.error>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_CoverageEligibilityResponse.error> 
}
<OneOrMore_CodeableConcept> CLOSED {
    rdf:first @<CodeableConcept>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_CodeableConcept> 
}
<OneOrMore_CoverageEligibilityResponse.insurance.item.benefit> CLOSED {
    rdf:first @<CoverageEligibilityResponse.insurance.item.benefit>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_CoverageEligibilityResponse.insurance.item.benefit> 
}
<OneOrMore_string> CLOSED {
    rdf:first @<string>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_string> 
}
<OneOrMore_CoverageEligibilityResponse.insurance.item> CLOSED {
    rdf:first @<CoverageEligibilityResponse.insurance.item>  ;
    rdf:rest [rdf:nil] OR @<OneOrMore_CoverageEligibilityResponse.insurance.item> 
}

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

# The outcome of the processing.
fhirvs:eligibility-outcome ["queued" "complete" "error" "partial"]

# A code specifying the types of information being requested.
fhirvs:eligibilityresponse-purpose ["auth-requirements" "benefits" "discovery" "validation"]

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