Procedure (HAPI FHIR Structures - DSTU2.1 (2016May) 3.3.0 API)

java.lang.Object
- org.hl7.fhir.dstu2016may.model.Base
- - org.hl7.fhir.dstu2016may.model.BaseResource
  - - org.hl7.fhir.dstu2016may.model.Resource
    - - org.hl7.fhir.dstu2016may.model.DomainResource
      - org.hl7.fhir.dstu2016may.model.Procedure

All Implemented Interfaces:

ca.uhn.fhir.model.api.IElement, Serializable, org.hl7.fhir.instance.model.api.IAnyResource, org.hl7.fhir.instance.model.api.IBase, org.hl7.fhir.instance.model.api.IBaseHasExtensions, org.hl7.fhir.instance.model.api.IBaseHasModifierExtensions, org.hl7.fhir.instance.model.api.IBaseResource, org.hl7.fhir.instance.model.api.IDomainResource
```
public class Procedure
extends DomainResource
```
An action that is or was performed on a patient. This can be a physical intervention like an operation, or less invasive like counseling or hypnotherapy.

See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Procedure.ProcedureFocalDeviceComponent`
`static class`	`Procedure.ProcedurePerformerComponent`
`static class`	`Procedure.ProcedureStatus`
`static class`	`Procedure.ProcedureStatusEnumFactory`

Field Summary

Fields
Modifier and Type	Field and Description
`protected List<CodeableConcept>`	`bodySite` Detailed and structured anatomical location information.
`protected CodeableConcept`	`category` A code that classifies the procedure for searching, sorting and display purposes (e.g.
`protected CodeableConcept`	`code` The specific procedure that is performed.
`static ca.uhn.fhir.rest.gclient.TokenClientParam`	`CODE` Fluent Client search parameter constant for code
`protected List<CodeableConcept>`	`complication` Any complications that occurred during the procedure, or in the immediate post-performance period.
`static ca.uhn.fhir.rest.gclient.DateClientParam`	`DATE` Fluent Client search parameter constant for date
`protected Reference`	`encounter` The encounter during which the procedure was performed.
`static ca.uhn.fhir.rest.gclient.ReferenceClientParam`	`ENCOUNTER` Fluent Client search parameter constant for encounter
`protected Encounter`	`encounterTarget` The actual object that is the target of the reference (The encounter during which the procedure was performed.)
`protected List<Procedure.ProcedureFocalDeviceComponent>`	`focalDevice` A device that is implanted, removed or otherwise manipulated (calibration, battery replacement, fitting a prosthesis, attaching a wound-vac, etc.) as a focal portion of the Procedure.
`protected List<CodeableConcept>`	`followUp` If the procedure required specific follow up - e.g.
`protected List<Identifier>`	`identifier` This records identifiers associated with this procedure that are defined by business processes and/or used to refer to it when a direct URL reference to the resource itself is not appropriate (e.g.
`static ca.uhn.fhir.rest.gclient.TokenClientParam`	`IDENTIFIER` Fluent Client search parameter constant for identifier
`static ca.uhn.fhir.model.api.Include`	`INCLUDE_ENCOUNTER` Constant for fluent queries to be used to add include statements.
`static ca.uhn.fhir.model.api.Include`	`INCLUDE_LOCATION` Constant for fluent queries to be used to add include statements.
`static ca.uhn.fhir.model.api.Include`	`INCLUDE_PATIENT` Constant for fluent queries to be used to add include statements.
`static ca.uhn.fhir.model.api.Include`	`INCLUDE_PERFORMER` Constant for fluent queries to be used to add include statements.
`static ca.uhn.fhir.model.api.Include`	`INCLUDE_SUBJECT` Constant for fluent queries to be used to add include statements.
`protected Reference`	`location` The location where the procedure actually happened.
`static ca.uhn.fhir.rest.gclient.ReferenceClientParam`	`LOCATION` Fluent Client search parameter constant for location
`protected Location`	`locationTarget` The actual object that is the target of the reference (The location where the procedure actually happened.
`protected List<Annotation>`	`notes` Any other notes about the procedure.
`protected BooleanType`	`notPerformed` Set this to true if the record is saying that the procedure was NOT performed.
`protected CodeableConcept`	`outcome` The outcome of the procedure - did it resolve reasons for the procedure being performed?
`static ca.uhn.fhir.rest.gclient.ReferenceClientParam`	`PATIENT` Fluent Client search parameter constant for patient
`protected Type`	`performed` The date(time)/period over which the procedure was performed.
`protected List<Procedure.ProcedurePerformerComponent>`	`performer` Limited to 'real' people rather than equipment.
`static ca.uhn.fhir.rest.gclient.ReferenceClientParam`	`PERFORMER` Fluent Client search parameter constant for performer
`protected Type`	`reason` The reason why the procedure was performed.
`protected List<CodeableConcept>`	`reasonNotPerformed` A code indicating why the procedure was not performed.
`protected List<Reference>`	`report` This could be a histology result, pathology report, surgical report, etc..
`protected List<DiagnosticReport>`	`reportTarget` The actual objects that are the target of the reference (This could be a histology result, pathology report, surgical report, etc..)
`protected Reference`	`request` A reference to a resource that contains details of the request for this procedure.
`protected Resource`	`requestTarget` The actual object that is the target of the reference (A reference to a resource that contains details of the request for this procedure.)
`static String`	`SP_CODE` Search parameter: code
`static String`	`SP_DATE` Search parameter: date
`static String`	`SP_ENCOUNTER` Search parameter: encounter
`static String`	`SP_IDENTIFIER` Search parameter: identifier
`static String`	`SP_LOCATION` Search parameter: location
`static String`	`SP_PATIENT` Search parameter: patient
`static String`	`SP_PERFORMER` Search parameter: performer
`static String`	`SP_SUBJECT` Search parameter: subject
`protected Enumeration<Procedure.ProcedureStatus>`	`status` A code specifying the state of the procedure.
`protected Reference`	`subject` The person, animal or group on which the procedure was performed.
`static ca.uhn.fhir.rest.gclient.ReferenceClientParam`	`SUBJECT` Fluent Client search parameter constant for subject
`protected Resource`	`subjectTarget` The actual object that is the target of the reference (The person, animal or group on which the procedure was performed.)
`protected List<Reference>`	`used` Identifies medications, devices and any other substance used as part of the procedure.
`protected List<Resource>`	`usedTarget` The actual objects that are the target of the reference (Identifies medications, devices and any other substance used as part of the procedure.)

Fields inherited from class org.hl7.fhir.dstu2016may.model.DomainResource
contained, extension, modifierExtension, text

Fields inherited from class org.hl7.fhir.dstu2016may.model.Resource
id, implicitRules, language, meta

Fields inherited from interface org.hl7.fhir.instance.model.api.IAnyResource
RES_ID, SP_RES_ID, SP_RES_LANGUAGE

Fields inherited from interface org.hl7.fhir.instance.model.api.IBaseResource
INCLUDE_ALL, WILDCARD_ALL_SET

Constructor Summary

Constructors
Constructor and Description
`Procedure()` Constructor
`Procedure(Reference subject, Enumeration<Procedure.ProcedureStatus> status, CodeableConcept code)` Constructor

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`CodeableConcept`	`addBodySite()`
`Procedure`	`addBodySite(CodeableConcept t)`
`Base`	`addChild(String name)`
`CodeableConcept`	`addComplication()`
`Procedure`	`addComplication(CodeableConcept t)`
`Procedure.ProcedureFocalDeviceComponent`	`addFocalDevice()`
`Procedure`	`addFocalDevice(Procedure.ProcedureFocalDeviceComponent t)`
`CodeableConcept`	`addFollowUp()`
`Procedure`	`addFollowUp(CodeableConcept t)`
`Identifier`	`addIdentifier()`
`Procedure`	`addIdentifier(Identifier t)`
`Annotation`	`addNotes()`
`Procedure`	`addNotes(Annotation t)`
`Procedure.ProcedurePerformerComponent`	`addPerformer()`
`Procedure`	`addPerformer(Procedure.ProcedurePerformerComponent t)`
`CodeableConcept`	`addReasonNotPerformed()`
`Procedure`	`addReasonNotPerformed(CodeableConcept t)`
`Reference`	`addReport()`
`Procedure`	`addReport(Reference t)`
`DiagnosticReport`	`addReportTarget()`
`Reference`	`addUsed()`
`Procedure`	`addUsed(Reference t)`
`Procedure`	`copy()`
`boolean`	`equalsDeep(Base other)`
`boolean`	`equalsShallow(Base other)`
`String`	`fhirType()`
`List<CodeableConcept>`	`getBodySite()`
`CodeableConcept`	`getCategory()`
`CodeableConcept`	`getCode()`
`List<CodeableConcept>`	`getComplication()`
`Reference`	`getEncounter()`
`Encounter`	`getEncounterTarget()`
`List<Procedure.ProcedureFocalDeviceComponent>`	`getFocalDevice()`
`List<CodeableConcept>`	`getFollowUp()`
`List<Identifier>`	`getIdentifier()`
`Reference`	`getLocation()`
`Location`	`getLocationTarget()`
`List<Annotation>`	`getNotes()`
`boolean`	`getNotPerformed()`
`BooleanType`	`getNotPerformedElement()`
`CodeableConcept`	`getOutcome()`
`Type`	`getPerformed()`
`DateTimeType`	`getPerformedDateTimeType()`
`Period`	`getPerformedPeriod()`
`List<Procedure.ProcedurePerformerComponent>`	`getPerformer()`
`Base[]`	`getProperty(int hash, String name, boolean checkValid)`
`Type`	`getReason()`
`CodeableConcept`	`getReasonCodeableConcept()`
`List<CodeableConcept>`	`getReasonNotPerformed()`
`Reference`	`getReasonReference()`
`List<Reference>`	`getReport()`
`List<DiagnosticReport>`	`getReportTarget()`
`Reference`	`getRequest()`
`Resource`	`getRequestTarget()`
`ResourceType`	`getResourceType()`
`Procedure.ProcedureStatus`	`getStatus()`
`Enumeration<Procedure.ProcedureStatus>`	`getStatusElement()`
`Reference`	`getSubject()`
`Resource`	`getSubjectTarget()`
`List<Reference>`	`getUsed()`
`List<Resource>`	`getUsedTarget()`
`boolean`	`hasBodySite()`
`boolean`	`hasCategory()`
`boolean`	`hasCode()`
`boolean`	`hasComplication()`
`boolean`	`hasEncounter()`
`boolean`	`hasFocalDevice()`
`boolean`	`hasFollowUp()`
`boolean`	`hasIdentifier()`
`boolean`	`hasLocation()`
`boolean`	`hasNotes()`
`boolean`	`hasNotPerformed()`
`boolean`	`hasNotPerformedElement()`
`boolean`	`hasOutcome()`
`boolean`	`hasPerformed()`
`boolean`	`hasPerformedDateTimeType()`
`boolean`	`hasPerformedPeriod()`
`boolean`	`hasPerformer()`
`boolean`	`hasReason()`
`boolean`	`hasReasonCodeableConcept()`
`boolean`	`hasReasonNotPerformed()`
`boolean`	`hasReasonReference()`
`boolean`	`hasReport()`
`boolean`	`hasRequest()`
`boolean`	`hasStatus()`
`boolean`	`hasStatusElement()`
`boolean`	`hasSubject()`
`boolean`	`hasUsed()`
`boolean`	`isEmpty()`
`protected void`	`listChildren(List<Property> childrenList)`
`Base`	`makeProperty(int hash, String name)`
`Procedure`	`setCategory(CodeableConcept value)`
`Procedure`	`setCode(CodeableConcept value)`
`Procedure`	`setEncounter(Reference value)`
`Procedure`	`setEncounterTarget(Encounter value)`
`Procedure`	`setLocation(Reference value)`
`Procedure`	`setLocationTarget(Location value)`
`Procedure`	`setNotPerformed(boolean value)`
`Procedure`	`setNotPerformedElement(BooleanType value)`
`Procedure`	`setOutcome(CodeableConcept value)`
`Procedure`	`setPerformed(Type value)`
`void`	`setProperty(int hash, String name, Base value)`
`void`	`setProperty(String name, Base value)`
`Procedure`	`setReason(Type value)`
`Procedure`	`setRequest(Reference value)`
`Procedure`	`setRequestTarget(Resource value)`
`Procedure`	`setStatus(Procedure.ProcedureStatus value)`
`Procedure`	`setStatusElement(Enumeration<Procedure.ProcedureStatus> value)`
`Procedure`	`setSubject(Reference value)`
`Procedure`	`setSubjectTarget(Resource value)`
`protected Procedure`	`typedCopy()`

Methods inherited from class org.hl7.fhir.dstu2016may.model.DomainResource
addContained, addExtension, addExtension, addModifierExtension, addModifierExtension, copyValues, getContained, getExtension, getExtensionsByUrl, getModifierExtension, getModifierExtensionsByUrl, getText, hasContained, hasExtension, hasModifierExtension, hasText, setText

Methods inherited from class org.hl7.fhir.dstu2016may.model.Resource
copyValues, getId, getIdElement, getImplicitRules, getImplicitRulesElement, getLanguage, getLanguageElement, getMeta, hasId, hasIdElement, hasImplicitRules, hasImplicitRulesElement, hasLanguage, hasLanguageElement, hasMeta, setId, setIdElement, setImplicitRules, setImplicitRulesElement, setLanguage, setLanguageElement, setMeta

Methods inherited from class org.hl7.fhir.dstu2016may.model.BaseResource
getStructureFhirVersionEnum, setId

Methods inherited from class org.hl7.fhir.dstu2016may.model.Base
castToActionDefinition, castToAddress, castToAnnotation, castToAttachment, castToBase64Binary, castToBoolean, castToCode, castToCodeableConcept, castToCoding, castToContactPoint, castToDataRequirement, castToDate, castToDateTime, castToDecimal, castToDuration, castToElementDefinition, castToExtension, castToHumanName, castToId, castToIdentifier, castToInstant, castToInteger, castToMarkdown, castToMeta, castToModuleMetadata, castToMoney, castToNarrative, castToOid, castToParameterDefinition, castToPeriod, castToPositiveInt, castToQuantity, castToRange, castToRatio, castToReference, castToResource, castToSampledData, castToSignature, castToSimpleQuantity, castToString, castToTime, castToTiming, castToTriggerDefinition, castToUnsignedInt, castToUri, children, compareDeep, compareDeep, compareDeep, compareValues, compareValues, equals, getChildByName, getFormatCommentsPost, getFormatCommentsPre, getUserData, getUserInt, getUserString, hasFormatComment, hasPrimitiveValue, hasType, hasUserData, isMetadataBased, isPrimitive, listChildrenByName, listChildrenByName, primitiveValue, setUserData, setUserDataINN

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.hl7.fhir.instance.model.api.IAnyResource
getId, getIdElement, getLanguageElement, getUserData, setId, setUserData

Methods inherited from interface org.hl7.fhir.instance.model.api.IBaseResource
getMeta, getStructureFhirVersionEnum, setId

Methods inherited from interface org.hl7.fhir.instance.model.api.IBase
getFormatCommentsPost, getFormatCommentsPre, hasFormatComment

- Field Detail
  - identifier
```
protected List<Identifier> identifier
```
    This records identifiers associated with this procedure that are defined by business processes and/or used to refer to it when a direct URL reference to the resource itself is not appropriate (e.g. in CDA documents, or in written / printed documentation).
  - subject
```
protected Reference subject
```
    The person, animal or group on which the procedure was performed.
  - subjectTarget
```
protected Resource subjectTarget
```
    The actual object that is the target of the reference (The person, animal or group on which the procedure was performed.)
  - status
```
protected Enumeration<Procedure.ProcedureStatus> status
```
    A code specifying the state of the procedure. Generally this will be in-progress or completed state.
  - category
```
protected CodeableConcept category
```
    A code that classifies the procedure for searching, sorting and display purposes (e.g. "Surgical Procedure").
  - code
```
protected CodeableConcept code
```
    The specific procedure that is performed. Use text if the exact nature of the procedure cannot be coded (e.g. "Laparoscopic Appendectomy").
  - notPerformed
```
protected BooleanType notPerformed
```
    Set this to true if the record is saying that the procedure was NOT performed.
  - reasonNotPerformed
```
protected List<CodeableConcept> reasonNotPerformed
```
    A code indicating why the procedure was not performed.
  - bodySite
```
protected List<CodeableConcept> bodySite
```
    Detailed and structured anatomical location information. Multiple locations are allowed - e.g. multiple punch biopsies of a lesion.
  - reason
```
protected Type reason
```
    The reason why the procedure was performed. This may be due to a Condition, may be coded entity of some type, or may simply be present as text.
  - performer
```
protected List<Procedure.ProcedurePerformerComponent> performer
```
    Limited to 'real' people rather than equipment.
  - performed
```
protected Type performed
```
    The date(time)/period over which the procedure was performed. Allows a period to support complex procedures that span more than one date, and also allows for the length of the procedure to be captured.
  - encounter
```
protected Reference encounter
```
    The encounter during which the procedure was performed.
  - encounterTarget
```
protected Encounter encounterTarget
```
    The actual object that is the target of the reference (The encounter during which the procedure was performed.)
  - location
```
protected Reference location
```
    The location where the procedure actually happened. E.g. a newborn at home, a tracheostomy at a restaurant.
  - locationTarget
```
protected Location locationTarget
```
    The actual object that is the target of the reference (The location where the procedure actually happened. E.g. a newborn at home, a tracheostomy at a restaurant.)
  - outcome
```
protected CodeableConcept outcome
```
    The outcome of the procedure - did it resolve reasons for the procedure being performed?
  - report
```
protected List<Reference> report
```
    This could be a histology result, pathology report, surgical report, etc..
  - reportTarget
```
protected List<DiagnosticReport> reportTarget
```
    The actual objects that are the target of the reference (This could be a histology result, pathology report, surgical report, etc..)
  - complication
```
protected List<CodeableConcept> complication
```
    Any complications that occurred during the procedure, or in the immediate post-performance period. These are generally tracked separately from the notes, which will typically describe the procedure itself rather than any 'post procedure' issues.
  - followUp
```
protected List<CodeableConcept> followUp
```
    If the procedure required specific follow up - e.g. removal of sutures. The followup may be represented as a simple note, or could potentially be more complex in which case the CarePlan resource can be used.
  - request
```
protected Reference request
```
    A reference to a resource that contains details of the request for this procedure.
  - requestTarget
```
protected Resource requestTarget
```
    The actual object that is the target of the reference (A reference to a resource that contains details of the request for this procedure.)
  - notes
```
protected List<Annotation> notes
```
    Any other notes about the procedure. E.g. the operative notes.
  - focalDevice
```
protected List<Procedure.ProcedureFocalDeviceComponent> focalDevice
```
    A device that is implanted, removed or otherwise manipulated (calibration, battery replacement, fitting a prosthesis, attaching a wound-vac, etc.) as a focal portion of the Procedure.
  - used
```
protected List<Reference> used
```
    Identifies medications, devices and any other substance used as part of the procedure.
  - usedTarget
```
protected List<Resource> usedTarget
```
    The actual objects that are the target of the reference (Identifies medications, devices and any other substance used as part of the procedure.)
  - SP_PATIENT
```
public static final String SP_PATIENT
```
    Search parameter: patient
    Description: Search by subject - a patient
    Type: reference
    Path: Procedure.subject
    
    See Also:
    
    Constant Field Values
  - PATIENT
```
public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PATIENT
```
    Fluent Client search parameter constant for patient
    Description: Search by subject - a patient
    Type: reference
    Path: Procedure.subject
  - INCLUDE_PATIENT
```
public static final ca.uhn.fhir.model.api.Include INCLUDE_PATIENT
```
    Constant for fluent queries to be used to add include statements. Specifies the path value of "Procedure:patient".
  - SP_LOCATION
```
public static final String SP_LOCATION
```
    Search parameter: location
    Description: Where the procedure happened
    Type: reference
    Path: Procedure.location
    
    See Also:
    
    Constant Field Values
  - LOCATION
```
public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam LOCATION
```
    Fluent Client search parameter constant for location
    Description: Where the procedure happened
    Type: reference
    Path: Procedure.location
  - INCLUDE_LOCATION
```
public static final ca.uhn.fhir.model.api.Include INCLUDE_LOCATION
```
    Constant for fluent queries to be used to add include statements. Specifies the path value of "Procedure:location".
  - SP_SUBJECT
```
public static final String SP_SUBJECT
```
    Search parameter: subject
    Description: Search by subject
    Type: reference
    Path: Procedure.subject
    
    See Also:
    
    Constant Field Values
  - SUBJECT
```
public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam SUBJECT
```
    Fluent Client search parameter constant for subject
    Description: Search by subject
    Type: reference
    Path: Procedure.subject
  - INCLUDE_SUBJECT
```
public static final ca.uhn.fhir.model.api.Include INCLUDE_SUBJECT
```
    Constant for fluent queries to be used to add include statements. Specifies the path value of "Procedure:subject".
  - SP_PERFORMER
```
public static final String SP_PERFORMER
```
    Search parameter: performer
    Description: The reference to the practitioner
    Type: reference
    Path: Procedure.performer.actor
    
    See Also:
    
    Constant Field Values
  - PERFORMER
```
public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PERFORMER
```
    Fluent Client search parameter constant for performer
    Description: The reference to the practitioner
    Type: reference
    Path: Procedure.performer.actor
  - INCLUDE_PERFORMER
```
public static final ca.uhn.fhir.model.api.Include INCLUDE_PERFORMER
```
    Constant for fluent queries to be used to add include statements. Specifies the path value of "Procedure:performer".
  - SP_ENCOUNTER
```
public static final String SP_ENCOUNTER
```
    Search parameter: encounter
    Description: The encounter associated with the procedure
    Type: reference
    Path: Procedure.encounter
    
    See Also:
    
    Constant Field Values
  - ENCOUNTER
```
public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam ENCOUNTER
```
    Fluent Client search parameter constant for encounter
    Description: The encounter associated with the procedure
    Type: reference
    Path: Procedure.encounter
  - INCLUDE_ENCOUNTER
```
public static final ca.uhn.fhir.model.api.Include INCLUDE_ENCOUNTER
```
    Constant for fluent queries to be used to add include statements. Specifies the path value of "Procedure:encounter".
  - SP_CODE
```
public static final String SP_CODE
```
    Search parameter: code
    Description: A code to identify a procedure
    Type: token
    Path: Procedure.code
    
    See Also:
    
    Constant Field Values
  - CODE
```
public static final ca.uhn.fhir.rest.gclient.TokenClientParam CODE
```
    Fluent Client search parameter constant for code
    Description: A code to identify a procedure
    Type: token
    Path: Procedure.code
  - SP_DATE
```
public static final String SP_DATE
```
    Search parameter: date
    Description: Date/Period the procedure was performed
    Type: date
    Path: Procedure.performed[x]
    
    See Also:
    
    Constant Field Values
  - DATE
```
public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE
```
    Fluent Client search parameter constant for date
    Description: Date/Period the procedure was performed
    Type: date
    Path: Procedure.performed[x]
  - SP_IDENTIFIER
```
public static final String SP_IDENTIFIER
```
    Search parameter: identifier
    Description: A unique identifier for a procedure
    Type: token
    Path: Procedure.identifier
    
    See Also:
    
    Constant Field Values
  - IDENTIFIER
```
public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER
```
    Fluent Client search parameter constant for identifier
    Description: A unique identifier for a procedure
    Type: token
    Path: Procedure.identifier
- Constructor Detail
  - Procedure
```
public Procedure()
```
    Constructor
  - Procedure
```
public Procedure(Reference subject,
                 Enumeration<Procedure.ProcedureStatus> status,
                 CodeableConcept code)
```
    Constructor
- Method Detail
  - getIdentifier
```
public List<Identifier> getIdentifier()
```
    Returns:
    
    identifier (This records identifiers associated with this procedure that are defined by business processes and/or used to refer to it when a direct URL reference to the resource itself is not appropriate (e.g. in CDA documents, or in written / printed documentation).)
  - hasIdentifier
```
public boolean hasIdentifier()
```
  - addIdentifier
```
public Identifier addIdentifier()
```
    Returns:
    
    identifier (This records identifiers associated with this procedure that are defined by business processes and/or used to refer to it when a direct URL reference to the resource itself is not appropriate (e.g. in CDA documents, or in written / printed documentation).)
  - addIdentifier
```
public Procedure addIdentifier(Identifier t)
```
  - getSubject
```
public Reference getSubject()
```
    Returns:
    
    subject (The person, animal or group on which the procedure was performed.)
  - hasSubject
```
public boolean hasSubject()
```
  - setSubject
```
public Procedure setSubject(Reference value)
```
    Parameters:
    
    value - subject (The person, animal or group on which the procedure was performed.)
  - getSubjectTarget
```
public Resource getSubjectTarget()
```
    Returns:
    
    subject The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The person, animal or group on which the procedure was performed.)
  - setSubjectTarget
```
public Procedure setSubjectTarget(Resource value)
```
    Parameters:
    
    value - subject The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The person, animal or group on which the procedure was performed.)
  - getStatusElement
```
public Enumeration<Procedure.ProcedureStatus> getStatusElement()
```
    Returns:
    
    status (A code specifying the state of the procedure. Generally this will be in-progress or completed state.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value
  - hasStatusElement
```
public boolean hasStatusElement()
```
  - hasStatus
```
public boolean hasStatus()
```
  - setStatusElement
```
public Procedure setStatusElement(Enumeration<Procedure.ProcedureStatus> value)
```
    Parameters:
    
    value - status (A code specifying the state of the procedure. Generally this will be in-progress or completed state.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value
  - getStatus
```
public Procedure.ProcedureStatus getStatus()
```
    Returns:
    
    A code specifying the state of the procedure. Generally this will be in-progress or completed state.
  - setStatus
```
public Procedure setStatus(Procedure.ProcedureStatus value)
```
    Parameters:
    
    value - A code specifying the state of the procedure. Generally this will be in-progress or completed state.
  - getCategory
```
public CodeableConcept getCategory()
```
    Returns:
    
    category (A code that classifies the procedure for searching, sorting and display purposes (e.g. "Surgical Procedure").)
  - hasCategory
```
public boolean hasCategory()
```
  - setCategory
```
public Procedure setCategory(CodeableConcept value)
```
    Parameters:
    
    value - category (A code that classifies the procedure for searching, sorting and display purposes (e.g. "Surgical Procedure").)
  - getCode
```
public CodeableConcept getCode()
```
    Returns:
    
    code (The specific procedure that is performed. Use text if the exact nature of the procedure cannot be coded (e.g. "Laparoscopic Appendectomy").)
  - hasCode
```
public boolean hasCode()
```
  - setCode
```
public Procedure setCode(CodeableConcept value)
```
    Parameters:
    
    value - code (The specific procedure that is performed. Use text if the exact nature of the procedure cannot be coded (e.g. "Laparoscopic Appendectomy").)
  - getNotPerformedElement
```
public BooleanType getNotPerformedElement()
```
    Returns:
    
    notPerformed (Set this to true if the record is saying that the procedure was NOT performed.). This is the underlying object with id, value and extensions. The accessor "getNotPerformed" gives direct access to the value
  - hasNotPerformedElement
```
public boolean hasNotPerformedElement()
```
  - hasNotPerformed
```
public boolean hasNotPerformed()
```
  - setNotPerformedElement
```
public Procedure setNotPerformedElement(BooleanType value)
```
    Parameters:
    
    value - notPerformed (Set this to true if the record is saying that the procedure was NOT performed.). This is the underlying object with id, value and extensions. The accessor "getNotPerformed" gives direct access to the value
  - getNotPerformed
```
public boolean getNotPerformed()
```
    Returns:
    
    Set this to true if the record is saying that the procedure was NOT performed.
  - setNotPerformed
```
public Procedure setNotPerformed(boolean value)
```
    Parameters:
    
    value - Set this to true if the record is saying that the procedure was NOT performed.
  - getReasonNotPerformed
```
public List<CodeableConcept> getReasonNotPerformed()
```
    Returns:
    
    reasonNotPerformed (A code indicating why the procedure was not performed.)
  - hasReasonNotPerformed
```
public boolean hasReasonNotPerformed()
```
  - addReasonNotPerformed
```
public CodeableConcept addReasonNotPerformed()
```
    Returns:
    
    reasonNotPerformed (A code indicating why the procedure was not performed.)
  - addReasonNotPerformed
```
public Procedure addReasonNotPerformed(CodeableConcept t)
```
  - getBodySite
```
public List<CodeableConcept> getBodySite()
```
    Returns:
    
    bodySite (Detailed and structured anatomical location information. Multiple locations are allowed - e.g. multiple punch biopsies of a lesion.)
  - hasBodySite
```
public boolean hasBodySite()
```
  - addBodySite
```
public CodeableConcept addBodySite()
```
    Returns:
    
    bodySite (Detailed and structured anatomical location information. Multiple locations are allowed - e.g. multiple punch biopsies of a lesion.)
  - addBodySite
```
public Procedure addBodySite(CodeableConcept t)
```
  - getReason
```
public Type getReason()
```
    Returns:
    
    reason (The reason why the procedure was performed. This may be due to a Condition, may be coded entity of some type, or may simply be present as text.)
  - getReasonCodeableConcept
```
public CodeableConcept getReasonCodeableConcept()
                                         throws org.hl7.fhir.exceptions.FHIRException
```
    Returns:
    
    reason (The reason why the procedure was performed. This may be due to a Condition, may be coded entity of some type, or may simply be present as text.)
    
    Throws:
    
    org.hl7.fhir.exceptions.FHIRException
  - hasReasonCodeableConcept
```
public boolean hasReasonCodeableConcept()
```
  - getReasonReference
```
public Reference getReasonReference()
                             throws org.hl7.fhir.exceptions.FHIRException
```
    Returns:
    
    reason (The reason why the procedure was performed. This may be due to a Condition, may be coded entity of some type, or may simply be present as text.)
    
    Throws:
    
    org.hl7.fhir.exceptions.FHIRException
  - hasReasonReference
```
public boolean hasReasonReference()
```
  - hasReason
```
public boolean hasReason()
```
  - setReason
```
public Procedure setReason(Type value)
```
    Parameters:
    
    value - reason (The reason why the procedure was performed. This may be due to a Condition, may be coded entity of some type, or may simply be present as text.)
  - getPerformer
```
public List<Procedure.ProcedurePerformerComponent> getPerformer()
```
    Returns:
    
    performer (Limited to 'real' people rather than equipment.)
  - hasPerformer
```
public boolean hasPerformer()
```
  - addPerformer
```
public Procedure.ProcedurePerformerComponent addPerformer()
```
    Returns:
    
    performer (Limited to 'real' people rather than equipment.)
  - addPerformer
```
public Procedure addPerformer(Procedure.ProcedurePerformerComponent t)
```
  - getPerformed
```
public Type getPerformed()
```
    Returns:
    
    performed (The date(time)/period over which the procedure was performed. Allows a period to support complex procedures that span more than one date, and also allows for the length of the procedure to be captured.)
  - getPerformedDateTimeType
```
public DateTimeType getPerformedDateTimeType()
                                      throws org.hl7.fhir.exceptions.FHIRException
```
    Returns:
    
    performed (The date(time)/period over which the procedure was performed. Allows a period to support complex procedures that span more than one date, and also allows for the length of the procedure to be captured.)
    
    Throws:
    
    org.hl7.fhir.exceptions.FHIRException
  - hasPerformedDateTimeType
```
public boolean hasPerformedDateTimeType()
```
  - getPerformedPeriod
```
public Period getPerformedPeriod()
                          throws org.hl7.fhir.exceptions.FHIRException
```
    Returns:
    
    performed (The date(time)/period over which the procedure was performed. Allows a period to support complex procedures that span more than one date, and also allows for the length of the procedure to be captured.)
    
    Throws:
    
    org.hl7.fhir.exceptions.FHIRException
  - hasPerformedPeriod
```
public boolean hasPerformedPeriod()
```
  - hasPerformed
```
public boolean hasPerformed()
```
  - setPerformed
```
public Procedure setPerformed(Type value)
```
    Parameters:
    
    value - performed (The date(time)/period over which the procedure was performed. Allows a period to support complex procedures that span more than one date, and also allows for the length of the procedure to be captured.)
  - getEncounter
```
public Reference getEncounter()
```
    Returns:
    
    encounter (The encounter during which the procedure was performed.)
  - hasEncounter
```
public boolean hasEncounter()
```
  - setEncounter
```
public Procedure setEncounter(Reference value)
```
    Parameters:
    
    value - encounter (The encounter during which the procedure was performed.)
  - getEncounterTarget
```
public Encounter getEncounterTarget()
```
    Returns:
    
    encounter The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The encounter during which the procedure was performed.)
  - setEncounterTarget
```
public Procedure setEncounterTarget(Encounter value)
```
    Parameters:
    
    value - encounter The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The encounter during which the procedure was performed.)
  - getLocation
```
public Reference getLocation()
```
    Returns:
    
    location (The location where the procedure actually happened. E.g. a newborn at home, a tracheostomy at a restaurant.)
  - hasLocation
```
public boolean hasLocation()
```
  - setLocation
```
public Procedure setLocation(Reference value)
```
    Parameters:
    
    value - location (The location where the procedure actually happened. E.g. a newborn at home, a tracheostomy at a restaurant.)
  - getLocationTarget
```
public Location getLocationTarget()
```
    Returns:
    
    location The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The location where the procedure actually happened. E.g. a newborn at home, a tracheostomy at a restaurant.)
  - setLocationTarget
```
public Procedure setLocationTarget(Location value)
```
    Parameters:
    
    value - location The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The location where the procedure actually happened. E.g. a newborn at home, a tracheostomy at a restaurant.)
  - getOutcome
```
public CodeableConcept getOutcome()
```
    Returns:
    
    outcome (The outcome of the procedure - did it resolve reasons for the procedure being performed?)
  - hasOutcome
```
public boolean hasOutcome()
```
  - setOutcome
```
public Procedure setOutcome(CodeableConcept value)
```
    Parameters:
    
    value - outcome (The outcome of the procedure - did it resolve reasons for the procedure being performed?)
  - getReport
```
public List<Reference> getReport()
```
    Returns:
    
    report (This could be a histology result, pathology report, surgical report, etc..)
  - hasReport
```
public boolean hasReport()
```
  - addReport
```
public Reference addReport()
```
    Returns:
    
    report (This could be a histology result, pathology report, surgical report, etc..)
  - addReport
```
public Procedure addReport(Reference t)
```
  - getReportTarget
```
public List<DiagnosticReport> getReportTarget()
```
    Returns:
    
    report (The actual objects that are the target of the reference. The reference library doesn't populate this, but you can use this to hold the resources if you resolvethemt. This could be a histology result, pathology report, surgical report, etc..)
  - addReportTarget
```
public DiagnosticReport addReportTarget()
```
    Returns:
    
    report (Add an actual object that is the target of the reference. The reference library doesn't use these, but you can use this to hold the resources if you resolvethemt. This could be a histology result, pathology report, surgical report, etc..)
  - getComplication
```
public List<CodeableConcept> getComplication()
```
    Returns:
    
    complication (Any complications that occurred during the procedure, or in the immediate post-performance period. These are generally tracked separately from the notes, which will typically describe the procedure itself rather than any 'post procedure' issues.)
  - hasComplication
```
public boolean hasComplication()
```
  - addComplication
```
public CodeableConcept addComplication()
```
    Returns:
    
    complication (Any complications that occurred during the procedure, or in the immediate post-performance period. These are generally tracked separately from the notes, which will typically describe the procedure itself rather than any 'post procedure' issues.)
  - addComplication
```
public Procedure addComplication(CodeableConcept t)
```
  - getFollowUp
```
public List<CodeableConcept> getFollowUp()
```
    Returns:
    
    followUp (If the procedure required specific follow up - e.g. removal of sutures. The followup may be represented as a simple note, or could potentially be more complex in which case the CarePlan resource can be used.)
  - hasFollowUp
```
public boolean hasFollowUp()
```
  - addFollowUp
```
public CodeableConcept addFollowUp()
```
    Returns:
    
    followUp (If the procedure required specific follow up - e.g. removal of sutures. The followup may be represented as a simple note, or could potentially be more complex in which case the CarePlan resource can be used.)
  - addFollowUp
```
public Procedure addFollowUp(CodeableConcept t)
```
  - getRequest
```
public Reference getRequest()
```
    Returns:
    
    request (A reference to a resource that contains details of the request for this procedure.)
  - hasRequest
```
public boolean hasRequest()
```
  - setRequest
```
public Procedure setRequest(Reference value)
```
    Parameters:
    
    value - request (A reference to a resource that contains details of the request for this procedure.)
  - getRequestTarget
```
public Resource getRequestTarget()
```
    Returns:
    
    request The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (A reference to a resource that contains details of the request for this procedure.)
  - setRequestTarget
```
public Procedure setRequestTarget(Resource value)
```
    Parameters:
    
    value - request The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (A reference to a resource that contains details of the request for this procedure.)
  - getNotes
```
public List<Annotation> getNotes()
```
    Returns:
    
    notes (Any other notes about the procedure. E.g. the operative notes.)
  - hasNotes
```
public boolean hasNotes()
```
  - addNotes
```
public Annotation addNotes()
```
    Returns:
    
    notes (Any other notes about the procedure. E.g. the operative notes.)
  - addNotes
```
public Procedure addNotes(Annotation t)
```
  - getFocalDevice
```
public List<Procedure.ProcedureFocalDeviceComponent> getFocalDevice()
```
    Returns:
    
    focalDevice (A device that is implanted, removed or otherwise manipulated (calibration, battery replacement, fitting a prosthesis, attaching a wound-vac, etc.) as a focal portion of the Procedure.)
  - hasFocalDevice
```
public boolean hasFocalDevice()
```
  - addFocalDevice
```
public Procedure.ProcedureFocalDeviceComponent addFocalDevice()
```
    Returns:
    
    focalDevice (A device that is implanted, removed or otherwise manipulated (calibration, battery replacement, fitting a prosthesis, attaching a wound-vac, etc.) as a focal portion of the Procedure.)
  - addFocalDevice
```
public Procedure addFocalDevice(Procedure.ProcedureFocalDeviceComponent t)
```
  - getUsed
```
public List<Reference> getUsed()
```
    Returns:
    
    used (Identifies medications, devices and any other substance used as part of the procedure.)
  - hasUsed
```
public boolean hasUsed()
```
  - addUsed
```
public Reference addUsed()
```
    Returns:
    
    used (Identifies medications, devices and any other substance used as part of the procedure.)
  - addUsed
```
public Procedure addUsed(Reference t)
```
  - getUsedTarget
```
public List<Resource> getUsedTarget()
```
    Returns:
    
    used (The actual objects that are the target of the reference. The reference library doesn't populate this, but you can use this to hold the resources if you resolvethemt. Identifies medications, devices and any other substance used as part of the procedure.)
  - listChildren
```
protected void listChildren(List<Property> childrenList)
```
    Overrides:
    
    listChildren in class DomainResource
  - getProperty
```
public Base[] getProperty(int hash,
                          String name,
                          boolean checkValid)
                   throws org.hl7.fhir.exceptions.FHIRException
```
    Overrides:
    
    getProperty in class DomainResource
    
    Throws:
    
    org.hl7.fhir.exceptions.FHIRException
  - setProperty
```
public void setProperty(int hash,
                        String name,
                        Base value)
                 throws org.hl7.fhir.exceptions.FHIRException
```
    Overrides:
    
    setProperty in class DomainResource
    
    Throws:
    
    org.hl7.fhir.exceptions.FHIRException
  - setProperty
```
public void setProperty(String name,
                        Base value)
                 throws org.hl7.fhir.exceptions.FHIRException
```
    Overrides:
    
    setProperty in class DomainResource
    
    Throws:
    
    org.hl7.fhir.exceptions.FHIRException
  - makeProperty
```
public Base makeProperty(int hash,
                         String name)
                  throws org.hl7.fhir.exceptions.FHIRException
```
    Overrides:
    
    makeProperty in class DomainResource
    
    Throws:
    
    org.hl7.fhir.exceptions.FHIRException
  - addChild
```
public Base addChild(String name)
              throws org.hl7.fhir.exceptions.FHIRException
```
    Overrides:
    
    addChild in class DomainResource
    
    Throws:
    
    org.hl7.fhir.exceptions.FHIRException
  - fhirType
```
public String fhirType()
```
    Overrides:
    
    fhirType in class DomainResource
  - copy
```
public Procedure copy()
```
    Specified by:
    
    copy in class DomainResource
  - typedCopy
```
protected Procedure typedCopy()
```
  - equalsDeep
```
public boolean equalsDeep(Base other)
```
    Overrides:
    
    equalsDeep in class DomainResource
  - equalsShallow
```
public boolean equalsShallow(Base other)
```
    Overrides:
    
    equalsShallow in class DomainResource
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface org.hl7.fhir.instance.model.api.IBase
    
    Overrides:
    
    isEmpty in class DomainResource
  - getResourceType
```
public ResourceType getResourceType()
```
    Specified by:
    
    getResourceType in class Resource

Class Procedure

Nested Class Summary

Field Summary

Fields inherited from class org.hl7.fhir.dstu2016may.model.DomainResource

Fields inherited from class org.hl7.fhir.dstu2016may.model.Resource

Fields inherited from interface org.hl7.fhir.instance.model.api.IAnyResource

Fields inherited from interface org.hl7.fhir.instance.model.api.IBaseResource

Constructor Summary

Method Summary

Methods inherited from class org.hl7.fhir.dstu2016may.model.DomainResource

Methods inherited from class org.hl7.fhir.dstu2016may.model.Resource

Methods inherited from class org.hl7.fhir.dstu2016may.model.BaseResource

Methods inherited from class org.hl7.fhir.dstu2016may.model.Base

Methods inherited from class java.lang.Object

Methods inherited from interface org.hl7.fhir.instance.model.api.IAnyResource

Methods inherited from interface org.hl7.fhir.instance.model.api.IBaseResource

Methods inherited from interface org.hl7.fhir.instance.model.api.IBase

Field Detail

identifier

subject

subjectTarget

status

category

code

notPerformed

reasonNotPerformed

bodySite

reason

performer

performed

encounter

encounterTarget

location

locationTarget

outcome

report

reportTarget

complication

followUp

request

requestTarget

notes

focalDevice

used

usedTarget

SP_PATIENT

PATIENT

INCLUDE_PATIENT

SP_LOCATION

LOCATION

INCLUDE_LOCATION

SP_SUBJECT

SUBJECT

INCLUDE_SUBJECT

SP_PERFORMER

PERFORMER

INCLUDE_PERFORMER

SP_ENCOUNTER

ENCOUNTER

INCLUDE_ENCOUNTER

SP_CODE

CODE

SP_DATE

DATE

SP_IDENTIFIER

IDENTIFIER

Constructor Detail

Procedure

Procedure

Method Detail

getIdentifier

hasIdentifier

addIdentifier

addIdentifier

getSubject

hasSubject

setSubject

getSubjectTarget

setSubjectTarget

getStatusElement