description: A profile of Parameters that indicate the result paramaters of searching for a remittance by claim or patient.
package_name: hl7.fhir.us.davinci-pr
derivation: constraint
name: SearchResultParameters
type: Parameters
elements:
  parameter:
    index: 0
    slicing:
      rules: open
      description: Slice parameters based on the name
      discriminator:
      - {path: name, type: value}
      min: null
      slices:
        TIN:
          match: {name: TIN}
          schema:
            index: 1
            elements:
              name:
                pattern: {type: String, value: TIN}
                index: 2
              value:
                choices: [valueString]
                index: 4
              valueString: {type: string, choiceOf: value, index: 5}
            required: [valueString, value]
        Claim:
          match: {name: Claim}
          schema:
            array: true
            index: 6
            elements:
              name:
                pattern: {type: String, value: Claim}
                index: 7
              part:
                array: true
                min: 4
                index: 8
                slicing:
                  rules: open
                  description: Slice Claim parameter parts based on the name
                  discriminator:
                  - {path: name, type: value}
                  min: 4
                  slices:
                    ProviderClaimID:
                      match: {name: ProviderClaimID}
                      schema:
                        type: BackboneElement
                        _required: true
                        index: 9
                        elements:
                          name:
                            pattern: {type: String, value: ProviderClaimID}
                            index: 10
                          value:
                            choices: [valueString]
                            index: 12
                          valueString: {type: string, choiceOf: value, index: 13}
                        required: [valueString, value]
                    ClaimReceivedDate:
                      match: {name: ClaimReceivedDate}
                      schema:
                        type: BackboneElement
                        _required: true
                        index: 14
                        elements:
                          name:
                            pattern: {type: String, value: ClaimReceivedDate}
                            index: 15
                          value:
                            choices: [valueDate]
                            index: 17
                          valueDate: {type: date, choiceOf: value, index: 18}
                        required: [value, valueDate]
                    ProviderID:
                      match: {name: ProviderID}
                      schema:
                        type: BackboneElement
                        _required: true
                        index: 19
                        elements:
                          name:
                            pattern: {type: String, value: ProviderID}
                            index: 20
                          value:
                            choices: [valueString]
                            index: 22
                          valueString: {type: string, choiceOf: value, index: 23}
                        required: [valueString, value]
                    PayerClaimID:
                      match: {name: PayerClaimID}
                      schema:
                        type: BackboneElement
                        _required: true
                        index: 24
                        elements:
                          name:
                            pattern: {type: String, value: PayerClaimID}
                            index: 25
                          value:
                            choices: [valueString]
                            index: 27
                          valueString: {type: string, choiceOf: value, index: 28}
                        required: [valueString, value]
                    PaymentInfo:
                      match: {name: PaymentInfo}
                      schema:
                        type: BackboneElement
                        array: true
                        index: 29
                        elements:
                          name:
                            pattern: {type: String, value: PaymentInfo}
                            index: 30
                          part:
                            array: true
                            min: 4
                            max: 4
                            index: 31
                            slicing:
                              rules: open
                              description: Slice Payment parameter parts based on the name
                              discriminator:
                              - {path: name, type: value}
                              min: 4
                              max: 4
                              slices:
                                PaymentDate:
                                  match: {name: PaymentDate}
                                  schema:
                                    type: BackboneElement
                                    _required: true
                                    index: 32
                                    elements:
                                      name:
                                        pattern: {type: String, value: PaymentDate}
                                        index: 33
                                      value:
                                        choices: [valueDate]
                                        index: 35
                                      valueDate: {type: date, choiceOf: value, index: 36}
                                    required: [value, valueDate]
                                PaymentNumber:
                                  match: {name: PaymentNumber}
                                  schema:
                                    type: BackboneElement
                                    _required: true
                                    index: 37
                                    elements:
                                      name:
                                        pattern: {type: String, value: PaymentNumber}
                                        index: 38
                                      value:
                                        choices: [valueString]
                                        index: 40
                                      valueString: {type: string, choiceOf: value, index: 41}
                                    required: [valueString, value]
                                PaymentAmount:
                                  match: {name: PaymentAmount}
                                  schema:
                                    type: BackboneElement
                                    _required: true
                                    index: 42
                                    elements:
                                      name:
                                        pattern: {type: String, value: PaymentAmount}
                                        index: 43
                                      value:
                                        choices: [valueMoney]
                                        index: 45
                                      valueMoney: {type: Money, choiceOf: value, index: 46}
                                    required: [valueMoney, value]
                                Remittance:
                                  match: {name: Remittance}
                                  schema:
                                    type: BackboneElement
                                    _required: true
                                    index: 47
                                    elements:
                                      name:
                                        pattern: {type: String, value: Remittance}
                                        index: 48
                                      part:
                                        array: true
                                        min: 4
                                        max: 4
                                        index: 49
                                        slicing:
                                          rules: open
                                          description: Slice Remittance parameter parts based on the name
                                          discriminator:
                                          - {path: name, type: value}
                                          min: 4
                                          max: 4
                                          slices:
                                            RemittanceAdviceIdentifier:
                                              match: {name: RemittanceAdviceIdentifier}
                                              schema:
                                                type: BackboneElement
                                                _required: true
                                                index: 50
                                                elements:
                                                  name:
                                                    pattern: {type: String, value: RemittanceAdviceIdentifier}
                                                    index: 51
                                                  value:
                                                    choices: [valueString]
                                                    index: 53
                                                  valueString: {type: string, choiceOf: value, index: 54}
                                                required: [valueString, value]
                                            RemittanceAdviceType:
                                              match: {name: RemittanceAdviceType}
                                              schema:
                                                type: BackboneElement
                                                _required: true
                                                index: 55
                                                elements:
                                                  name:
                                                    pattern: {type: String, value: RemittanceAdviceType}
                                                    index: 56
                                                  value:
                                                    choices: [valueCode]
                                                    index: 58
                                                  valueCode: {type: code, choiceOf: value, index: 59}
                                                required: [valueCode, value]
                                            RemittanceAdviceDate:
                                              match: {name: RemittanceAdviceDate}
                                              schema:
                                                type: BackboneElement
                                                _required: true
                                                index: 60
                                                elements:
                                                  name:
                                                    pattern: {type: String, value: RemittanceAdviceDate}
                                                    index: 61
                                                  value:
                                                    choices: [valueDate]
                                                    index: 63
                                                  valueDate: {type: date, choiceOf: value, index: 64}
                                                required: [value, valueDate]
                                            RemittanceAdviceFileSize:
                                              match: {name: RemittanceAdviceFileSize}
                                              schema:
                                                type: BackboneElement
                                                _required: true
                                                index: 65
                                                elements:
                                                  name:
                                                    pattern: {type: String, value: RemittanceAdviceFileSize}
                                                    index: 66
                                                  value:
                                                    choices: [valueInteger]
                                                    index: 68
                                                  valueInteger: {type: integer, choiceOf: value, index: 69}
                                                required: [value, valueInteger]
        Payer:
          match: {name: Payer}
          schema:
            index: 70
            elements:
              name:
                pattern: {type: String, value: Payer}
                index: 71
              part:
                array: true
                min: 2
                max: 2
                index: 72
                slicing:
                  rules: open
                  description: Slice Payer parameter parts based on the name
                  discriminator:
                  - {path: name, type: value}
                  min: 2
                  max: 2
                  slices:
                    PayerID:
                      match: {name: PayerID}
                      schema:
                        type: BackboneElement
                        _required: true
                        index: 73
                        elements:
                          name:
                            pattern: {type: String, value: PayerID}
                            index: 74
                          value:
                            choices: [valueString]
                            index: 76
                          valueString: {type: string, choiceOf: value, index: 77}
                        required: [valueString, value]
                    PayerName:
                      match: {name: PayerName}
                      schema:
                        type: BackboneElement
                        _required: true
                        index: 78
                        elements:
                          name:
                            pattern: {type: String, value: PayerName}
                            index: 79
                          value:
                            choices: [valueString]
                            index: 81
                          valueString: {type: string, choiceOf: value, index: 82}
                        required: [valueString, value]
        Patient:
          match: {name: Patient}
          schema:
            index: 83
            elements:
              name:
                pattern: {type: String, value: Patient}
                index: 84
              part:
                array: true
                min: 4
                max: 4
                index: 85
                slicing:
                  rules: open
                  description: Slice Patient parameter parts based on the name
                  discriminator:
                  - {path: name, type: value}
                  min: 4
                  max: 4
                  slices:
                    DateOfBirth:
                      match: {name: DateOfBirth}
                      schema:
                        type: BackboneElement
                        _required: true
                        index: 86
                        elements:
                          name:
                            pattern: {type: String, value: DateOfBirth}
                            index: 87
                          value:
                            choices: [valueDate]
                            index: 89
                          valueDate: {type: date, choiceOf: value, index: 90}
                        required: [value, valueDate]
                    PatientID:
                      match: {name: PatientID}
                      schema:
                        type: BackboneElement
                        _required: true
                        index: 91
                        elements:
                          name:
                            pattern: {type: String, value: PatientID}
                            index: 92
                          value:
                            choices: [valueString]
                            index: 94
                          valueString: {type: string, choiceOf: value, index: 95}
                        required: [valueString, value]
                    PatientFirstName:
                      match: {name: PatientFirstName}
                      schema:
                        type: BackboneElement
                        _required: true
                        index: 96
                        elements:
                          name:
                            pattern: {type: String, value: PatientFirstName}
                            index: 97
                          value:
                            choices: [valueString]
                            index: 99
                          valueString: {type: string, choiceOf: value, index: 100}
                        required: [valueString, value]
                    PatientLastName:
                      match: {name: PatientLastName}
                      schema:
                        type: BackboneElement
                        _required: true
                        index: 101
                        elements:
                          name:
                            pattern: {type: String, value: PatientLastName}
                            index: 102
                          value:
                            choices: [valueString]
                            index: 104
                          valueString: {type: string, choiceOf: value, index: 105}
                        required: [valueString, value]
package_version: 1.0.0-ballot
class: profile
kind: resource
url: http://hl7.org/fhir/us/davinci-pr/StructureDefinition/searchResultParameters
base: http://hl7.org/fhir/StructureDefinition/Parameters
version: 1.0.0-ballot