diff --git a/generator/generator_base.rb b/generator/generator_base.rb
index c895e0d58..e8e808246 100644
--- a/generator/generator_base.rb
+++ b/generator/generator_base.rb
@@ -27,7 +27,14 @@ def load_resources
 
             # We should consider using the native Ruby models instead of JSON
             # There were problems with round-tripping certain SearchParameters though
-            new_resource_json = JSON.parse(File.read(resource))
+
+            begin
+              new_resource_json = JSON.parse(File.read(resource))
+            rescue JSON::ParserError
+              Inferno.logger.debug("Failed to parse JSON: #{resource}")
+              next
+            end
+
             new_resource = FHIR.from_contents(File.read(resource))
             next unless new_resource.present?
 
diff --git a/generator/generic/generic_generator.rb b/generator/generic/generic_generator.rb
index e609b61f0..86b472d96 100644
--- a/generator/generic/generic_generator.rb
+++ b/generator/generic/generic_generator.rb
@@ -2,32 +2,46 @@
 
 require_relative '../generator_base'
 require_relative '../sequence_metadata'
+require_relative '../search_parameter_metadata'
 require_relative './read_test'
 require_relative './profile_validation_test'
+require_relative './search_test'
+require_relative './interaction_test'
+require_relative '../generic_generator_utilities'
 
 module Inferno
   module Generator
     class GenericGenerator < Generator::Base
       include ReadTest
       include ProfileValidationTest
+      include SearchTest
+      include InteractionTest
+      include Inferno::Generator::GenericGeneratorUtilties
 
       def resource_profiles
         resources_by_type['StructureDefinition'].reject { |definition| definition['type'] == 'Extension' }
       end
 
       def sequence_metadata
-        @sequence_metadata ||= resource_profiles.map { |profile| SequenceMetadata.new(profile) }
+        @sequence_metadata ||= resource_profiles.map { |profile| SequenceMetadata.new(profile, module_name, search_parameter_metadata, capability_statement) }
+      end
+
+      def search_parameter_metadata
+        @search_parameter_metadata ||= resources_by_type['SearchParameter'].map { |parameter_json| SearchParameterMetadata.new(parameter_json) }
       end
 
       def generate
         generate_sequences
+        copy_static_files
         generate_module
       end
 
       def generate_sequences
         sequence_metadata.each do |metadata|
           create_read_test(metadata)
+          create_search_tests(metadata)
           create_profile_validation_test(metadata)
+          create_interaction_tests(metadata)
           generate_sequence(metadata)
         end
       end
@@ -39,6 +53,46 @@ def generate_sequence(metadata)
         output =   template.result_with_hash(metadata: metadata)
         FileUtils.mkdir_p(sequence_out_path + '/') unless File.directory?(sequence_out_path + '/')
         File.write(file_name, output)
+
+        generate_sequence_definitions(metadata)
+      end
+
+      def generate_sequence_definitions(metadata)
+        output_directory = File.join(sequence_out_path, 'profile_definitions')
+        file_name = File.join(output_directory, metadata.file_name + '_definitions.rb')
+        template = ERB.new(File.read(File.join(__dir__, 'templates/sequence_definition.rb.erb')))
+        output = template.result_with_hash(sequence_definition_hash(metadata))
+        FileUtils.mkdir_p(sequence_out_path + '/profile_definitions/') unless File.directory?(sequence_out_path + '/profile_definitions/')
+        File.write(file_name, output)
+      end
+
+      def sequence_definition_hash(metadata)
+        search_parameters = metadata.search_parameter_metadata&.map do |param_metadata|
+          {
+            url: param_metadata.url,
+            code: param_metadata.code,
+            expression: param_metadata.expression,
+            multipleOr: param_metadata.multiple_or,
+            multipleOrExpectation: param_metadata.multiple_or_expectation,
+            multipleAnd: param_metadata.multiple_and,
+            multipleAndExpectation: param_metadata.multiple_and_expectation,
+            modifiers: param_metadata.modifiers,
+            comparators: param_metadata.comparators
+          }
+        end
+        search_parameters ||= []
+        {
+          module_name: module_name + 'ProfileDefinitions',
+          class_name: metadata.class_name + 'Definition',
+          search_parameters: structure_to_string(search_parameters)
+        }
+      end
+
+      def module_name
+        delimiters = ['-', '_', '.']
+        @path.split(Regexp.union(delimiters))
+          .map(&:capitalize)
+          .join
       end
 
       def module_file_path
@@ -59,6 +113,12 @@ def generate_module
 
         File.write(file_name, output)
       end
+
+      def copy_static_files
+        Dir.glob(File.join(__dir__, 'static', '*')).each do |static_file|
+          FileUtils.cp(static_file, sequence_out_path)
+        end
+      end
     end
   end
 end
diff --git a/generator/generic/interaction_test.rb b/generator/generic/interaction_test.rb
new file mode 100644
index 000000000..5981d73e1
--- /dev/null
+++ b/generator/generic/interaction_test.rb
@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative '../test_metadata'
+
+module Inferno
+  module Generator
+    module InteractionTest
+      def create_interaction_tests(metadata)
+        metadata.interactions.each do |interaction|
+          next if ['read', 'search-type'].include? interaction[:code] # already have tests for
+          next if ['create', 'update', 'patch', 'delete', 'history-type'].include? interaction[:code] # not currently supported
+
+          interaction[:code] = 'history' if interaction[:code] == 'history-instance' # how the history interaction is called already
+
+          interaction_test = TestMetadata.new(
+            title: "Server supports the  #{metadata.resource_type} #{interaction[:code]} interaction",
+            key: "resource_#{interaction[:code].gsub('-', '_').downcase}".to_sym,
+            description: "This test will verify that #{metadata.resource_type} #{interaction[:code]} interactions are supported by the server.",
+            optional: interaction[:expectation] != 'SHALL'
+          )
+
+          validate_reply_args = [
+            '@resource_found',
+            "versioned_resource_class('#{metadata.resource_type}')"
+          ]
+          validate_reply_args_string = validate_reply_args.join(', ')
+
+          interaction_test.code = %(
+              skip 'No resource found from Read test' unless @resource_found.present?
+              validate_#{interaction[:code].gsub('-', '_')}_reply(#{validate_reply_args_string})
+            )
+          metadata.add_test(interaction_test)
+        end
+      end
+    end
+  end
+end
diff --git a/generator/generic/profile_validation_test.rb b/generator/generic/profile_validation_test.rb
index 7ee8e5fa7..bad9b4b81 100644
--- a/generator/generic/profile_validation_test.rb
+++ b/generator/generic/profile_validation_test.rb
@@ -13,7 +13,7 @@ def create_profile_validation_test(metadata)
         )
         profile_validation_test.code = %(
             skip 'No resource found from Read test' unless @resource_found.present?
-            test_resource_against_profile('#{metadata.resource_type}', @resource_found, '#{metadata.url}')
+            test_resources_against_profile('#{metadata.resource_type}','#{metadata.url}')
         )
         metadata.add_test(profile_validation_test)
       end
diff --git a/generator/generic/read_test.rb b/generator/generic/read_test.rb
index 766fbd96d..fed59b71e 100644
--- a/generator/generic/read_test.rb
+++ b/generator/generic/read_test.rb
@@ -14,6 +14,7 @@ def create_read_test(metadata)
         read_test.code = %(
             resource_id = @instance.#{metadata.resource_type.underscore}_id
             @resource_found = validate_read_reply(FHIR::#{metadata.resource_type}.new(id: resource_id), FHIR::#{metadata.resource_type})
+            save_resource_references(versioned_resource_class('#{metadata.resource_type}'), [@resource_found], '#{metadata.url}')
         )
         metadata.add_test(read_test)
       end
diff --git a/generator/generic/search_test.rb b/generator/generic/search_test.rb
new file mode 100644
index 000000000..29e1f3752
--- /dev/null
+++ b/generator/generic/search_test.rb
@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative '../test_metadata'
+
+module Inferno
+  module Generator
+    module SearchTest
+      def create_search_tests(metadata)
+        metadata.searches.each do |search|
+          search_test = TestMetadata.new(
+            title: "Server returns expected results from #{metadata.resource_type} search by #{search[:parameters].join('+')}",
+            key: :"search_by_#{search[:parameters].map(&:underscore).join('_')}",
+            description: "This test will verify that #{metadata.resource_type} resources can be searched from the server.",
+            optional: search[:expectation] != 'SHALL'
+          )
+
+          search_parameter_assignments = search[:parameters].map do |parameter|
+            param_metadata = metadata.search_parameter_metadata.find { |parameter_metadata| parameter_metadata.code == parameter }
+            path = param_metadata
+              .expression
+              .gsub(/(?<!\w)class(?!\w)/, 'local_class')
+              .split('.')
+              .drop(1)
+              .join('.')
+
+            # handle some fhir path stuff. Remove this once fhir path server is added
+            path = path.gsub(/.where\((.*)/, '')
+            as_type = path.scan(/.as\((.*?)\)/).flatten.first
+            path = path.gsub(/.as\((.*?)\)/, capitalize_first_letter(as_type)) if as_type.present?
+
+            "#{search_param_value_name(parameter)} = find_search_parameter_value_from_resource(@resource_found, '#{path}')"
+          end
+          search_test.code = %(
+            skip 'No resource found from Read test' unless @resource_found.present?
+            #{search_parameter_assignments.join("\n")}
+            search_parameters = {
+              #{search[:parameters].map { |parameter| "'#{parameter}': #{search_param_value_name(parameter)}" }.join(",\n")}
+            }
+
+            reply = get_resource_by_params(versioned_resource_class('#{metadata.resource_type}'), search_parameters)
+            validate_search_reply(versioned_resource_class('#{metadata.resource_type}'), reply, search_parameters)
+          )
+          metadata.add_test(search_test)
+        end
+      end
+
+      def search_param_value_name(parameter)
+        parameter.gsub!(/^[\W_]+|[\W_]+$"/, '') # remove non-character elements from beginning and end of name
+        "#{parameter.gsub('-', '_')}_val"
+      end
+
+      def capitalize_first_letter(str)
+        str.slice(0).capitalize + str.slice(1..-1)
+      end
+    end
+  end
+end
diff --git a/generator/generic/templates/module.yml.erb b/generator/generic/templates/module.yml.erb
index 0c100a5a4..6f1c7ef08 100644
--- a/generator/generic/templates/module.yml.erb
+++ b/generator/generic/templates/module.yml.erb
@@ -12,3 +12,6 @@ test_sets:
         run_all: true
         sequences:<% sequences.each do |sequence| %>
         - <%= sequence.class_name %><% end %>
+sequence_requirements:<% sequences.flat_map { |seq| seq.requirements }.uniq.map { |req| req.gsub(':', '') }.each do |requirement| %>
+  <%= requirement %>:
+    label: <%= requirement %><% end %>
diff --git a/generator/generic/templates/sequence.rb.erb b/generator/generic/templates/sequence.rb.erb
index d84943d0f..08388fa94 100644
--- a/generator/generic/templates/sequence.rb.erb
+++ b/generator/generic/templates/sequence.rb.erb
@@ -3,6 +3,8 @@
 module Inferno
   module Sequence
     class <%= metadata.class_name %> < SequenceBase
+      include Inferno::SequenceUtilities
+
       title '<%= metadata.title %> Tests'
       description 'Verify support for the server capabilities required by the <%= metadata.title %> profile.'
       details %(
@@ -12,6 +14,8 @@ module Inferno
 
       @resource_found = nil
 
+      <%=metadata.create_search_validation(metadata)%>
+
       <% metadata.tests.each_with_index do |test, idx|%>
 <% if test.key.present? %>
       test :<%= test.key %> do
diff --git a/generator/generic/templates/sequence_definition.rb.erb b/generator/generic/templates/sequence_definition.rb.erb
new file mode 100644
index 000000000..0de34d704
--- /dev/null
+++ b/generator/generic/templates/sequence_definition.rb.erb
@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Inferno
+  module <%= module_name %>
+    class <%= class_name %>
+      SEARCH_PARAMETERS = <%= search_parameters %>.freeze
+    end
+  end
+end
diff --git a/generator/generic_generator_utilities.rb b/generator/generic_generator_utilities.rb
new file mode 100644
index 000000000..21170a862
--- /dev/null
+++ b/generator/generic_generator_utilities.rb
@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+module Inferno
+  module Generator
+    module GenericGeneratorUtilties
+      EXPECTATION_URL = 'http://hl7.org/fhir/StructureDefinition/capabilitystatement-expectation'
+
+      def structure_to_string(struct)
+        if struct.is_a? Hash
+          %({
+            #{struct.map { |k, v| "#{k}: #{structure_to_string(v)}" }.join(",\n")}
+          })
+        elsif struct.is_a? Array
+          if struct.empty?
+            '[]'
+          else
+            %([
+              #{struct.map { |el| structure_to_string(el) }.join(",\n")}
+            ])
+          end
+        elsif struct.is_a? String
+          "'#{struct}'"
+        elsif [true, false].include? struct
+          struct.to_s
+        else
+          "''"
+        end
+      end
+
+      def create_search_validation(sequence_metadata)
+        search_validators = ''
+        sequence_metadata.search_parameter_metadata&.each do |parameter_metadata|
+          type = sequence_metadata.element_type_by_path(parameter_metadata.expression) || parameter_metadata.type
+          path = parameter_metadata.expression
+            .gsub(/(?<!\w)class(?!\w)/, 'local_class')
+            .split('.')
+            .drop(1)
+            .join('.')
+          path += get_value_path_by_type(type) unless ['Period', 'date', 'HumanName', 'Address', 'CodeableConcept', 'Coding', 'Identifier'].include? type
+          parameter_code = parameter_metadata.code
+          resource_type = sequence_metadata.resource_type
+          search_validators += %(
+              when '#{parameter_metadata.code}'
+              values_found = resolve_path(resource, '#{path}')
+              #{search_param_match_found_code(type, parameter_metadata.code)}
+              assert match_found, "#{parameter_code} in #{resource_type}/\#{resource.id} (\#{values_found}) does not match #{parameter_code} requested (\#{value})"
+            )
+        end
+
+        validate_functions =
+          if search_validators.empty?
+            ''
+          else
+            %(
+              def validate_resource_item(resource, property, value)
+                case property
+                  #{search_validators}
+                end
+              end
+            )
+          end
+        validate_functions
+      end
+
+      def search_param_match_found_code(type, element)
+        case type
+        when 'Period', 'date'
+          %(match_found = values_found.any? { |date| validate_date_search(value, date) })
+        when 'HumanName'
+          # When a string search parameter refers to the types HumanName and Address,
+          # the search covers the elements of type string, and does not cover elements such as use and period
+          # https://www.hl7.org/fhir/search.html#string
+          %(value_downcase = value.downcase
+            match_found = values_found.any? do |name|
+              name&.text&.downcase&.start_with?(value_downcase) ||
+                name&.family&.downcase&.include?(value_downcase) ||
+                name&.given&.any? { |given| given.downcase.start_with?(value_downcase) } ||
+                name&.prefix&.any? { |prefix| prefix.downcase.start_with?(value_downcase) } ||
+                name&.suffix&.any? { |suffix| suffix.downcase.start_with?(value_downcase) }
+            end)
+        when 'Address'
+          %(match_found = values_found.any? do |address|
+              address&.text&.start_with?(value) ||
+              address&.city&.start_with?(value) ||
+              address&.state&.start_with?(value) ||
+              address&.postalCode&.start_with?(value) ||
+              address&.country&.start_with?(value)
+            end)
+        when 'CodeableConcept'
+          %(coding_system = value.split('|').first.empty? ? nil : value.split('|').first
+            coding_value = value.split('|').last
+            match_found = values_found.any? do |codeable_concept|
+              if value.include? '|'
+                codeable_concept.coding.any? { |coding| coding.system == coding_system && coding.code == coding_value }
+              else
+                codeable_concept.coding.any? { |coding| coding.code == value }
+              end
+            end)
+        when 'Identifier'
+          %(identifier_system = value.split('|').first.empty? ? nil : value.split('|').first
+            identifier_value = value.split('|').last
+            match_found = values_found.any? do |identifier|
+              identifier.value == identifier_value && (!value.include?('|') || identifier.system == identifier_system)
+            end)
+        else
+          # searching by patient requires special case because we are searching by a resource identifier
+          # references can also be URL's, so we made need to resolve those url's
+          if ['subject', 'patient'].include? element.to_s
+            %(value = value.split('Patient/').last
+              match_found = values_found.any? { |reference| [value, 'Patient/' + value, "\#{@instance.url}/Patient/\#{value}"].include? reference })
+          else
+            %(values = value.split(/(?<!\\\\),/).each { |str| str.gsub!('\\,', ',') }
+              match_found = values_found.any? { |value_in_resource| values.include? value_in_resource })
+          end
+        end
+      end
+
+      def get_value_path_by_type(type)
+        case type
+        when 'CodeableConcept'
+          '.coding.code'
+        when 'Reference', 'reference'
+          '.reference'
+        when 'Period'
+          '.start'
+        when 'Identifier'
+          '.value'
+        when 'Coding'
+          '.code'
+        when 'HumanName'
+          '.family'
+        when 'Address'
+          '.city'
+        else
+          ''
+        end
+      end
+    end
+  end
+end
diff --git a/generator/search_parameter_metadata.rb b/generator/search_parameter_metadata.rb
new file mode 100644
index 000000000..6ffce6f29
--- /dev/null
+++ b/generator/search_parameter_metadata.rb
@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative './generic_generator_utilities'
+
+module Inferno
+  module Generator
+    class SearchParameterMetadata
+      include Inferno::Generator::GenericGeneratorUtilties
+
+      attr_reader :search_parameter_json
+      attr_writer :url,
+                  :code,
+                  :type,
+                  :expression,
+                  :multiple_or,
+                  :multiple_or_expectation,
+                  :multiple_and,
+                  :multiple_and_expectation,
+                  :modifiers,
+                  :comparators
+
+      def initialize(search_parameter_json)
+        @search_parameter_json = search_parameter_json
+      end
+
+      def url
+        @url ||= @search_parameter_json['url']
+      end
+
+      def code
+        @code ||= @search_parameter_json['code']
+      end
+
+      def type
+        @type ||= @search_parameter_json['type']
+      end
+
+      def expression
+        @expression ||= @search_parameter_json['expression']
+      end
+
+      # whether multiple or is allowed
+      def multiple_or
+        @multiple_or ||= @search_parameter_json['multipleOr']
+      end
+
+      # expectation if multiple or is allowed - unsure if this is generic or just us core specific
+      def multiple_or_expectation
+        @multiple_or_expectation ||= @search_parameter_json.dig('_multipleOr', 'extension')
+                                         &.find { |ext| ext['url'] == EXPECTATION_URL }
+                                         &.dig('valueCode')
+      end
+
+      # whether multiple and is allowed
+      def multiple_and
+        @multiple_and ||= @search_parameter_json['multipleAnd']
+      end
+
+      # expectation if multiple and is allowed - unsure if this is generic or just us core specific
+      def multiple_and_expectation
+        @multiple_and_expectation ||= @search_parameter_json.dig('_multipleAnd', 'extension')
+                                          &.find { |ext| ext['url'] == EXPECTATION_URL }
+                                          &.dig('valueCode')
+      end
+
+      def comparators
+        return [] if @search_parameter_json['comparator'].nil?
+
+        @comparators ||= @search_parameter_json['comparator'].each_with_index.map do |comparator, index|
+          expectation_extension = @search_parameter_json['_comparator'] # unsure if this is us core specific
+          expectation = expectation_extension[index]['extension'].find { |ext| ext['url'] == EXPECTATION_URL }['valueCode'] unless expectation_extension.nil?
+          { comparator: comparator, expectation: expectation }
+        end
+      end
+
+      def modifiers
+        return [] if @search_parameter_json['modifier'].nil?
+
+        @modifiers ||= @search_parameter_json['modifier'].each_with_index.map do |modifier, index|
+          expectation_extension = @search_parameter_json['_modifier'] # unsure if this is us core specific
+          expectation = expectation_extension[index]['extension'].find { |ext| ext['url'] == EXPECTATION_URL }['valueCode'] unless expectation_extension.nil?
+          { modifier: modifier, expectation: expectation }
+        end
+      end
+    end
+  end
+end
diff --git a/generator/sequence_metadata.rb b/generator/sequence_metadata.rb
index 7603a5b74..f26cfe0a8 100644
--- a/generator/sequence_metadata.rb
+++ b/generator/sequence_metadata.rb
@@ -1,21 +1,44 @@
 # frozen_string_literal: true
 
+require_relative './generic_generator_utilities'
+
 module Inferno
   module Generator
     class SequenceMetadata
+      include Inferno::Generator::GenericGeneratorUtilties
+
       attr_reader :profile,
-                  :tests
+                  :tests,
+                  :capabilities,
+                  :search_parameter_metadata,
+                  :module_name
       attr_writer :class_name,
                   :file_name,
                   :requirements,
                   :sequence_name,
                   :test_id_prefix,
                   :title,
-                  :url
+                  :url,
+                  :searches,
+                  :must_supports,
+                  :interactions
 
-      def initialize(profile)
+      def initialize(profile, module_name, all_search_parameter_metadata, capability_statement = nil)
         @profile = profile
         @tests = []
+        @module_name = module_name
+        @search_parameter_metadata = []
+        return unless capability_statement.present?
+
+        @capabilities = capability_statement['rest']
+          .find { |rest| rest['mode'] == 'server' }['resource']
+          .find { |resource| resource['type'] == profile['type'] }
+
+        return unless capabilities.present?
+
+        @search_parameter_metadata = capabilities['searchParam']&.map do |param|
+          all_search_parameter_metadata.find { |param_metadata| param_metadata.url == param['definition'] }
+        end
       end
 
       def resource_type
@@ -51,16 +74,75 @@ def url
         @url ||= profile['url']
       end
 
+      def interactions
+        @interactions ||= interactions_from_capability_statement
+      end
+
+      def interactions_from_capability_statement
+        return [] unless capabilities.present?
+
+        capabilities['interaction'].map do |interaction|
+          {
+            code: interaction['code'],
+            expectation: interaction['extension'].find { |ext| ext['url'] == EXPECTATION_URL } ['valueCode']
+          }
+        end
+      end
+
+      def searches
+        @searches ||= basic_searches_from_capability_statement + search_combinations_from_capability_statement
+      end
+
+      def basic_searches_from_capability_statement
+        return [] unless capabilities.present?
+
+        capabilities['searchParam']&.map do |search_param|
+          {
+            parameters: [search_param['name']],
+            expectation: search_param['extension'].find { |ext| ext['url'] == EXPECTATION_URL }['valueCode']
+          }
+        end || []
+      end
+
+      def search_combinations_from_capability_statement
+        return [] unless capabilities.present?
+
+        search_combo_url = 'http://hl7.org/fhir/StructureDefinition/capabilitystatement-search-parameter-combination'
+        capabilities['extension']
+          &.select { |ext| ext['url'] == search_combo_url }
+          &.map do |combo|
+            # rubocop:disable Layout/IndentationWidth, Layout/CommentIndentation:
+            expectation = combo['extension'].find { |ext| ext['url'] == EXPECTATION_URL }['valueCode']
+            combo_params = combo['extension']
+              .reject { |ext| ext['url'] == EXPECTATION_URL }
+              .map { |ext| ext['valueString'] }
+            {
+              parameters: combo_params,
+              expectation: expectation
+            }
+            # rubocop:enable Layout/IndentationWidth, Layout/CommentIndentation:
+        end || []
+      end
+
       def add_test(test)
         @tests << test
       end
 
+      def element_type_by_path(path)
+        profile_element = profile['snapshot']['element'].select { |el| el['id'] == path }.first
+        return nil if profile_element.nil?
+
+        profile_element['type'].first['code']
+      end
+
       private
 
       def initial_sequence_name
-        return profile['name'] unless profile['name'].include?('-')
-
-        profile['name'].split('-').map(&:capitalize).join
+        delimiters = ['-', '_', '.']
+        (@module_name + '.' + profile['name'])
+          .split(Regexp.union(delimiters))
+          .map(&:capitalize)
+          .join
       end
     end
   end
diff --git a/generator/test_metadata.rb b/generator/test_metadata.rb
index 5777e6e7c..906e1f4d8 100644
--- a/generator/test_metadata.rb
+++ b/generator/test_metadata.rb
@@ -5,12 +5,13 @@ module Generator
     class TestMetadata
       attr_accessor :title, :key, :link, :description, :optional, :code
 
-      def initialize(title: '', key: nil, link: '', description: '', code: '')
+      def initialize(title: '', key: nil, link: '', description: '', code: '', optional: false)
         @title = title
         @key = key
         @link = link
         @description = description
         @code = code
+        @optional = optional
       end
     end
   end
diff --git a/lib/app/sequence_base.rb b/lib/app/sequence_base.rb
index 49b3e07a6..7c90efa64 100644
--- a/lib/app/sequence_base.rb
+++ b/lib/app/sequence_base.rb
@@ -11,6 +11,7 @@
 require_relative 'utils/terminology'
 require_relative 'utils/result_statuses'
 require_relative 'utils/search_validation'
+require_relative 'utils/sequence_utilities'
 require_relative 'models/testing_instance'
 require_relative 'models/inferno_test'
 require_relative 'utils/hl7_validator'
diff --git a/lib/app/utils/sequence_utilities.rb b/lib/app/utils/sequence_utilities.rb
new file mode 100644
index 000000000..93f1b0e2f
--- /dev/null
+++ b/lib/app/utils/sequence_utilities.rb
@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Inferno
+  module SequenceUtilities
+    def resolve_path(elements, path)
+      elements = Array.wrap(elements)
+      return elements if path.blank?
+
+      paths = path.split('.')
+
+      elements.flat_map do |element|
+        resolve_path(element&.send(paths.first), paths.drop(1).join('.'))
+      end.compact
+    end
+
+    def find_search_parameter_value_from_resource(resource, path)
+      get_value_for_search_param(resolve_element_from_path(resource, path) { |el| get_value_for_search_param(el).present? })
+    end
+
+    def get_value_for_search_param(element, include_system = false)
+      search_value = case element
+                     when FHIR::Period
+                       if element.start.present?
+                         'gt' + (DateTime.xmlschema(element.start) - 1).xmlschema
+                       else
+                         end_datetime = get_fhir_datetime_range(element.end)[:end]
+                         'lt' + (end_datetime + 1).xmlschema
+                       end
+                     when FHIR::Reference
+                       element.reference
+                     when FHIR::CodeableConcept
+                       if include_system
+                         coding_with_code = resolve_element_from_path(element, 'coding') { |coding| coding.code.present? }
+                         coding_with_code.present? ? "#{coding_with_code.system}|#{coding_with_code.code}" : nil
+                       else
+                         resolve_element_from_path(element, 'coding.code')
+                       end
+                     when FHIR::Identifier
+                       if include_system
+                         "#{element.system}|#{element.value}"
+                       else
+                         element.value
+                       end
+                     when FHIR::Coding
+                       if include_system
+                         "#{element.system}|#{element.code}"
+                       else
+                         element.code
+                       end
+                     when FHIR::HumanName
+                       element.family || element.given&.first || element.text
+                     when FHIR::Address
+                       element.text || element.city || element.state || element.postalCode || element.country
+                     else
+                       element
+                     end
+      escaped_value = search_value&.gsub(',', '\\,')
+      escaped_value
+    end
+  end
+end