davinci_pas_test_kit 0.15.1 → 0.16.0

data/lib/davinci_pas_test_kit/cross_suite/pas_bundle_validation.rb

@@ -3,151 +3,297 @@
 require_relative '../parameters_helper'
 require_relative 'validation_test'
 require_relative 'pas_constants'
+require_relative 'pas_datatype_constraints'
+require_relative 'referenced_resource_presence_validation'
+require_relative 'validator_configuration'
 
 module DaVinciPASTestKit
   module PasBundleValidation
     include DaVinciPASTestKit::ValidationTest
+    include DaVinciPASTestKit::PasDatatypeConstraints
+    include DaVinciPASTestKit::ReferencedResourcePresenceValidation
     include ParametersHelper
 
-    US_CORE_VERSION = '6.1.0'
-    US_CORE_PROFILE_BASE = 'http://hl7.org/fhir/us/core/StructureDefinition'
-    BASE_R4_PROFILE = :base_r4
-    CLAIM_ENCOUNTER_EXTENSION_URL = 'http://hl7.org/fhir/5.0/StructureDefinition/extension-Claim.encounter'
-    LOINC_SYSTEM = 'http://loinc.org'
-    TERMINOLOGY_CONDITION_CATEGORY_SYSTEM = 'http://terminology.hl7.org/CodeSystem/condition-category'
-    OBSERVATION_CATEGORY_SYSTEM = 'http://terminology.hl7.org/CodeSystem/observation-category'
-    DIAGNOSTIC_REPORT_CATEGORY_SYSTEM = 'http://terminology.hl7.org/CodeSystem/v2-0074'
-
-    US_CORE_SINGLE_PROFILE_IDS_BY_RESOURCE = {
-      'AllergyIntolerance' => 'us-core-allergyintolerance',
-      'CarePlan' => 'us-core-careplan',
-      'CareTeam' => 'us-core-careteam',
-      'Coverage' => 'us-core-coverage',
-      'Device' => 'us-core-implantable-device',
-      'DocumentReference' => 'us-core-documentreference',
-      'Encounter' => 'us-core-encounter',
-      'Goal' => 'us-core-goal',
-      'Immunization' => 'us-core-immunization',
-      'Location' => 'us-core-location',
-      'Medication' => 'us-core-medication',
-      'MedicationDispense' => 'us-core-medicationdispense',
-      'MedicationRequest' => 'us-core-medicationrequest',
-      'Organization' => 'us-core-organization',
-      'Patient' => 'us-core-patient',
-      'Practitioner' => 'us-core-practitioner',
-      'PractitionerRole' => 'us-core-practitionerrole',
-      'Procedure' => 'us-core-procedure',
-      'Provenance' => 'us-core-provenance',
-      'QuestionnaireResponse' => 'us-core-questionnaireresponse',
-      'RelatedPerson' => 'us-core-relatedperson',
-      'ServiceRequest' => 'us-core-servicerequest',
-      'Specimen' => 'us-core-specimen'
-    }.freeze
-
-    US_CORE_CONDITION_ENCOUNTER_DIAGNOSIS_PROFILE_ID = 'us-core-condition-encounter-diagnosis'
-    US_CORE_CONDITION_PROBLEMS_HEALTH_CONCERNS_PROFILE_ID = 'us-core-condition-problems-health-concerns'
-    US_CORE_DIAGNOSTIC_REPORT_LAB_PROFILE_ID = 'us-core-diagnosticreport-lab'
-    US_CORE_DIAGNOSTIC_REPORT_NOTE_PROFILE_ID = 'us-core-diagnosticreport-note'
-    US_CORE_OBSERVATION_CLINICAL_RESULT_PROFILE_ID = 'us-core-observation-clinical-result'
-    US_CORE_OBSERVATION_LAB_PROFILE_ID = 'us-core-observation-lab'
-    US_CORE_OBSERVATION_SCREENING_ASSESSMENT_PROFILE_ID = 'us-core-observation-screening-assessment'
-    US_CORE_SIMPLE_OBSERVATION_PROFILE_ID = 'us-core-simple-observation'
-    US_CORE_SMOKING_STATUS_PROFILE_ID = 'us-core-smokingstatus'
-    US_CORE_VITAL_SIGNS_PROFILE_ID = 'us-core-vital-signs'
-
-    US_CORE_OBSERVATION_CODE_PROFILE_IDS = {
-      '11341-5' => 'us-core-observation-occupation',
-      '86645-9' => 'us-core-observation-pregnancyintent',
-      '82810-3' => 'us-core-observation-pregnancystatus',
-      '76690-7' => 'us-core-observation-sexual-orientation',
-      '8289-1' => 'head-occipital-frontal-circumference-percentile',
-      '59576-9' => 'pediatric-bmi-for-age',
-      '77606-2' => 'pediatric-weight-for-height',
-      '85354-9' => 'us-core-blood-pressure',
-      '39156-5' => 'us-core-bmi',
-      '8302-2' => 'us-core-body-height',
-      '8310-5' => 'us-core-body-temperature',
-      '29463-7' => 'us-core-body-weight',
-      '9843-4' => 'us-core-head-circumference',
-      '8867-4' => 'us-core-heart-rate',
-      '59408-5' => 'us-core-pulse-oximetry',
-      '2708-6' => 'us-core-pulse-oximetry',
-      '9279-1' => 'us-core-respiratory-rate',
-      '72166-2' => 'us-core-smokingstatus'
-    }.freeze
-
-    def validation_error_messages
-      @validation_error_messages ||= []
-    end
-
-    def perform_bundle_validation(bundle, operation, type, ig_version)
+    ###########################################################################
+    # Public API
+    ###########################################################################
+
+    # @return [Array<Hash>] The messages (of every severity) found while validating this
+    #   bundle, each a { type:, message: } hash. Callers that only care about failure should
+    #   check for a message with type: 'error' rather than just whether this is present -
+    #   see validation_messages.
+    # @param validator [Symbol] the name of the FHIR resource validator to use for profile
+    #   validation. Use perform_no_custom_extensions_validation for Bundles Inferno sends.
+    # @param echoed_from [FHIR::Bundle, String, nil] the request Bundle the response answers. When
+    #   given, entry resources echoed back from it that carry no extensions beyond those they had in
+    #   it are validated with the :default validator rather than `validator`, since the extensions
+    #   came from the system under test.
+    def perform_bundle_validation(bundle, operation, type, ig_version, request_bundle = nil, validator: :default,
+                                  echoed_from: nil)
+      @validation_messages = []
+      @profile_validator = validator
+      @echoed_from_bundle = parse_bundle(echoed_from)
       target_profile = PASConstants.bundle_profile_url_for_operation_and_type(operation, type)
       request_type = "#{operation}_#{type}"
       if type == 'request'
         perform_request_validation(bundle, target_profile, ig_version.delete_prefix('v'), request_type)
       else
-        perform_response_validation(bundle, target_profile, ig_version.delete_prefix('v'), request_type)
+        perform_response_validation(bundle, target_profile, ig_version.delete_prefix('v'), request_type, request_bundle)
       end
+      validation_messages
     end
 
-    def perform_request_validation(bundle, profile_url, version, request_type)
-      validate_pa_request_payload_structure(bundle, request_type)
-      validate_resources_conformance_against_profile(bundle, profile_url, version, request_type)
+    # Validates a Bundle that Inferno sends to the system under test, which may be tester-provided,
+    # using NO_CUSTOM_EXTENSIONS_VALIDATOR so that custom extensions aren't allowed. Resources echoed
+    # back from the system under test's Bundle may keep the extensions they had in it.
+    # @param type [String] 'request' or 'response' - see perform_bundle_validation.
+    # @param echoed_from [FHIR::Bundle, String, nil] the Bundle from the system under test that this
+    #   one answers, e.g. the request for a response, or nil if there is none - see
+    #   perform_bundle_validation.
+    # @return [Array<Hash>] see perform_bundle_validation.
+    def perform_no_custom_extensions_validation(bundle, operation, type, ig_version, echoed_from:)
+      perform_bundle_validation(bundle, operation, type, ig_version,
+                                validator: NO_CUSTOM_EXTENSIONS_VALIDATOR, echoed_from:)
     end
 
-    def perform_response_validation(response_bundle, profile_url, version, request_type, request_bundle = nil)
-      validate_pa_response_body_structure(response_bundle, request_bundle) if request_type == 'submit'
-      validate_resources_conformance_against_profile(response_bundle, profile_url, version, request_type)
+    # Validates a Parameters resource that Inferno sends to wrap Bundles (e.g., a v2.2.1 $inquire
+    # response) against the base Parameters definition, since PAS doesn't profile it, using
+    # NO_CUSTOM_EXTENSIONS_VALIDATOR. Issues within the wrapped resources are dropped, since those are
+    # validated separately - see perform_no_custom_extensions_validation.
+    # @param parameters [FHIR::Parameters]
+    # @return [Array<Hash>] the messages found, each a { type:, message: } hash.
+    def perform_no_custom_extensions_parameters_validation(parameters)
+      response_details = []
+      resource_is_valid?(resource: parameters, validator: NO_CUSTOM_EXTENSIONS_VALIDATOR,
+                         add_messages_to_runnable: false,
+                         validator_response_details: response_details)
+      validator_issues_to_messages(response_details.reject do |issue|
+        issue.filtered || issue.location&.match?(/\AParameters\.parameter\[\d+\](\.part\[\d+\])*\.resource/)
+      end)
     end
 
-    def validate_pas_bundle_json(json, profile_url, version, request_type, bundle_type, skips: false, message: '')
-      assert_valid_json(json)
-      resource = FHIR.from_contents(json)
-      assert resource.present?, 'Not a FHIR resource'
+    ###########################################################################
+    # Internal Validation Methods
+    ###########################################################################
+
+    # Every message (of every severity, not just errors) collected while validating the
+    # current bundle. Passing-profile messages and per-issue profile-conformance messages
+    # (see validate_bundle_entries_against_profiles) may be warnings or info, not just
+    # errors, which is why this isn't error-only despite most entries being added via
+    # add_validation_error.
+    def validation_messages
+      @validation_messages ||= []
+    end
 
-      # For v2.2.1 inquire responses, expect Parameters resource
-      if version == '2.2.1' && request_type == 'inquire' && bundle_type == 'response_bundle'
-        if resource.resourceType == 'Parameters'
-          # Extract and validate each Bundle in the Parameters
-          bundles = extract_bundles_from_pas_inquiry_response_parameters(resource)
+    # Appends a plain error string to validation_messages as a { type:, message: } hash,
+    # for the many checks in this file that only ever produce errors (as opposed to
+    # validate_bundle_entries_against_profiles, which already has typed messages from the
+    # validator and concats them directly).
+    def add_validation_error(message)
+      validation_messages << { type: 'error', message: }
+    end
 
-          bundles.each do |bundle|
-            perform_response_validation(bundle, profile_url, version, request_type)
-          end
-        elsif resource.is_a?(FHIR::Bundle)
-          # Bundle received instead of Parameters - validate it but log an error
-          validation_error_messages << 'Expected Parameters resource for v2.2.1 inquire response, but received ' \
-                                       'Bundle. The response Bundle should be wrapped in a ' \
-                                       'Parameters resource with a return parameter.'
-          perform_response_validation(resource, profile_url, version, request_type)
-        else
-          assert false,
-                 "Expected Parameters resource for v2.2.1 inquire response, but received #{resource.resourceType}"
+    # The name of the FHIR resource validator used for profile validation of the current
+    # bundle - see perform_bundle_validation.
+    def profile_validator
+      @profile_validator || :default
+    end
+
+    # How to validate one entry resource in the current bundle. Resources echoed back from the request
+    # (see perform_bundle_validation's echoed_from) may keep the extensions they had in it: those that
+    # add no extensions of their own use the :default validator, and the others use the specified
+    # validator with the issues it reports about their extensions explained or dropped - see
+    # echoed_extension_issue_messages.
+    # @param full_url [String] the fullUrl of the entry containing the resource.
+    # @param resource [FHIR::Model] the entry resource.
+    # @return [Array(Symbol, Array, FHIR::Bundle::Entry)] the name of the validator to use, the
+    #   [element path, extension] pairs (see extensions_in) of the request resource the resource echoes,
+    #   and the request entry it echoes. The last two are nil if it doesn't echo one (or the validator is
+    #   :default, which allows any extension).
+    def entry_validation_settings(full_url, resource)
+      return [profile_validator, nil, nil] if profile_validator == :default
+
+      request_entry = echoed_request_entry(full_url, resource)
+      return [profile_validator, nil, nil] if request_entry.blank?
+
+      echoed_extensions = extensions_in(validated_hash(request_entry.resource))
+      all_echoed = extensions_in(validated_hash(resource)).all? { |extension| echoed_extensions.include?(extension) }
+      [all_echoed ? :default : profile_validator, echoed_extensions, request_entry]
+    end
+
+    def echoed_request_entry(full_url, resource)
+      return if @echoed_from_bundle.blank?
+
+      response_entry = FHIR::Bundle::Entry.new(fullUrl: full_url, resource:)
+      @echoed_from_bundle.entry.find { |entry| echoed_resource?(entry, response_entry) }
+    end
+
+    # The resource as the validator receives it (Inferno sends its source_contents), as a hash. Unlike
+    # to_hash, this keeps the extensions on primitive elements (e.g., `_birthDate`).
+    def validated_hash(resource)
+      JSON.parse(resource.source_contents)
+    rescue StandardError
+      resource.to_hash
+    end
+
+    # An extension is echoed if it appears, with the same content and at the same element path, in the
+    # request resource. Paths leave out array indexes so reordered repeating elements still match.
+    # Reference values are ignored because Inferno rewrites them when it echoes resources in responses
+    # it generates.
+    # @return [Array<Array(String, Hash)>] [element path, extension] pairs for every extension (at any
+    #   depth, including modifierExtensions) in the value.
+    def extensions_in(value, path = '')
+      case value
+      when Hash
+        value.flat_map do |key, child|
+          child_path = path.empty? ? key : "#{path}.#{key}"
+          own = if %w[extension modifierExtension].include?(key)
+                  Array(child).map { |extension| [child_path, without_references(extension)] }
+                else
+                  []
+                end
+          own + extensions_in(child, child_path)
         end
+      when Array
+        value.flat_map { |child| extensions_in(child, path) }
       else
-        # For v2.0.1 or non-inquire operations, expect Bundle resource
-        assert_resource_type(:bundle, resource: resource)
-        bundle = resource
+        []
+      end
+    end
 
-        if bundle_type == 'request_bundle'
-          perform_request_validation(bundle, profile_url, version, request_type)
-        else
-          perform_response_validation(bundle, profile_url, version, request_type)
-        end
+    def without_references(value)
+      case value
+      when Hash
+        value.except('reference').transform_values { |child| without_references(child) }
+      when Array
+        value.map { |child| without_references(child) }
+      else
+        value
+      end
+    end
+
+    # An info message identifying an echoed resource, which of its identifying fields matched the request
+    # entry it echoes (see echoed_resource?), and the extensions it is allowed to keep because they are
+    # unchanged from the request - see entry_validation_settings.
+    def echoed_resource_message(full_url, resource, echoed_extensions, request_entry)
+      kept_urls = extensions_in(validated_hash(resource))
+        .select { |extension| echoed_extensions.include?(extension) }
+        .map { |_path, extension| extension['url'] }.uniq
+      message = "#{resource.resourceType} #{full_url} echoes the #{resource.resourceType} in the request " \
+                "(#{echo_match_details(full_url, resource, request_entry)})"
+      message += if kept_urls.present?
+                   ", so these extensions unchanged from the request are allowed in it: #{kept_urls.join(', ')}."
+                 else
+                   '.'
+                 end
+      { type: 'info', message: }
+    end
+
+    # Which identifying fields of an echoed resource match the request entry it echoes and which differ,
+    # e.g., "matched by id; fullUrl differs". Fields blank in both are left out.
+    def echo_match_details(full_url, resource, request_entry)
+      fields = {
+        'fullUrl' => [request_entry.fullUrl, full_url],
+        'id' => [request_entry.resource.id, resource.id],
+        'identifiers' => [identifiers_of(request_entry.resource), identifiers_of(resource)]
+      }.reject { |_name, values| values.all?(&:blank?) }
+      matched, differing = fields.keys.partition do |name|
+        request_value, response_value = fields[name]
+        request_value == response_value
+      end
+      details = "matched by #{matched.to_sentence}"
+      details += "; #{differing.to_sentence} #{differing.one? ? 'differs' : 'differ'}" if differing.present?
+      details
+    end
+
+    # Messages for the validator issues about an echoed resource. An issue that an extension isn't allowed
+    # (see unknown_extension_issue?) is:
+    # - dropped if the extension is echoed, i.e., in echoed_extensions.
+    # - reworded otherwise, to say whether the request resource has an extension with that url at the
+    #   same element, but with different content, or doesn't.
+    # Other issues are kept as is.
+    # @param resource_hash [Hash] the validated resource, as a hash.
+    def echoed_extension_issue_messages(issues, resource_hash, echoed_extensions)
+      issues.filter_map do |issue|
+        path, extension = extension_at_location(resource_hash, issue.location)
+        url = extension&.dig('url')
+        next validator_issue_message(issue) unless unknown_extension_issue?(issue, url)
+        next if echoed_extensions.include?([path, without_references(extension)])
+
+        details =
+          if echoed_extensions.any? { |echoed_path, echoed| echoed_path == path && echoed['url'] == url }
+            "echoed extension #{url} contained a different value than in the source resource."
+          else
+            "extension #{url} in an echoed resource is not in the source resource at this element."
+          end
+        validator_issue_message(issue, details:)
       end
+    end
+
+    # True if the issue is the validator's error for an extension it doesn't know, so doesn't allow
+    # (Extension_EXT_Unknown_NotHere), as the strict validator reports for custom extensions. Other
+    # issues about extensions, e.g., known extensions with invalid values, are reported as is.
+    def unknown_extension_issue?(issue, url)
+      url.present? && issue.raw_issue['message'] == "The extension #{url} could not be found so is not allowed here"
+    end
 
-      validation_error_messages.each do |msg|
-        messages << { type: 'error', message: msg }
+    # True if the issue is the :default validator's note that an echoed extension is unknown
+    # (Extension_EXT_Unknown) - see echoed_resource_message.
+    def echoed_unknown_extension_note?(issue, resource_hash, echoed_extensions)
+      path, extension = extension_at_location(resource_hash, issue.location)
+      url = extension&.dig('url')
+      url.present? && issue.raw_issue['message'] == "Unknown extension #{url}" &&
+        echoed_extensions.include?([path, without_references(extension)])
+    end
+
+    # Resolves a validator issue location such as `Patient.name[0].extension[1]` against the resource.
+    # Extensions on primitive elements are located by the element's name (e.g.,
+    # `Patient.birthDate.extension[0]`) but held in its `_` sibling (e.g., `_birthDate`) in JSON.
+    # @return [Array(String, Hash), nil] the extension's index-free element path (as in extensions_in)
+    #   and the extension, or nil if the location isn't an extension in the resource.
+    def extension_at_location(resource_hash, location)
+      value = resource_hash
+      names = location.to_s.split('.').drop(1).map do |segment|
+        name, index = segment.match(/\A(\w+)(?:\[(\d+)\])?\z/)&.captures
+        return nil if name.nil? || !value.is_a?(Hash)
+
+        name = "_#{name}" if primitive_element?(value, name)
+        value = value[name]
+        value = value[index.to_i] if index.present? && value.is_a?(Array)
+        name
       end
-      msg = 'Bundle and/or entry resources are not conformant. Check messages for issues found.'
-      assert validation_error_messages.blank?, msg
-    rescue Inferno::Exceptions::AssertionException => e
-      msg = "#{message} #{e.message}".strip
-      raise e.class, msg unless skips
+      return unless %w[extension modifierExtension].include?(names.last) && value.is_a?(Hash)
+
+      [names.join('.'), value]
+    end
+
+    # True if the element is a primitive (or repeating primitive) with a `_` sibling holding its
+    # extensions, in the JSON object `parent`.
+    def primitive_element?(parent, name)
+      parent.key?("_#{name}") && Array.wrap(parent[name]).none?(Hash)
+    end
+
+    def parse_bundle(bundle)
+      bundle = FHIR.from_contents(bundle) if bundle.is_a?(String)
+      bundle if bundle.is_a?(FHIR::Bundle)
+    rescue StandardError
+      nil
+    end
+
+    def perform_request_validation(bundle, profile_url, version, request_type)
+      validate_pa_request_payload_structure(bundle, request_type)
+      validate_resources_conformance_against_profile(bundle, profile_url, version, request_type)
+    end
 
-      skip msg
+    def perform_response_validation(response_bundle, profile_url, version, request_type, request_bundle = nil)
+      validate_pa_response_body_structure(response_bundle, request_bundle) if request_type.start_with?('submit')
+      validate_resources_conformance_against_profile(response_bundle, profile_url, version, request_type)
     end
 
+    ###########################################################################
+    # Structure Validation
+    ###########################################################################
+
     # Validates the structure of a Prior Authorization (PA) request Bundle.
     #
     # @param bundle [FHIR::Bundle] The FHIR Bundle of the PA request.
@@ -165,18 +311,22 @@ module DaVinciPASTestKit
       base_url = extract_base_url(bundle.entry.first&.fullUrl)
 
       check_presence_of_referenced_resources(first_entry, base_url, bundle.entry)
+        .each { |msg| add_validation_error(msg) }
 
-      if request_type == 'submit'
+      # request_type is the compound 'submit_request' / 'inquire_request' built by
+      # perform_bundle_validation - start_with? also accepts a bare 'submit', consistent with
+      # find_profile_url and validate_resources_conformance_against_profile below.
+      if request_type.start_with?('submit')
         unless first_entry.is_a?(FHIR::Claim)
-          validation_error_messages << "[Bundle/#{bundle.id}]: The first bundle entry must be a Claim"
+          add_validation_error("[Bundle/#{bundle.id}]: The first bundle entry must be a Claim")
         end
 
         validate_uniqueness_of_supporting_info_sequences(first_entry)
         validate_bundle_entries_full_url(bundle)
       else
-        claim_resource = bundle_entry_resources.find { |resource| resource.resourceType == 'Claim' }
+        claim_resource = bundle_entry_resources.find { |resource| resource&.resourceType == 'Claim' }
         if claim_resource.blank?
-          validation_error_messages << "[Bundle/#{bundle.id}]: Claim must be present for inquiry request"
+          add_validation_error("[Bundle/#{bundle.id}]: Claim must be present for inquiry request")
         end
 
         # The inquiry operation must contain a requesting provider organization,
@@ -186,16 +336,15 @@ module DaVinciPASTestKit
         payer_reference = claim_resource&.insurer&.reference
 
         if patient_reference.blank?
-          validation_error_messages <<
-            "[Bundle/#{bundle.id}]: The Claim for inquiry operation must reference a patient."
+          add_validation_error("[Bundle/#{bundle.id}]: The Claim for inquiry operation must reference a patient.")
         end
         if provider_reference.blank?
-          validation_error_messages << "[Bundle/#{bundle.id}]: The claim for inquiry operation must reference " \
-                                       'a requesting provider organization.'
+          add_validation_error("[Bundle/#{bundle.id}]: The claim for inquiry operation must reference " \
+                               'a requesting provider organization.')
         end
         if payer_reference.blank?
-          validation_error_messages << "[Bundle/#{bundle.id}]: The Claim for inquiry operation must contain " \
-                                       'a payer organization.'
+          add_validation_error("[Bundle/#{bundle.id}]: The Claim for inquiry operation must contain " \
+                               'a payer organization.')
         end
       end
     end
@@ -203,7 +352,7 @@ module DaVinciPASTestKit
     # Validates the response body structure of a Prior Authorization (PA) response.
     #
     # @param pa_response_bundle [FHIR::Bundle] The FHIR bundle representing the PA response.
-    # @param pa_request_bundle [String] The JSON payload of the PA request bundle.
+    # @param pa_request_bundle [FHIR::Bundle, String, nil] The submitted PA request Bundle, either parsed or JSON.
     #
     # This method performs validation of the PA response bundle structure.
     # It follows the PAS IG requirement that the FHIR Bundle generated
@@ -214,34 +363,74 @@ module DaVinciPASTestKit
     # a given combination of content. Resources echoed back from the request are validated
     # to ensure the same fullUrl and resource identifiers as in the
     # request are used.
-    def validate_pa_response_body_structure(pa_response_bundle, _pa_request_bundle)
-      first_entry = pa_response_bundle.entry.first.resource
+    def validate_pa_response_body_structure(pa_response_bundle, pa_request_bundle)
+      first_entry = pa_response_bundle.entry.first&.resource
       unless first_entry.is_a?(FHIR::ClaimResponse)
-        validation_error_messages <<
-          "[Bundle/#{pa_response_bundle.id}]: The first bundle entry must be a ClaimResponse"
+        add_validation_error("[Bundle/#{pa_response_bundle.id}]: The first bundle entry must be a ClaimResponse")
       end
 
       base_url = extract_base_url(pa_response_bundle.entry.last&.fullUrl)
       check_presence_of_referenced_resources(first_entry, base_url, pa_response_bundle.entry)
+        .each { |msg| add_validation_error(msg) }
+
+      validate_echoed_response_resources(pa_response_bundle, pa_request_bundle)
+    end
+
+    def validate_echoed_response_resources(pa_response_bundle, pa_request_bundle)
+      return if pa_request_bundle.blank?
+
+      request_bundle = pa_request_bundle.is_a?(FHIR::Bundle) ? pa_request_bundle : FHIR.from_contents(pa_request_bundle)
+      return unless request_bundle.is_a?(FHIR::Bundle)
+
+      pa_response_bundle.entry.each do |response_entry|
+        response_resource = response_entry.resource
+        next if response_resource.blank?
+
+        request_entry = request_bundle.entry.find do |entry|
+          echoed_resource?(entry, response_entry)
+        end
+        next if request_entry.blank?
+
+        next if echoed_resource_identifiers_match?(request_entry, response_entry)
+
+        add_validation_error(resource_present_in_pa_request_and_response_msg(response_resource))
+      end
+    rescue StandardError
+      add_validation_error('Unable to compare PAS request and response Bundle resources for echoed identifiers.')
+    end
+
+    def echoed_resource?(request_entry, response_entry)
+      request_resource = request_entry.resource
+      response_resource = response_entry.resource
+      return false if request_resource.blank? || response_resource.blank?
+      return false unless request_resource.resourceType == response_resource.resourceType
+
+      # True if any identifying field is present on both sides and matches, so we can later report if any
+      # do not have all matching identifiers. Blank fields do not identify echoed resources.
+      (request_entry.fullUrl.present? && request_entry.fullUrl == response_entry.fullUrl) ||
+        (request_resource.id.present? && request_resource.id == response_resource.id) ||
+        (identifiers_of(request_resource).present? &&
+          identifiers_of(request_resource) == identifiers_of(response_resource))
+    end
 
-      # Testing: When echoing back resources that are the same as were present in the prior authorization request,
-      # the system SHALL ensure that the same fullUrl and resource identifiers are used in the response as appeared
-      # in the request
-      # pa_request_bundle = FHIR.from_contents(pa_request_bundle)
-      # pa_response_bundle.entry.each do |entry|
-      #   res = entry.resource
-      #   request_entry = pa_request_bundle.entry.find do |ent|
-      #     ent.resource.resourceType == res.resourceType && ent.resource.id == res.id
-      #   end
-      #   next unless request_entry.present?
+    def echoed_resource_identifiers_match?(request_entry, response_entry)
+      request_resource = request_entry.resource
+      response_resource = response_entry.resource
 
-      #   assert(
-      #     request_entry.fullUrl == entry.fullUrl && request_entry.resource.identifier == res.identifier,
-      #     resource_present_in_pa_request_and_response_msg(res)
-      #   )
-      # end
+      request_entry.fullUrl == response_entry.fullUrl &&
+        request_resource.id == response_resource.id &&
+        identifiers_of(request_resource) == identifiers_of(response_resource)
     end
 
+    # Nil for resource types without an identifier element (e.g., Binary, Parameters).
+    def identifiers_of(resource)
+      resource.identifier if resource.respond_to?(:identifier)
+    end
+
+    ###########################################################################
+    # Bundle entry profile validation
+    ###########################################################################
+
     # Profile conformance of Prior Authorization (PA) resources.
     #
     # @param bundle [FHIR::Bundle] The FHIR bundle representing the PA request/response.
@@ -259,7 +448,7 @@ module DaVinciPASTestKit
       bundle_entry = bundle.entry
 
       root_entry = bundle_entry.find do |entry|
-        ['Claim', 'ClaimResponse'].include?(entry.resource.resourceType)
+        ['Claim', 'ClaimResponse'].include?(entry.resource&.resourceType)
       end
 
       if root_entry.present?
@@ -299,34 +488,63 @@ module DaVinciPASTestKit
     end
 
     # Validates bundle resource and each entry in the bundle against its target profiles.
-    # It logs a message for each conformant entry
-    # and collects error messages for non-conformant entries. Asserts that there are no validation errors.
+    # Validation messages are collected per profile rather than logged directly, so a
+    # resource with multiple candidate profiles only reports errors when it fails all of
+    # them. When a profile passes, only that profile's (non-error) messages are kept. Either
+    # way, messages go into validation_messages rather than straight to the runnable's
+    # `messages` - see perform_bundle_validation - so callers see every message this method
+    # finds, not just the summary line for a resource that conformed to nothing.
     # @param version [String] The version of the IG.
     def validate_bundle_entries_against_profiles(version)
       bundle_resources_target_profile_map.each do |key, item|
         resource = item[:resource]
         base_profile = FHIR::Definitions.resource_definition(resource.resourceType).url
+        unless key == 'bundle'
+          validator, echoed_extensions, request_entry = entry_validation_settings(key, resource)
+          if request_entry.present?
+            validation_messages << echoed_resource_message(key, resource, echoed_extensions, request_entry)
+          end
+        end
+        messages_by_profile = {}
 
         success_profile = item[:profile_urls].find do |url|
-          if key == 'bundle'
-            profile_to_validate = profile_url_for_validation(url, base_profile, version)
-            bundle_profile_valid?(resource, profile_to_validate)
-          elsif url == BASE_R4_PROFILE
-            resource_is_valid?(resource:)
-          else
-            profile_to_validate = profile_url_for_validation(url, base_profile, version)
-            resource_is_valid?(resource:, profile_url: profile_to_validate)
-          end
+          profile_messages =
+            if key == 'bundle'
+              collect_bundle_profile_messages(resource, profile_url_for_validation(url, base_profile, version))
+            elsif url == BASE_R4_PROFILE
+              collect_resource_profile_messages(resource, validator:, echoed_extensions:)
+            else
+              collect_resource_profile_messages(resource, profile_url_for_validation(url, base_profile, version),
+                                                validator:, echoed_extensions:) +
+                datatype_constraint_messages(resource, profile_url_without_version(url), version)
+            end
+          messages_by_profile[url] = profile_messages
+          profile_messages.none? { |message| message[:type] == 'error' }
         end
 
-        validation_error_messages << generate_non_conformance_message(item) unless success_profile
+        if success_profile
+          validation_messages.concat(messages_by_profile[success_profile])
+        else
+          messages_by_profile.each_value { |profile_messages| validation_messages.concat(profile_messages) }
+          add_validation_error(generate_non_conformance_message(item))
+        end
       end
     end
 
     def profile_url_for_validation(url, base_profile, version)
       url = url.to_s
       return url if url.include?('|') || profile_url_without_version(url) == base_profile
-      return "#{url}|#{US_CORE_VERSION}" if us_core_profile_url?(url)
+
+      if us_core_profile_url?(url)
+        profile_id = url.delete_prefix("#{US_CORE_PROFILE_BASE}/")
+        # US Core 3.1.1's single Condition profile was split by category in later versions,
+        # so only 3.1.1 defines it.
+        return "#{url}|#{PASConstants::US_CORE_VERSION_3_1_1}" if profile_id == US_CORE_CONDITION_PROFILE_ID
+
+        # A declared US Core profile gets the selected version only when that version defines it;
+        # otherwise it stays unversioned so the validator resolves it to a version that does.
+        return us_core_profile_available?(profile_id) ? "#{url}|#{us_core_version}" : url
+      end
 
       "#{url}|#{version}"
     end
@@ -365,6 +583,12 @@ module DaVinciPASTestKit
       version.to_s.delete_prefix('v').match?(/\A2\.2(\.|\z)/)
     end
 
+    # The US Core version whose profiles the fallback validates against: the session's
+    # US Core Version suite option when the suite offers it, otherwise 6.1.0.
+    def us_core_version
+      suite_options[:us_core_version].presence || PASConstants::DEFAULT_US_CORE_VERSION
+    end
+
     def us_core_profile_urls_for_resource(resource)
       profile_ids =
         case resource.resourceType
@@ -378,10 +602,20 @@ module DaVinciPASTestKit
           Array(US_CORE_SINGLE_PROFILE_IDS_BY_RESOURCE[resource.resourceType])
         end
 
-      us_core_profile_urls(profile_ids)
+      profile_urls = us_core_profile_urls(profile_ids.select { |profile_id| us_core_profile_available?(profile_id) })
+      # US Core 3.1.1 has no Simple Observation profile, so the base resource takes its place as the
+      # catch-all at the end of the Observation candidates.
+      if profile_ids.include?(US_CORE_SIMPLE_OBSERVATION_PROFILE_ID) &&
+         !us_core_profile_available?(US_CORE_SIMPLE_OBSERVATION_PROFILE_ID)
+        profile_urls << BASE_R4_PROFILE
+      end
+      profile_urls
     end
 
     def us_core_condition_profile_ids(resource)
+      # US Core 3.1.1 has a single Condition profile; later versions split it by category.
+      return [US_CORE_CONDITION_PROFILE_ID] if us_core_version == PASConstants::US_CORE_VERSION_3_1_1
+
       if category_code_present?(resource, 'encounter-diagnosis', system: TERMINOLOGY_CONDITION_CATEGORY_SYSTEM)
         [US_CORE_CONDITION_ENCOUNTER_DIAGNOSIS_PROFILE_ID]
       else
@@ -398,8 +632,9 @@ module DaVinciPASTestKit
     end
 
     def us_core_observation_profile_ids(resource)
-      code_profile_id = US_CORE_OBSERVATION_CODE_PROFILE_IDS.find do |code, _profile_id|
-        codeable_concept_has_code?(resource.code, code, system: LOINC_SYSTEM)
+      code_profile_id = US_CORE_OBSERVATION_CODE_PROFILE_IDS.find do |code, profile_id|
+        us_core_profile_available?(profile_id) &&
+          codeable_concept_has_code?(resource.code, code, system: LOINC_SYSTEM)
       end&.last
       return [code_profile_id] if code_profile_id.present?
 
@@ -422,7 +657,16 @@ module DaVinciPASTestKit
     end
 
     def us_core_profile_urls(profile_ids)
-      Array(profile_ids).map { |profile_id| "#{US_CORE_PROFILE_BASE}/#{profile_id}|#{US_CORE_VERSION}" }
+      Array(profile_ids).map { |profile_id| "#{US_CORE_PROFILE_BASE}/#{profile_id}|#{us_core_version}" }
+    end
+
+    # Whether the selected US Core version defines the profile.
+    def us_core_profile_available?(profile_id)
+      # The only profile a later supported version dropped; see profile_url_for_validation.
+      return us_core_version == PASConstants::US_CORE_VERSION_3_1_1 if profile_id == US_CORE_CONDITION_PROFILE_ID
+
+      added_in = US_CORE_PROFILE_IDS_ADDED_IN_VERSION.find { |_, profile_ids| profile_ids.include?(profile_id) }&.first
+      added_in.nil? || Gem::Version.new(us_core_version) >= Gem::Version.new(added_in)
     end
 
     def profile_url_without_version(url)
@@ -446,19 +690,59 @@ module DaVinciPASTestKit
       end
     end
 
-    # Validates a Bundle resource against a profile, filtering out entry-resource-level issues
-    # that are covered by individual resource validation to avoid duplicate messages.
+    # Validates a resource against a profile without logging, returning the unfiltered
+    # issues as message hashes for the caller to log once profile selection is resolved.
+    # @param resource [FHIR::Model] The resource to validate.
+    # @param profile_url [String, nil] The profile URL (with version) to validate against,
+    #   or nil to validate against the base resource definition.
+    # @param validator [Symbol] The name of the FHIR resource validator to use.
+    # @param echoed_extensions [Array, nil] Extensions of the request resource the resource echoes, or
+    #   nil if it doesn't echo one - see entry_validation_settings and echoed_extension_issue_messages.
+    # @return [Array<Hash>] Message hashes for the issues found.
+    def collect_resource_profile_messages(resource, profile_url = nil, validator: profile_validator,
+                                          echoed_extensions: nil)
+      response_details = []
+      resource_is_valid?(resource:, profile_url:, validator:,
+                         add_messages_to_runnable: false,
+                         validator_response_details: response_details)
+      issues = response_details.reject(&:filtered)
+      return validator_issues_to_messages(issues) if echoed_extensions.nil?
+
+      resource_hash = validated_hash(resource)
+      if validator == :default
+        # The :default validator allows every extension, so its only issues to drop are its notes that
+        # echoed extensions are unknown, which the echoed resource message already covers.
+        return validator_issues_to_messages(issues.reject do |issue|
+          echoed_unknown_extension_note?(issue, resource_hash, echoed_extensions)
+        end)
+      end
+
+      echoed_extension_issue_messages(issues, resource_hash, echoed_extensions)
+    end
+
+    # Same as collect_resource_profile_messages for a Bundle, additionally dropping
+    # entry-resource-level issues that are covered by individual resource validation
+    # to avoid duplicate messages.
     # @param bundle [FHIR::Bundle] The Bundle resource to validate.
     # @param profile_url [String] The profile URL (with version) to validate against.
-    # @return [Boolean] true if no unfiltered errors remain after removing entry-resource issues.
-    def bundle_profile_valid?(bundle, profile_url)
+    # @return [Array<Hash>] Message hashes for the Bundle-structural issues found.
+    def collect_bundle_profile_messages(bundle, profile_url)
       response_details = []
-      resource_is_valid?(resource: bundle, profile_url:,
+      resource_is_valid?(resource: bundle, profile_url:, validator: profile_validator,
                          add_messages_to_runnable: false,
                          validator_response_details: response_details)
-      bundle_level_issues = reject_entry_resource_issues(response_details)
-      bundle_level_issues.each { |issue| messages << { type: issue.severity, message: issue.message } }
-      bundle_level_issues.none? { |issue| issue.severity == 'error' }
+      validator_issues_to_messages(reject_entry_resource_issues(response_details))
+    end
+
+    def validator_issues_to_messages(issues)
+      issues.map { |issue| validator_issue_message(issue) }
+    end
+
+    # @param details [String, nil] replaces the validator's text, keeping the location the message starts with.
+    def validator_issue_message(issue, details: nil)
+      message = issue.message
+      message = message.delete_suffix(issue.raw_issue['message'].to_s) + details if details.present?
+      { type: issue.severity, message: }
     end
 
     # Rejects validator issues that are already filtered or are located at/below
@@ -652,29 +936,6 @@ module DaVinciPASTestKit
       bundle_map[key]
     end
 
-    def absolute_url(reference, base_url)
-      return if reference.blank?
-      return reference if base_url.blank? || reference.starts_with?('urn:uuid:') || URI(reference).absolute?
-
-      "#{base_url}/#{reference}"
-    end
-
-    # Extracts the base URL from an absolute URL by removing the resource type and ID.
-    # @param absolute_url [String] The absolute URL.
-    # @return [String] The base URL, or an empty string if the URL format is not as expected.
-    def extract_base_url(absolute_url)
-      return '' if absolute_url.blank?
-
-      uri = URI(absolute_url)
-      return '' unless uri.scheme && uri.host
-
-      # Split the path segments and remove the last two segments (resource type and id)
-      path_segments = uri.path.split('/')
-      base_path = path_segments[0...-2].join('/')
-
-      "#{uri.scheme}://#{uri.host}#{base_path}"
-    end
-
     # Resource Types to validate in request/ response bundle
     def find_profile_url(request_type)
       {
@@ -693,7 +954,7 @@ module DaVinciPASTestKit
 
     # Determines the target profile URL for a Claim resource in a submit request bundle.
     #
-    # In v2.2.1, profile-pas-request-bundle permits either profile-claim or profile-claim-update.
+    # In PAS v2.2.1, profile-pas-request-bundle permits either profile-claim or profile-claim-update.
     # The structural discriminator is Claim.related: profile-claim-update requires it (must-support)
     # while profile-claim disallows it (max: 0). For all other versions, profile-claim-update is
     # used unconditionally.
@@ -727,15 +988,15 @@ module DaVinciPASTestKit
       is_unique = sequences.uniq.length == sequences.length
       return if is_unique
 
-      validation_error_messages << "[Claim/#{claim.id}]: The sequence element for each supportingInfo entry SHALL be " \
-                                   'unique within the Claim.'
+      add_validation_error("[Claim/#{claim.id}]: The sequence element for each supportingInfo entry SHALL be " \
+                           'unique within the Claim.')
     end
 
     def validate_bundle_entries_full_url(bundle)
       msg = "[Bundle/#{bundle.id}]: Bundle.entry.fullUrl values SHALL be a valid url or in the form " \
             "'urn:uuid:[some guid]'."
       bundle.entry.each do |entry|
-        validation_error_messages << msg unless valid_url_or_urn_uuid?(entry.fullUrl)
+        add_validation_error(msg) unless valid_url_or_urn_uuid?(entry.fullUrl)
       end
     end
 
@@ -749,119 +1010,6 @@ module DaVinciPASTestKit
       string&.match?(url_regex) || string&.match?(urn_uuid_regex)
     end
 
-    # This method traverses references within a FHIR resource, ensuring that referenced resources
-    # are populated in the bundle. It also enforces that a referenced resource appears only once in the bundle,
-    # as required by the PAS IG.
-    # @param target_resource [FHIR::Model] The FHIR resource to traverse and validate.
-    # @param base_url [String] The server base url.
-    # @param resources_to_match [Array<FHIR:Bundle:Entry] The list of FHIR bundle entries to match references against.
-    # @param skip_claim_related [Boolean] When true, a Claim's `related` element is not traversed. This is set
-    #   for any Claim reached by following a reference (i.e. a non-primary Claim in a Claim Update chain), whose
-    #   own Claim.related.claim (the grandparent) is deliberately omitted from the Bundle per spec-65/66. The
-    #   primary Claim passed in by the caller keeps `skip_claim_related: false`, so its parent reference - and the
-    #   parent's own referenced resources - are still checked.
-    def check_presence_of_referenced_resources(target_resource, base_url, resources_to_match,
-                                               skip_claim_related: false)
-      return if target_resource.blank?
-
-      if target_resource.is_a?(FHIR::Reference) && target_resource.reference.present?
-        ref = target_resource.reference
-        absolute_ref = absolute_url(ref, base_url)
-        matching_resources = resources_to_match.find_all { |res| res.fullUrl == absolute_ref }
-
-        if matching_resources.length != 1
-          validation_error_messages << resource_shall_appear_once_message(absolute_ref,
-                                                                          matching_resources.length)
-        end
-
-        if matching_resources.length.positive?
-          # A resource reached by following a reference is an included resource, not the primary Claim
-          # being validated; if it is itself a Claim Update, its referenced grandparent Claim is omitted.
-          check_presence_of_referenced_resources(matching_resources.first.resource, base_url, resources_to_match,
-                                                 skip_claim_related: true)
-        end
-      else
-        target_resource.source_hash.each_key do |attr|
-          next if claim_response_request_attr?(target_resource, attr)
-          next if skip_claim_related && claim_related_attr?(target_resource, attr)
-
-          value = target_resource.send(attr.to_sym)
-          if value.is_a?(FHIR::Model)
-            check_presence_of_referenced_resources(value, base_url, resources_to_match, skip_claim_related:)
-          elsif value.is_a?(Array) && value.all?(FHIR::Model)
-            value.each do |elmt|
-              check_presence_of_referenced_resources(elmt, base_url, resources_to_match, skip_claim_related:)
-            end
-          end
-        end
-      end
-    end
-
-    # ClaimResponse.request is a back-reference to the submitted Claim. The PAS IG response bundle
-    # profile (profile-pas-response-bundle) has no required Claim entry slice, so the Claim need
-    # not be present in the response bundle. Skipping here matches the identical guard in
-    # ResponseGenerator#referenced_entities, which also skips ClaimResponse.request when
-    # building mock response bundles.
-    def claim_response_request_attr?(resource, attr)
-      attr.to_s == 'request' &&
-        resource.respond_to?(:resourceType) &&
-        resource.resourceType == 'ClaimResponse'
-    end
-
-    # Claim.related.claim points to the Claim being updated. For a non-primary Claim in a Claim Update
-    # chain (one reached by following a reference), that prior Claim is the grandparent, which spec-65/66
-    # require to be omitted from the Bundle. Used with the `skip_claim_related` flag so the generic
-    # reference-presence check does not flag the deliberately-omitted grandparent as missing.
-    def claim_related_attr?(resource, attr)
-      attr.to_s == 'related' &&
-        resource.respond_to?(:resourceType) &&
-        resource.resourceType == 'Claim'
-    end
-
-    # Extracts resources from a bundle while following "next" links.
-    #
-    # @param bundle [FHIR::Bundle] The initial FHIR bundle to extract resources from.
-    # @param response [Object] The HTTP response object for the bundle retrieval.
-    # @param reply_handler [Proc] A callback function to handle responses.
-    # @param max_pages [Integer] The maximum number of pages to process.
-    #
-    # This method extracts resources from a FHIR bundle, following "next" links in the bundle
-    # until the specified maximum number of pages is reached. It collects resources and
-    # invokes the reply_handler for each response.
-    def extract_resources_from_bundle(
-      bundle: nil,
-      response: nil,
-      reply_handler: nil,
-      max_pages: 20
-    )
-      page_count = 1
-      resources = []
-
-      until bundle.nil? || page_count == max_pages
-        resources += bundle&.entry&.map { |entry| entry&.resource }
-        next_bundle_link = bundle&.link&.find { |link| link.relation == 'next' }&.url
-        reply_handler&.call(response)
-
-        break if next_bundle_link.blank?
-
-        page_count += 1
-      end
-
-      resources
-    end
-
-    # Generates a message for a resource that appears more than once in a bundle.
-    #
-    # @param reference_resource_type [String] The resource type being referenced.
-    # @param reference_resource_id [String] The resource ID being referenced.
-    # @param total_matches [Integer] The total number of matches found in the bundle.
-    #
-    # This method generates an error message when a referenced resource appears more than once
-    # in a FHIR bundle, which is not allowed.
-    def resource_shall_appear_once_message(absolute_ref, total_matches)
-      " The referenced #{absolute_ref} resource SHALL appear exactly once in the Bundle, but found #{total_matches}."
-    end
-
     # Generates a message for a resource present in both the PA request and response bundles.
     #
     # @param resource [FHIR::Model] The resource present in both bundles.
@@ -872,5 +1020,115 @@ module DaVinciPASTestKit
       "Resource #{resource.resourceType}/#{resource.id} is an entry in both the PA Request Bundle and the Response " \
         'Bundle, but they do not have the same fullUrl or identifiers'
     end
+
+    ###########################################################################
+    # US Core Profile Constants
+    ###########################################################################
+
+    US_CORE_PROFILE_BASE = 'http://hl7.org/fhir/us/core/StructureDefinition'
+    BASE_R4_PROFILE = :base_r4
+    CLAIM_ENCOUNTER_EXTENSION_URL = 'http://hl7.org/fhir/5.0/StructureDefinition/extension-Claim.encounter'
+    LOINC_SYSTEM = 'http://loinc.org'
+    TERMINOLOGY_CONDITION_CATEGORY_SYSTEM = 'http://terminology.hl7.org/CodeSystem/condition-category'
+    OBSERVATION_CATEGORY_SYSTEM = 'http://terminology.hl7.org/CodeSystem/observation-category'
+    DIAGNOSTIC_REPORT_CATEGORY_SYSTEM = 'http://terminology.hl7.org/CodeSystem/v2-0074'
+
+    US_CORE_SINGLE_PROFILE_IDS_BY_RESOURCE = {
+      'AllergyIntolerance' => 'us-core-allergyintolerance',
+      'CarePlan' => 'us-core-careplan',
+      'CareTeam' => 'us-core-careteam',
+      'Coverage' => 'us-core-coverage',
+      'Device' => 'us-core-implantable-device',
+      'DocumentReference' => 'us-core-documentreference',
+      'Encounter' => 'us-core-encounter',
+      'Goal' => 'us-core-goal',
+      'Immunization' => 'us-core-immunization',
+      'Location' => 'us-core-location',
+      'Medication' => 'us-core-medication',
+      'MedicationDispense' => 'us-core-medicationdispense',
+      'MedicationRequest' => 'us-core-medicationrequest',
+      'Organization' => 'us-core-organization',
+      'Patient' => 'us-core-patient',
+      'Practitioner' => 'us-core-practitioner',
+      'PractitionerRole' => 'us-core-practitionerrole',
+      'Procedure' => 'us-core-procedure',
+      'Provenance' => 'us-core-provenance',
+      'QuestionnaireResponse' => 'us-core-questionnaireresponse',
+      'RelatedPerson' => 'us-core-relatedperson',
+      'ServiceRequest' => 'us-core-servicerequest',
+      'Specimen' => 'us-core-specimen'
+    }.freeze
+
+    US_CORE_CONDITION_PROFILE_ID = 'us-core-condition'
+    US_CORE_CONDITION_ENCOUNTER_DIAGNOSIS_PROFILE_ID = 'us-core-condition-encounter-diagnosis'
+    US_CORE_CONDITION_PROBLEMS_HEALTH_CONCERNS_PROFILE_ID = 'us-core-condition-problems-health-concerns'
+    US_CORE_DIAGNOSTIC_REPORT_LAB_PROFILE_ID = 'us-core-diagnosticreport-lab'
+    US_CORE_DIAGNOSTIC_REPORT_NOTE_PROFILE_ID = 'us-core-diagnosticreport-note'
+    US_CORE_OBSERVATION_CLINICAL_RESULT_PROFILE_ID = 'us-core-observation-clinical-result'
+    US_CORE_OBSERVATION_LAB_PROFILE_ID = 'us-core-observation-lab'
+    US_CORE_OBSERVATION_SCREENING_ASSESSMENT_PROFILE_ID = 'us-core-observation-screening-assessment'
+    US_CORE_SIMPLE_OBSERVATION_PROFILE_ID = 'us-core-simple-observation'
+    US_CORE_SMOKING_STATUS_PROFILE_ID = 'us-core-smokingstatus'
+    US_CORE_VITAL_SIGNS_PROFILE_ID = 'us-core-vital-signs'
+
+    US_CORE_OBSERVATION_CODE_PROFILE_IDS = {
+      '11341-5' => 'us-core-observation-occupation',
+      '86645-9' => 'us-core-observation-pregnancyintent',
+      '82810-3' => 'us-core-observation-pregnancystatus',
+      '76690-7' => 'us-core-observation-sexual-orientation',
+      '95541-9' => 'us-core-care-experience-preference',
+      '75773-2' => 'us-core-treatment-intervention-preference',
+      '8289-1' => 'head-occipital-frontal-circumference-percentile',
+      '59576-9' => 'pediatric-bmi-for-age',
+      '77606-2' => 'pediatric-weight-for-height',
+      '85354-9' => 'us-core-blood-pressure',
+      '96607-7' => 'us-core-average-blood-pressure',
+      '39156-5' => 'us-core-bmi',
+      '8302-2' => 'us-core-body-height',
+      '8310-5' => 'us-core-body-temperature',
+      '29463-7' => 'us-core-body-weight',
+      '9843-4' => 'us-core-head-circumference',
+      '8867-4' => 'us-core-heart-rate',
+      '59408-5' => 'us-core-pulse-oximetry',
+      '2708-6' => 'us-core-pulse-oximetry',
+      '9279-1' => 'us-core-respiratory-rate',
+      '72166-2' => 'us-core-smokingstatus'
+    }.freeze
+
+    # Fallback profiles that US Core 3.1.1 does not define, keyed by the earliest supported
+    # version that does. Profiles not listed here exist in every supported version.
+    US_CORE_PROFILE_IDS_ADDED_IN_VERSION = {
+      PASConstants::US_CORE_VERSION_6_1_0 => [
+        'us-core-blood-pressure',
+        'us-core-bmi',
+        'us-core-body-height',
+        'us-core-body-temperature',
+        'us-core-body-weight',
+        'us-core-condition-encounter-diagnosis',
+        'us-core-condition-problems-health-concerns',
+        'us-core-coverage',
+        'us-core-head-circumference',
+        'us-core-heart-rate',
+        'us-core-medicationdispense',
+        'us-core-observation-clinical-result',
+        'us-core-observation-occupation',
+        'us-core-observation-pregnancyintent',
+        'us-core-observation-pregnancystatus',
+        'us-core-observation-screening-assessment',
+        'us-core-observation-sexual-orientation',
+        'us-core-questionnaireresponse',
+        'us-core-relatedperson',
+        'us-core-respiratory-rate',
+        'us-core-servicerequest',
+        'us-core-simple-observation',
+        'us-core-specimen',
+        'us-core-vital-signs'
+      ],
+      PASConstants::US_CORE_VERSION_7_0_0 => [
+        'us-core-average-blood-pressure',
+        'us-core-care-experience-preference',
+        'us-core-treatment-intervention-preference'
+      ]
+    }.freeze
   end
 end