001package org.hl7.fhir.r5.model;
002
003
004/*
005  Copyright (c) 2011+, HL7, Inc.
006  All rights reserved.
007  
008  Redistribution and use in source and binary forms, with or without modification, \
009  are permitted provided that the following conditions are met:
010  
011   * Redistributions of source code must retain the above copyright notice, this \
012     list of conditions and the following disclaimer.
013   * Redistributions in binary form must reproduce the above copyright notice, \
014     this list of conditions and the following disclaimer in the documentation \
015     and/or other materials provided with the distribution.
016   * Neither the name of HL7 nor the names of its contributors may be used to 
017     endorse or promote products derived from this software without specific 
018     prior written permission.
019  
020  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND \
021  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED \
022  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \
023  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, \
024  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT \
025  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR \
026  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \
027  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) \
028  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \
029  POSSIBILITY OF SUCH DAMAGE.
030  */
031
032// Generated on Thu, Mar 23, 2023 19:59+1100 for FHIR v5.0.0
033
034import java.util.ArrayList;
035import java.util.Date;
036import java.util.List;
037import org.hl7.fhir.utilities.Utilities;
038import org.hl7.fhir.r5.model.Enumerations.*;
039import org.hl7.fhir.instance.model.api.IBaseBackboneElement;
040import org.hl7.fhir.exceptions.FHIRException;
041import org.hl7.fhir.instance.model.api.ICompositeType;
042import ca.uhn.fhir.model.api.annotation.ResourceDef;
043import ca.uhn.fhir.model.api.annotation.SearchParamDefinition;
044import org.hl7.fhir.instance.model.api.IBaseBackboneElement;
045import ca.uhn.fhir.model.api.annotation.Child;
046import ca.uhn.fhir.model.api.annotation.ChildOrder;
047import ca.uhn.fhir.model.api.annotation.Description;
048import ca.uhn.fhir.model.api.annotation.Block;
049
050/**
051 * This resource describes the properties (regulated, has real time clock, etc.), adminstrative (manufacturer name, model number, serial number, firmware, etc.), and type (knee replacement, blood pressure cuff, MRI, etc.) of a physical unit (these values do not change much within a given module, for example the serail number, manufacturer name, and model number). An actual unit may consist of several modules in a distinct hierarchy and these are represented by multiple Device resources and bound through the 'parent' element.
052 */
053@ResourceDef(name="Device", profile="http://hl7.org/fhir/StructureDefinition/Device")
054public class Device extends DomainResource {
055
056    public enum FHIRDeviceStatus {
057        /**
058         * The device record is current and is appropriate for reference in new instances.
059         */
060        ACTIVE, 
061        /**
062         * The device record is not current and is not appropriate for reference in new instances.
063         */
064        INACTIVE, 
065        /**
066         * The device record is not current and is not appropriate for reference in new instances.
067         */
068        ENTEREDINERROR, 
069        /**
070         * added to help the parsers with the generic types
071         */
072        NULL;
073        public static FHIRDeviceStatus fromCode(String codeString) throws FHIRException {
074            if (codeString == null || "".equals(codeString))
075                return null;
076        if ("active".equals(codeString))
077          return ACTIVE;
078        if ("inactive".equals(codeString))
079          return INACTIVE;
080        if ("entered-in-error".equals(codeString))
081          return ENTEREDINERROR;
082        if (Configuration.isAcceptInvalidEnums())
083          return null;
084        else
085          throw new FHIRException("Unknown FHIRDeviceStatus code '"+codeString+"'");
086        }
087        public String toCode() {
088          switch (this) {
089            case ACTIVE: return "active";
090            case INACTIVE: return "inactive";
091            case ENTEREDINERROR: return "entered-in-error";
092            case NULL: return null;
093            default: return "?";
094          }
095        }
096        public String getSystem() {
097          switch (this) {
098            case ACTIVE: return "http://hl7.org/fhir/device-status";
099            case INACTIVE: return "http://hl7.org/fhir/device-status";
100            case ENTEREDINERROR: return "http://hl7.org/fhir/device-status";
101            case NULL: return null;
102            default: return "?";
103          }
104        }
105        public String getDefinition() {
106          switch (this) {
107            case ACTIVE: return "The device record is current and is appropriate for reference in new instances.";
108            case INACTIVE: return "The device record is not current and is not appropriate for reference in new instances.";
109            case ENTEREDINERROR: return "The device record is not current and is not appropriate for reference in new instances.";
110            case NULL: return null;
111            default: return "?";
112          }
113        }
114        public String getDisplay() {
115          switch (this) {
116            case ACTIVE: return "Active";
117            case INACTIVE: return "Inactive";
118            case ENTEREDINERROR: return "Entered in Error";
119            case NULL: return null;
120            default: return "?";
121          }
122        }
123    }
124
125  public static class FHIRDeviceStatusEnumFactory implements EnumFactory<FHIRDeviceStatus> {
126    public FHIRDeviceStatus fromCode(String codeString) throws IllegalArgumentException {
127      if (codeString == null || "".equals(codeString))
128            if (codeString == null || "".equals(codeString))
129                return null;
130        if ("active".equals(codeString))
131          return FHIRDeviceStatus.ACTIVE;
132        if ("inactive".equals(codeString))
133          return FHIRDeviceStatus.INACTIVE;
134        if ("entered-in-error".equals(codeString))
135          return FHIRDeviceStatus.ENTEREDINERROR;
136        throw new IllegalArgumentException("Unknown FHIRDeviceStatus code '"+codeString+"'");
137        }
138        public Enumeration<FHIRDeviceStatus> fromType(PrimitiveType<?> code) throws FHIRException {
139          if (code == null)
140            return null;
141          if (code.isEmpty())
142            return new Enumeration<FHIRDeviceStatus>(this, FHIRDeviceStatus.NULL, code);
143          String codeString = ((PrimitiveType) code).asStringValue();
144          if (codeString == null || "".equals(codeString))
145            return new Enumeration<FHIRDeviceStatus>(this, FHIRDeviceStatus.NULL, code);
146        if ("active".equals(codeString))
147          return new Enumeration<FHIRDeviceStatus>(this, FHIRDeviceStatus.ACTIVE, code);
148        if ("inactive".equals(codeString))
149          return new Enumeration<FHIRDeviceStatus>(this, FHIRDeviceStatus.INACTIVE, code);
150        if ("entered-in-error".equals(codeString))
151          return new Enumeration<FHIRDeviceStatus>(this, FHIRDeviceStatus.ENTEREDINERROR, code);
152        throw new FHIRException("Unknown FHIRDeviceStatus code '"+codeString+"'");
153        }
154    public String toCode(FHIRDeviceStatus code) {
155      if (code == FHIRDeviceStatus.ACTIVE)
156        return "active";
157      if (code == FHIRDeviceStatus.INACTIVE)
158        return "inactive";
159      if (code == FHIRDeviceStatus.ENTEREDINERROR)
160        return "entered-in-error";
161      return "?";
162      }
163    public String toSystem(FHIRDeviceStatus code) {
164      return code.getSystem();
165      }
166    }
167
168    public enum UDIEntryType {
169        /**
170         * a barcodescanner captured the data from the device label.
171         */
172        BARCODE, 
173        /**
174         * An RFID chip reader captured the data from the device label.
175         */
176        RFID, 
177        /**
178         * The data was read from the label by a person and manually entered. (e.g.  via a keyboard).
179         */
180        MANUAL, 
181        /**
182         * The data originated from a patient's implant card and was read by an operator.
183         */
184        CARD, 
185        /**
186         * The data originated from a patient source and was not directly scanned or read from a label or card.
187         */
188        SELFREPORTED, 
189        /**
190         * The UDI information was received electronically from the device through a communication protocol, such as the IEEE 11073 20601 version 4 exchange protocol over Bluetooth or USB.
191         */
192        ELECTRONICTRANSMISSION, 
193        /**
194         * The method of data capture has not been determined.
195         */
196        UNKNOWN, 
197        /**
198         * added to help the parsers with the generic types
199         */
200        NULL;
201        public static UDIEntryType fromCode(String codeString) throws FHIRException {
202            if (codeString == null || "".equals(codeString))
203                return null;
204        if ("barcode".equals(codeString))
205          return BARCODE;
206        if ("rfid".equals(codeString))
207          return RFID;
208        if ("manual".equals(codeString))
209          return MANUAL;
210        if ("card".equals(codeString))
211          return CARD;
212        if ("self-reported".equals(codeString))
213          return SELFREPORTED;
214        if ("electronic-transmission".equals(codeString))
215          return ELECTRONICTRANSMISSION;
216        if ("unknown".equals(codeString))
217          return UNKNOWN;
218        if (Configuration.isAcceptInvalidEnums())
219          return null;
220        else
221          throw new FHIRException("Unknown UDIEntryType code '"+codeString+"'");
222        }
223        public String toCode() {
224          switch (this) {
225            case BARCODE: return "barcode";
226            case RFID: return "rfid";
227            case MANUAL: return "manual";
228            case CARD: return "card";
229            case SELFREPORTED: return "self-reported";
230            case ELECTRONICTRANSMISSION: return "electronic-transmission";
231            case UNKNOWN: return "unknown";
232            case NULL: return null;
233            default: return "?";
234          }
235        }
236        public String getSystem() {
237          switch (this) {
238            case BARCODE: return "http://hl7.org/fhir/udi-entry-type";
239            case RFID: return "http://hl7.org/fhir/udi-entry-type";
240            case MANUAL: return "http://hl7.org/fhir/udi-entry-type";
241            case CARD: return "http://hl7.org/fhir/udi-entry-type";
242            case SELFREPORTED: return "http://hl7.org/fhir/udi-entry-type";
243            case ELECTRONICTRANSMISSION: return "http://hl7.org/fhir/udi-entry-type";
244            case UNKNOWN: return "http://hl7.org/fhir/udi-entry-type";
245            case NULL: return null;
246            default: return "?";
247          }
248        }
249        public String getDefinition() {
250          switch (this) {
251            case BARCODE: return "a barcodescanner captured the data from the device label.";
252            case RFID: return "An RFID chip reader captured the data from the device label.";
253            case MANUAL: return "The data was read from the label by a person and manually entered. (e.g.  via a keyboard).";
254            case CARD: return "The data originated from a patient's implant card and was read by an operator.";
255            case SELFREPORTED: return "The data originated from a patient source and was not directly scanned or read from a label or card.";
256            case ELECTRONICTRANSMISSION: return "The UDI information was received electronically from the device through a communication protocol, such as the IEEE 11073 20601 version 4 exchange protocol over Bluetooth or USB.";
257            case UNKNOWN: return "The method of data capture has not been determined.";
258            case NULL: return null;
259            default: return "?";
260          }
261        }
262        public String getDisplay() {
263          switch (this) {
264            case BARCODE: return "Barcode";
265            case RFID: return "RFID";
266            case MANUAL: return "Manual";
267            case CARD: return "Card";
268            case SELFREPORTED: return "Self Reported";
269            case ELECTRONICTRANSMISSION: return "Electronic Transmission";
270            case UNKNOWN: return "Unknown";
271            case NULL: return null;
272            default: return "?";
273          }
274        }
275    }
276
277  public static class UDIEntryTypeEnumFactory implements EnumFactory<UDIEntryType> {
278    public UDIEntryType fromCode(String codeString) throws IllegalArgumentException {
279      if (codeString == null || "".equals(codeString))
280            if (codeString == null || "".equals(codeString))
281                return null;
282        if ("barcode".equals(codeString))
283          return UDIEntryType.BARCODE;
284        if ("rfid".equals(codeString))
285          return UDIEntryType.RFID;
286        if ("manual".equals(codeString))
287          return UDIEntryType.MANUAL;
288        if ("card".equals(codeString))
289          return UDIEntryType.CARD;
290        if ("self-reported".equals(codeString))
291          return UDIEntryType.SELFREPORTED;
292        if ("electronic-transmission".equals(codeString))
293          return UDIEntryType.ELECTRONICTRANSMISSION;
294        if ("unknown".equals(codeString))
295          return UDIEntryType.UNKNOWN;
296        throw new IllegalArgumentException("Unknown UDIEntryType code '"+codeString+"'");
297        }
298        public Enumeration<UDIEntryType> fromType(PrimitiveType<?> code) throws FHIRException {
299          if (code == null)
300            return null;
301          if (code.isEmpty())
302            return new Enumeration<UDIEntryType>(this, UDIEntryType.NULL, code);
303          String codeString = ((PrimitiveType) code).asStringValue();
304          if (codeString == null || "".equals(codeString))
305            return new Enumeration<UDIEntryType>(this, UDIEntryType.NULL, code);
306        if ("barcode".equals(codeString))
307          return new Enumeration<UDIEntryType>(this, UDIEntryType.BARCODE, code);
308        if ("rfid".equals(codeString))
309          return new Enumeration<UDIEntryType>(this, UDIEntryType.RFID, code);
310        if ("manual".equals(codeString))
311          return new Enumeration<UDIEntryType>(this, UDIEntryType.MANUAL, code);
312        if ("card".equals(codeString))
313          return new Enumeration<UDIEntryType>(this, UDIEntryType.CARD, code);
314        if ("self-reported".equals(codeString))
315          return new Enumeration<UDIEntryType>(this, UDIEntryType.SELFREPORTED, code);
316        if ("electronic-transmission".equals(codeString))
317          return new Enumeration<UDIEntryType>(this, UDIEntryType.ELECTRONICTRANSMISSION, code);
318        if ("unknown".equals(codeString))
319          return new Enumeration<UDIEntryType>(this, UDIEntryType.UNKNOWN, code);
320        throw new FHIRException("Unknown UDIEntryType code '"+codeString+"'");
321        }
322    public String toCode(UDIEntryType code) {
323      if (code == UDIEntryType.BARCODE)
324        return "barcode";
325      if (code == UDIEntryType.RFID)
326        return "rfid";
327      if (code == UDIEntryType.MANUAL)
328        return "manual";
329      if (code == UDIEntryType.CARD)
330        return "card";
331      if (code == UDIEntryType.SELFREPORTED)
332        return "self-reported";
333      if (code == UDIEntryType.ELECTRONICTRANSMISSION)
334        return "electronic-transmission";
335      if (code == UDIEntryType.UNKNOWN)
336        return "unknown";
337      return "?";
338      }
339    public String toSystem(UDIEntryType code) {
340      return code.getSystem();
341      }
342    }
343
344    @Block()
345    public static class DeviceUdiCarrierComponent extends BackboneElement implements IBaseBackboneElement {
346        /**
347         * The device identifier (DI) is a mandatory, fixed portion of a UDI that identifies the labeler and the specific version or model of a device.
348         */
349        @Child(name = "deviceIdentifier", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=true)
350        @Description(shortDefinition="Mandatory fixed portion of UDI", formalDefinition="The device identifier (DI) is a mandatory, fixed portion of a UDI that identifies the labeler and the specific version or model of a device." )
351        protected StringType deviceIdentifier;
352
353        /**
354         * Organization that is charged with issuing UDIs for devices. For example, the US FDA issuers include: 
3551) GS1: http://hl7.org/fhir/NamingSystem/gs1-di, 
3562) HIBCC: http://hl7.org/fhir/NamingSystem/hibcc-diI, 
3573) ICCBBA for blood containers: http://hl7.org/fhir/NamingSystem/iccbba-blood-di, 
3584) ICCBA for other devices: http://hl7.org/fhir/NamingSystem/iccbba-other-di # Informationsstelle für Arzneispezialitäten (IFA GmbH) (EU only): http://hl7.org/fhir/NamingSystem/ifa-gmbh-di.
359         */
360        @Child(name = "issuer", type = {UriType.class}, order=2, min=1, max=1, modifier=false, summary=true)
361        @Description(shortDefinition="UDI Issuing Organization", formalDefinition="Organization that is charged with issuing UDIs for devices. For example, the US FDA issuers include: \n1) GS1: http://hl7.org/fhir/NamingSystem/gs1-di, \n2) HIBCC: http://hl7.org/fhir/NamingSystem/hibcc-diI, \n3) ICCBBA for blood containers: http://hl7.org/fhir/NamingSystem/iccbba-blood-di, \n4) ICCBA for other devices: http://hl7.org/fhir/NamingSystem/iccbba-other-di # Informationsstelle für Arzneispezialitäten (IFA GmbH) (EU only): http://hl7.org/fhir/NamingSystem/ifa-gmbh-di." )
362        protected UriType issuer;
363
364        /**
365         * The identity of the authoritative source for UDI generation within a jurisdiction. All UDIs are globally unique within a single namespace with the appropriate repository uri as the system. For example, UDIs of devices managed in the U.S. by the FDA, the value is http://hl7.org/fhir/NamingSystem/us-fda-udi or in the European Union by the European Commission http://hl7.org/fhir/NamingSystem/eu-ec-udi.
366         */
367        @Child(name = "jurisdiction", type = {UriType.class}, order=3, min=0, max=1, modifier=false, summary=false)
368        @Description(shortDefinition="Regional UDI authority", formalDefinition="The identity of the authoritative source for UDI generation within a jurisdiction. All UDIs are globally unique within a single namespace with the appropriate repository uri as the system. For example, UDIs of devices managed in the U.S. by the FDA, the value is http://hl7.org/fhir/NamingSystem/us-fda-udi or in the European Union by the European Commission http://hl7.org/fhir/NamingSystem/eu-ec-udi." )
369        protected UriType jurisdiction;
370
371        /**
372         * The full UDI carrier of the Automatic Identification and Data Capture (AIDC) technology representation of the barcode string as printed on the packaging of the device - e.g., a barcode or RFID.   Because of limitations on character sets in XML and the need to round-trip JSON data through XML, AIDC Formats *SHALL* be base64 encoded.
373         */
374        @Child(name = "carrierAIDC", type = {Base64BinaryType.class}, order=4, min=0, max=1, modifier=false, summary=true)
375        @Description(shortDefinition="UDI Machine Readable Barcode String", formalDefinition="The full UDI carrier of the Automatic Identification and Data Capture (AIDC) technology representation of the barcode string as printed on the packaging of the device - e.g., a barcode or RFID.   Because of limitations on character sets in XML and the need to round-trip JSON data through XML, AIDC Formats *SHALL* be base64 encoded." )
376        protected Base64BinaryType carrierAIDC;
377
378        /**
379         * The full UDI carrier as the human readable form (HRF) representation of the barcode string as printed on the packaging of the device.
380         */
381        @Child(name = "carrierHRF", type = {StringType.class}, order=5, min=0, max=1, modifier=false, summary=true)
382        @Description(shortDefinition="UDI Human Readable Barcode String", formalDefinition="The full UDI carrier as the human readable form (HRF) representation of the barcode string as printed on the packaging of the device." )
383        protected StringType carrierHRF;
384
385        /**
386         * A coded entry to indicate how the data was entered.
387         */
388        @Child(name = "entryType", type = {CodeType.class}, order=6, min=0, max=1, modifier=false, summary=false)
389        @Description(shortDefinition="barcode | rfid | manual | card | self-reported | electronic-transmission | unknown", formalDefinition="A coded entry to indicate how the data was entered." )
390        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/udi-entry-type")
391        protected Enumeration<UDIEntryType> entryType;
392
393        private static final long serialVersionUID = -191630425L;
394
395    /**
396     * Constructor
397     */
398      public DeviceUdiCarrierComponent() {
399        super();
400      }
401
402    /**
403     * Constructor
404     */
405      public DeviceUdiCarrierComponent(String deviceIdentifier, String issuer) {
406        super();
407        this.setDeviceIdentifier(deviceIdentifier);
408        this.setIssuer(issuer);
409      }
410
411        /**
412         * @return {@link #deviceIdentifier} (The device identifier (DI) is a mandatory, fixed portion of a UDI that identifies the labeler and the specific version or model of a device.). This is the underlying object with id, value and extensions. The accessor "getDeviceIdentifier" gives direct access to the value
413         */
414        public StringType getDeviceIdentifierElement() { 
415          if (this.deviceIdentifier == null)
416            if (Configuration.errorOnAutoCreate())
417              throw new Error("Attempt to auto-create DeviceUdiCarrierComponent.deviceIdentifier");
418            else if (Configuration.doAutoCreate())
419              this.deviceIdentifier = new StringType(); // bb
420          return this.deviceIdentifier;
421        }
422
423        public boolean hasDeviceIdentifierElement() { 
424          return this.deviceIdentifier != null && !this.deviceIdentifier.isEmpty();
425        }
426
427        public boolean hasDeviceIdentifier() { 
428          return this.deviceIdentifier != null && !this.deviceIdentifier.isEmpty();
429        }
430
431        /**
432         * @param value {@link #deviceIdentifier} (The device identifier (DI) is a mandatory, fixed portion of a UDI that identifies the labeler and the specific version or model of a device.). This is the underlying object with id, value and extensions. The accessor "getDeviceIdentifier" gives direct access to the value
433         */
434        public DeviceUdiCarrierComponent setDeviceIdentifierElement(StringType value) { 
435          this.deviceIdentifier = value;
436          return this;
437        }
438
439        /**
440         * @return The device identifier (DI) is a mandatory, fixed portion of a UDI that identifies the labeler and the specific version or model of a device.
441         */
442        public String getDeviceIdentifier() { 
443          return this.deviceIdentifier == null ? null : this.deviceIdentifier.getValue();
444        }
445
446        /**
447         * @param value The device identifier (DI) is a mandatory, fixed portion of a UDI that identifies the labeler and the specific version or model of a device.
448         */
449        public DeviceUdiCarrierComponent setDeviceIdentifier(String value) { 
450            if (this.deviceIdentifier == null)
451              this.deviceIdentifier = new StringType();
452            this.deviceIdentifier.setValue(value);
453          return this;
454        }
455
456        /**
457         * @return {@link #issuer} (Organization that is charged with issuing UDIs for devices. For example, the US FDA issuers include: 
4581) GS1: http://hl7.org/fhir/NamingSystem/gs1-di, 
4592) HIBCC: http://hl7.org/fhir/NamingSystem/hibcc-diI, 
4603) ICCBBA for blood containers: http://hl7.org/fhir/NamingSystem/iccbba-blood-di, 
4614) ICCBA for other devices: http://hl7.org/fhir/NamingSystem/iccbba-other-di # Informationsstelle für Arzneispezialitäten (IFA GmbH) (EU only): http://hl7.org/fhir/NamingSystem/ifa-gmbh-di.). This is the underlying object with id, value and extensions. The accessor "getIssuer" gives direct access to the value
462         */
463        public UriType getIssuerElement() { 
464          if (this.issuer == null)
465            if (Configuration.errorOnAutoCreate())
466              throw new Error("Attempt to auto-create DeviceUdiCarrierComponent.issuer");
467            else if (Configuration.doAutoCreate())
468              this.issuer = new UriType(); // bb
469          return this.issuer;
470        }
471
472        public boolean hasIssuerElement() { 
473          return this.issuer != null && !this.issuer.isEmpty();
474        }
475
476        public boolean hasIssuer() { 
477          return this.issuer != null && !this.issuer.isEmpty();
478        }
479
480        /**
481         * @param value {@link #issuer} (Organization that is charged with issuing UDIs for devices. For example, the US FDA issuers include: 
4821) GS1: http://hl7.org/fhir/NamingSystem/gs1-di, 
4832) HIBCC: http://hl7.org/fhir/NamingSystem/hibcc-diI, 
4843) ICCBBA for blood containers: http://hl7.org/fhir/NamingSystem/iccbba-blood-di, 
4854) ICCBA for other devices: http://hl7.org/fhir/NamingSystem/iccbba-other-di # Informationsstelle für Arzneispezialitäten (IFA GmbH) (EU only): http://hl7.org/fhir/NamingSystem/ifa-gmbh-di.). This is the underlying object with id, value and extensions. The accessor "getIssuer" gives direct access to the value
486         */
487        public DeviceUdiCarrierComponent setIssuerElement(UriType value) { 
488          this.issuer = value;
489          return this;
490        }
491
492        /**
493         * @return Organization that is charged with issuing UDIs for devices. For example, the US FDA issuers include: 
4941) GS1: http://hl7.org/fhir/NamingSystem/gs1-di, 
4952) HIBCC: http://hl7.org/fhir/NamingSystem/hibcc-diI, 
4963) ICCBBA for blood containers: http://hl7.org/fhir/NamingSystem/iccbba-blood-di, 
4974) ICCBA for other devices: http://hl7.org/fhir/NamingSystem/iccbba-other-di # Informationsstelle für Arzneispezialitäten (IFA GmbH) (EU only): http://hl7.org/fhir/NamingSystem/ifa-gmbh-di.
498         */
499        public String getIssuer() { 
500          return this.issuer == null ? null : this.issuer.getValue();
501        }
502
503        /**
504         * @param value Organization that is charged with issuing UDIs for devices. For example, the US FDA issuers include: 
5051) GS1: http://hl7.org/fhir/NamingSystem/gs1-di, 
5062) HIBCC: http://hl7.org/fhir/NamingSystem/hibcc-diI, 
5073) ICCBBA for blood containers: http://hl7.org/fhir/NamingSystem/iccbba-blood-di, 
5084) ICCBA for other devices: http://hl7.org/fhir/NamingSystem/iccbba-other-di # Informationsstelle für Arzneispezialitäten (IFA GmbH) (EU only): http://hl7.org/fhir/NamingSystem/ifa-gmbh-di.
509         */
510        public DeviceUdiCarrierComponent setIssuer(String value) { 
511            if (this.issuer == null)
512              this.issuer = new UriType();
513            this.issuer.setValue(value);
514          return this;
515        }
516
517        /**
518         * @return {@link #jurisdiction} (The identity of the authoritative source for UDI generation within a jurisdiction. All UDIs are globally unique within a single namespace with the appropriate repository uri as the system. For example, UDIs of devices managed in the U.S. by the FDA, the value is http://hl7.org/fhir/NamingSystem/us-fda-udi or in the European Union by the European Commission http://hl7.org/fhir/NamingSystem/eu-ec-udi.). This is the underlying object with id, value and extensions. The accessor "getJurisdiction" gives direct access to the value
519         */
520        public UriType getJurisdictionElement() { 
521          if (this.jurisdiction == null)
522            if (Configuration.errorOnAutoCreate())
523              throw new Error("Attempt to auto-create DeviceUdiCarrierComponent.jurisdiction");
524            else if (Configuration.doAutoCreate())
525              this.jurisdiction = new UriType(); // bb
526          return this.jurisdiction;
527        }
528
529        public boolean hasJurisdictionElement() { 
530          return this.jurisdiction != null && !this.jurisdiction.isEmpty();
531        }
532
533        public boolean hasJurisdiction() { 
534          return this.jurisdiction != null && !this.jurisdiction.isEmpty();
535        }
536
537        /**
538         * @param value {@link #jurisdiction} (The identity of the authoritative source for UDI generation within a jurisdiction. All UDIs are globally unique within a single namespace with the appropriate repository uri as the system. For example, UDIs of devices managed in the U.S. by the FDA, the value is http://hl7.org/fhir/NamingSystem/us-fda-udi or in the European Union by the European Commission http://hl7.org/fhir/NamingSystem/eu-ec-udi.). This is the underlying object with id, value and extensions. The accessor "getJurisdiction" gives direct access to the value
539         */
540        public DeviceUdiCarrierComponent setJurisdictionElement(UriType value) { 
541          this.jurisdiction = value;
542          return this;
543        }
544
545        /**
546         * @return The identity of the authoritative source for UDI generation within a jurisdiction. All UDIs are globally unique within a single namespace with the appropriate repository uri as the system. For example, UDIs of devices managed in the U.S. by the FDA, the value is http://hl7.org/fhir/NamingSystem/us-fda-udi or in the European Union by the European Commission http://hl7.org/fhir/NamingSystem/eu-ec-udi.
547         */
548        public String getJurisdiction() { 
549          return this.jurisdiction == null ? null : this.jurisdiction.getValue();
550        }
551
552        /**
553         * @param value The identity of the authoritative source for UDI generation within a jurisdiction. All UDIs are globally unique within a single namespace with the appropriate repository uri as the system. For example, UDIs of devices managed in the U.S. by the FDA, the value is http://hl7.org/fhir/NamingSystem/us-fda-udi or in the European Union by the European Commission http://hl7.org/fhir/NamingSystem/eu-ec-udi.
554         */
555        public DeviceUdiCarrierComponent setJurisdiction(String value) { 
556          if (Utilities.noString(value))
557            this.jurisdiction = null;
558          else {
559            if (this.jurisdiction == null)
560              this.jurisdiction = new UriType();
561            this.jurisdiction.setValue(value);
562          }
563          return this;
564        }
565
566        /**
567         * @return {@link #carrierAIDC} (The full UDI carrier of the Automatic Identification and Data Capture (AIDC) technology representation of the barcode string as printed on the packaging of the device - e.g., a barcode or RFID.   Because of limitations on character sets in XML and the need to round-trip JSON data through XML, AIDC Formats *SHALL* be base64 encoded.). This is the underlying object with id, value and extensions. The accessor "getCarrierAIDC" gives direct access to the value
568         */
569        public Base64BinaryType getCarrierAIDCElement() { 
570          if (this.carrierAIDC == null)
571            if (Configuration.errorOnAutoCreate())
572              throw new Error("Attempt to auto-create DeviceUdiCarrierComponent.carrierAIDC");
573            else if (Configuration.doAutoCreate())
574              this.carrierAIDC = new Base64BinaryType(); // bb
575          return this.carrierAIDC;
576        }
577
578        public boolean hasCarrierAIDCElement() { 
579          return this.carrierAIDC != null && !this.carrierAIDC.isEmpty();
580        }
581
582        public boolean hasCarrierAIDC() { 
583          return this.carrierAIDC != null && !this.carrierAIDC.isEmpty();
584        }
585
586        /**
587         * @param value {@link #carrierAIDC} (The full UDI carrier of the Automatic Identification and Data Capture (AIDC) technology representation of the barcode string as printed on the packaging of the device - e.g., a barcode or RFID.   Because of limitations on character sets in XML and the need to round-trip JSON data through XML, AIDC Formats *SHALL* be base64 encoded.). This is the underlying object with id, value and extensions. The accessor "getCarrierAIDC" gives direct access to the value
588         */
589        public DeviceUdiCarrierComponent setCarrierAIDCElement(Base64BinaryType value) { 
590          this.carrierAIDC = value;
591          return this;
592        }
593
594        /**
595         * @return The full UDI carrier of the Automatic Identification and Data Capture (AIDC) technology representation of the barcode string as printed on the packaging of the device - e.g., a barcode or RFID.   Because of limitations on character sets in XML and the need to round-trip JSON data through XML, AIDC Formats *SHALL* be base64 encoded.
596         */
597        public byte[] getCarrierAIDC() { 
598          return this.carrierAIDC == null ? null : this.carrierAIDC.getValue();
599        }
600
601        /**
602         * @param value The full UDI carrier of the Automatic Identification and Data Capture (AIDC) technology representation of the barcode string as printed on the packaging of the device - e.g., a barcode or RFID.   Because of limitations on character sets in XML and the need to round-trip JSON data through XML, AIDC Formats *SHALL* be base64 encoded.
603         */
604        public DeviceUdiCarrierComponent setCarrierAIDC(byte[] value) { 
605          if (value == null)
606            this.carrierAIDC = null;
607          else {
608            if (this.carrierAIDC == null)
609              this.carrierAIDC = new Base64BinaryType();
610            this.carrierAIDC.setValue(value);
611          }
612          return this;
613        }
614
615        /**
616         * @return {@link #carrierHRF} (The full UDI carrier as the human readable form (HRF) representation of the barcode string as printed on the packaging of the device.). This is the underlying object with id, value and extensions. The accessor "getCarrierHRF" gives direct access to the value
617         */
618        public StringType getCarrierHRFElement() { 
619          if (this.carrierHRF == null)
620            if (Configuration.errorOnAutoCreate())
621              throw new Error("Attempt to auto-create DeviceUdiCarrierComponent.carrierHRF");
622            else if (Configuration.doAutoCreate())
623              this.carrierHRF = new StringType(); // bb
624          return this.carrierHRF;
625        }
626
627        public boolean hasCarrierHRFElement() { 
628          return this.carrierHRF != null && !this.carrierHRF.isEmpty();
629        }
630
631        public boolean hasCarrierHRF() { 
632          return this.carrierHRF != null && !this.carrierHRF.isEmpty();
633        }
634
635        /**
636         * @param value {@link #carrierHRF} (The full UDI carrier as the human readable form (HRF) representation of the barcode string as printed on the packaging of the device.). This is the underlying object with id, value and extensions. The accessor "getCarrierHRF" gives direct access to the value
637         */
638        public DeviceUdiCarrierComponent setCarrierHRFElement(StringType value) { 
639          this.carrierHRF = value;
640          return this;
641        }
642
643        /**
644         * @return The full UDI carrier as the human readable form (HRF) representation of the barcode string as printed on the packaging of the device.
645         */
646        public String getCarrierHRF() { 
647          return this.carrierHRF == null ? null : this.carrierHRF.getValue();
648        }
649
650        /**
651         * @param value The full UDI carrier as the human readable form (HRF) representation of the barcode string as printed on the packaging of the device.
652         */
653        public DeviceUdiCarrierComponent setCarrierHRF(String value) { 
654          if (Utilities.noString(value))
655            this.carrierHRF = null;
656          else {
657            if (this.carrierHRF == null)
658              this.carrierHRF = new StringType();
659            this.carrierHRF.setValue(value);
660          }
661          return this;
662        }
663
664        /**
665         * @return {@link #entryType} (A coded entry to indicate how the data was entered.). This is the underlying object with id, value and extensions. The accessor "getEntryType" gives direct access to the value
666         */
667        public Enumeration<UDIEntryType> getEntryTypeElement() { 
668          if (this.entryType == null)
669            if (Configuration.errorOnAutoCreate())
670              throw new Error("Attempt to auto-create DeviceUdiCarrierComponent.entryType");
671            else if (Configuration.doAutoCreate())
672              this.entryType = new Enumeration<UDIEntryType>(new UDIEntryTypeEnumFactory()); // bb
673          return this.entryType;
674        }
675
676        public boolean hasEntryTypeElement() { 
677          return this.entryType != null && !this.entryType.isEmpty();
678        }
679
680        public boolean hasEntryType() { 
681          return this.entryType != null && !this.entryType.isEmpty();
682        }
683
684        /**
685         * @param value {@link #entryType} (A coded entry to indicate how the data was entered.). This is the underlying object with id, value and extensions. The accessor "getEntryType" gives direct access to the value
686         */
687        public DeviceUdiCarrierComponent setEntryTypeElement(Enumeration<UDIEntryType> value) { 
688          this.entryType = value;
689          return this;
690        }
691
692        /**
693         * @return A coded entry to indicate how the data was entered.
694         */
695        public UDIEntryType getEntryType() { 
696          return this.entryType == null ? null : this.entryType.getValue();
697        }
698
699        /**
700         * @param value A coded entry to indicate how the data was entered.
701         */
702        public DeviceUdiCarrierComponent setEntryType(UDIEntryType value) { 
703          if (value == null)
704            this.entryType = null;
705          else {
706            if (this.entryType == null)
707              this.entryType = new Enumeration<UDIEntryType>(new UDIEntryTypeEnumFactory());
708            this.entryType.setValue(value);
709          }
710          return this;
711        }
712
713        protected void listChildren(List<Property> children) {
714          super.listChildren(children);
715          children.add(new Property("deviceIdentifier", "string", "The device identifier (DI) is a mandatory, fixed portion of a UDI that identifies the labeler and the specific version or model of a device.", 0, 1, deviceIdentifier));
716          children.add(new Property("issuer", "uri", "Organization that is charged with issuing UDIs for devices. For example, the US FDA issuers include: \n1) GS1: http://hl7.org/fhir/NamingSystem/gs1-di, \n2) HIBCC: http://hl7.org/fhir/NamingSystem/hibcc-diI, \n3) ICCBBA for blood containers: http://hl7.org/fhir/NamingSystem/iccbba-blood-di, \n4) ICCBA for other devices: http://hl7.org/fhir/NamingSystem/iccbba-other-di # Informationsstelle für Arzneispezialitäten (IFA GmbH) (EU only): http://hl7.org/fhir/NamingSystem/ifa-gmbh-di.", 0, 1, issuer));
717          children.add(new Property("jurisdiction", "uri", "The identity of the authoritative source for UDI generation within a jurisdiction. All UDIs are globally unique within a single namespace with the appropriate repository uri as the system. For example, UDIs of devices managed in the U.S. by the FDA, the value is http://hl7.org/fhir/NamingSystem/us-fda-udi or in the European Union by the European Commission http://hl7.org/fhir/NamingSystem/eu-ec-udi.", 0, 1, jurisdiction));
718          children.add(new Property("carrierAIDC", "base64Binary", "The full UDI carrier of the Automatic Identification and Data Capture (AIDC) technology representation of the barcode string as printed on the packaging of the device - e.g., a barcode or RFID.   Because of limitations on character sets in XML and the need to round-trip JSON data through XML, AIDC Formats *SHALL* be base64 encoded.", 0, 1, carrierAIDC));
719          children.add(new Property("carrierHRF", "string", "The full UDI carrier as the human readable form (HRF) representation of the barcode string as printed on the packaging of the device.", 0, 1, carrierHRF));
720          children.add(new Property("entryType", "code", "A coded entry to indicate how the data was entered.", 0, 1, entryType));
721        }
722
723        @Override
724        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
725          switch (_hash) {
726          case 1322005407: /*deviceIdentifier*/  return new Property("deviceIdentifier", "string", "The device identifier (DI) is a mandatory, fixed portion of a UDI that identifies the labeler and the specific version or model of a device.", 0, 1, deviceIdentifier);
727          case -1179159879: /*issuer*/  return new Property("issuer", "uri", "Organization that is charged with issuing UDIs for devices. For example, the US FDA issuers include: \n1) GS1: http://hl7.org/fhir/NamingSystem/gs1-di, \n2) HIBCC: http://hl7.org/fhir/NamingSystem/hibcc-diI, \n3) ICCBBA for blood containers: http://hl7.org/fhir/NamingSystem/iccbba-blood-di, \n4) ICCBA for other devices: http://hl7.org/fhir/NamingSystem/iccbba-other-di # Informationsstelle für Arzneispezialitäten (IFA GmbH) (EU only): http://hl7.org/fhir/NamingSystem/ifa-gmbh-di.", 0, 1, issuer);
728          case -507075711: /*jurisdiction*/  return new Property("jurisdiction", "uri", "The identity of the authoritative source for UDI generation within a jurisdiction. All UDIs are globally unique within a single namespace with the appropriate repository uri as the system. For example, UDIs of devices managed in the U.S. by the FDA, the value is http://hl7.org/fhir/NamingSystem/us-fda-udi or in the European Union by the European Commission http://hl7.org/fhir/NamingSystem/eu-ec-udi.", 0, 1, jurisdiction);
729          case -768521825: /*carrierAIDC*/  return new Property("carrierAIDC", "base64Binary", "The full UDI carrier of the Automatic Identification and Data Capture (AIDC) technology representation of the barcode string as printed on the packaging of the device - e.g., a barcode or RFID.   Because of limitations on character sets in XML and the need to round-trip JSON data through XML, AIDC Formats *SHALL* be base64 encoded.", 0, 1, carrierAIDC);
730          case 806499972: /*carrierHRF*/  return new Property("carrierHRF", "string", "The full UDI carrier as the human readable form (HRF) representation of the barcode string as printed on the packaging of the device.", 0, 1, carrierHRF);
731          case -479362356: /*entryType*/  return new Property("entryType", "code", "A coded entry to indicate how the data was entered.", 0, 1, entryType);
732          default: return super.getNamedProperty(_hash, _name, _checkValid);
733          }
734
735        }
736
737      @Override
738      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
739        switch (hash) {
740        case 1322005407: /*deviceIdentifier*/ return this.deviceIdentifier == null ? new Base[0] : new Base[] {this.deviceIdentifier}; // StringType
741        case -1179159879: /*issuer*/ return this.issuer == null ? new Base[0] : new Base[] {this.issuer}; // UriType
742        case -507075711: /*jurisdiction*/ return this.jurisdiction == null ? new Base[0] : new Base[] {this.jurisdiction}; // UriType
743        case -768521825: /*carrierAIDC*/ return this.carrierAIDC == null ? new Base[0] : new Base[] {this.carrierAIDC}; // Base64BinaryType
744        case 806499972: /*carrierHRF*/ return this.carrierHRF == null ? new Base[0] : new Base[] {this.carrierHRF}; // StringType
745        case -479362356: /*entryType*/ return this.entryType == null ? new Base[0] : new Base[] {this.entryType}; // Enumeration<UDIEntryType>
746        default: return super.getProperty(hash, name, checkValid);
747        }
748
749      }
750
751      @Override
752      public Base setProperty(int hash, String name, Base value) throws FHIRException {
753        switch (hash) {
754        case 1322005407: // deviceIdentifier
755          this.deviceIdentifier = TypeConvertor.castToString(value); // StringType
756          return value;
757        case -1179159879: // issuer
758          this.issuer = TypeConvertor.castToUri(value); // UriType
759          return value;
760        case -507075711: // jurisdiction
761          this.jurisdiction = TypeConvertor.castToUri(value); // UriType
762          return value;
763        case -768521825: // carrierAIDC
764          this.carrierAIDC = TypeConvertor.castToBase64Binary(value); // Base64BinaryType
765          return value;
766        case 806499972: // carrierHRF
767          this.carrierHRF = TypeConvertor.castToString(value); // StringType
768          return value;
769        case -479362356: // entryType
770          value = new UDIEntryTypeEnumFactory().fromType(TypeConvertor.castToCode(value));
771          this.entryType = (Enumeration) value; // Enumeration<UDIEntryType>
772          return value;
773        default: return super.setProperty(hash, name, value);
774        }
775
776      }
777
778      @Override
779      public Base setProperty(String name, Base value) throws FHIRException {
780        if (name.equals("deviceIdentifier")) {
781          this.deviceIdentifier = TypeConvertor.castToString(value); // StringType
782        } else if (name.equals("issuer")) {
783          this.issuer = TypeConvertor.castToUri(value); // UriType
784        } else if (name.equals("jurisdiction")) {
785          this.jurisdiction = TypeConvertor.castToUri(value); // UriType
786        } else if (name.equals("carrierAIDC")) {
787          this.carrierAIDC = TypeConvertor.castToBase64Binary(value); // Base64BinaryType
788        } else if (name.equals("carrierHRF")) {
789          this.carrierHRF = TypeConvertor.castToString(value); // StringType
790        } else if (name.equals("entryType")) {
791          value = new UDIEntryTypeEnumFactory().fromType(TypeConvertor.castToCode(value));
792          this.entryType = (Enumeration) value; // Enumeration<UDIEntryType>
793        } else
794          return super.setProperty(name, value);
795        return value;
796      }
797
798      @Override
799      public Base makeProperty(int hash, String name) throws FHIRException {
800        switch (hash) {
801        case 1322005407:  return getDeviceIdentifierElement();
802        case -1179159879:  return getIssuerElement();
803        case -507075711:  return getJurisdictionElement();
804        case -768521825:  return getCarrierAIDCElement();
805        case 806499972:  return getCarrierHRFElement();
806        case -479362356:  return getEntryTypeElement();
807        default: return super.makeProperty(hash, name);
808        }
809
810      }
811
812      @Override
813      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
814        switch (hash) {
815        case 1322005407: /*deviceIdentifier*/ return new String[] {"string"};
816        case -1179159879: /*issuer*/ return new String[] {"uri"};
817        case -507075711: /*jurisdiction*/ return new String[] {"uri"};
818        case -768521825: /*carrierAIDC*/ return new String[] {"base64Binary"};
819        case 806499972: /*carrierHRF*/ return new String[] {"string"};
820        case -479362356: /*entryType*/ return new String[] {"code"};
821        default: return super.getTypesForProperty(hash, name);
822        }
823
824      }
825
826      @Override
827      public Base addChild(String name) throws FHIRException {
828        if (name.equals("deviceIdentifier")) {
829          throw new FHIRException("Cannot call addChild on a singleton property Device.udiCarrier.deviceIdentifier");
830        }
831        else if (name.equals("issuer")) {
832          throw new FHIRException("Cannot call addChild on a singleton property Device.udiCarrier.issuer");
833        }
834        else if (name.equals("jurisdiction")) {
835          throw new FHIRException("Cannot call addChild on a singleton property Device.udiCarrier.jurisdiction");
836        }
837        else if (name.equals("carrierAIDC")) {
838          throw new FHIRException("Cannot call addChild on a singleton property Device.udiCarrier.carrierAIDC");
839        }
840        else if (name.equals("carrierHRF")) {
841          throw new FHIRException("Cannot call addChild on a singleton property Device.udiCarrier.carrierHRF");
842        }
843        else if (name.equals("entryType")) {
844          throw new FHIRException("Cannot call addChild on a singleton property Device.udiCarrier.entryType");
845        }
846        else
847          return super.addChild(name);
848      }
849
850      public DeviceUdiCarrierComponent copy() {
851        DeviceUdiCarrierComponent dst = new DeviceUdiCarrierComponent();
852        copyValues(dst);
853        return dst;
854      }
855
856      public void copyValues(DeviceUdiCarrierComponent dst) {
857        super.copyValues(dst);
858        dst.deviceIdentifier = deviceIdentifier == null ? null : deviceIdentifier.copy();
859        dst.issuer = issuer == null ? null : issuer.copy();
860        dst.jurisdiction = jurisdiction == null ? null : jurisdiction.copy();
861        dst.carrierAIDC = carrierAIDC == null ? null : carrierAIDC.copy();
862        dst.carrierHRF = carrierHRF == null ? null : carrierHRF.copy();
863        dst.entryType = entryType == null ? null : entryType.copy();
864      }
865
866      @Override
867      public boolean equalsDeep(Base other_) {
868        if (!super.equalsDeep(other_))
869          return false;
870        if (!(other_ instanceof DeviceUdiCarrierComponent))
871          return false;
872        DeviceUdiCarrierComponent o = (DeviceUdiCarrierComponent) other_;
873        return compareDeep(deviceIdentifier, o.deviceIdentifier, true) && compareDeep(issuer, o.issuer, true)
874           && compareDeep(jurisdiction, o.jurisdiction, true) && compareDeep(carrierAIDC, o.carrierAIDC, true)
875           && compareDeep(carrierHRF, o.carrierHRF, true) && compareDeep(entryType, o.entryType, true);
876      }
877
878      @Override
879      public boolean equalsShallow(Base other_) {
880        if (!super.equalsShallow(other_))
881          return false;
882        if (!(other_ instanceof DeviceUdiCarrierComponent))
883          return false;
884        DeviceUdiCarrierComponent o = (DeviceUdiCarrierComponent) other_;
885        return compareValues(deviceIdentifier, o.deviceIdentifier, true) && compareValues(issuer, o.issuer, true)
886           && compareValues(jurisdiction, o.jurisdiction, true) && compareValues(carrierAIDC, o.carrierAIDC, true)
887           && compareValues(carrierHRF, o.carrierHRF, true) && compareValues(entryType, o.entryType, true);
888      }
889
890      public boolean isEmpty() {
891        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(deviceIdentifier, issuer, jurisdiction
892          , carrierAIDC, carrierHRF, entryType);
893      }
894
895  public String fhirType() {
896    return "Device.udiCarrier";
897
898  }
899
900  }
901
902    @Block()
903    public static class DeviceNameComponent extends BackboneElement implements IBaseBackboneElement {
904        /**
905         * The actual name that identifies the device.
906         */
907        @Child(name = "value", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=true)
908        @Description(shortDefinition="The term that names the device", formalDefinition="The actual name that identifies the device." )
909        protected StringType value;
910
911        /**
912         * Indicates the kind of name. RegisteredName | UserFriendlyName | PatientReportedName.
913         */
914        @Child(name = "type", type = {CodeType.class}, order=2, min=1, max=1, modifier=false, summary=true)
915        @Description(shortDefinition="registered-name | user-friendly-name | patient-reported-name", formalDefinition="Indicates the kind of name. RegisteredName | UserFriendlyName | PatientReportedName." )
916        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/device-nametype")
917        protected Enumeration<DeviceNameType> type;
918
919        /**
920         * Indicates the default or preferred name to be displayed.
921         */
922        @Child(name = "display", type = {BooleanType.class}, order=3, min=0, max=1, modifier=true, summary=true)
923        @Description(shortDefinition="The preferred device name", formalDefinition="Indicates the default or preferred name to be displayed." )
924        protected BooleanType display;
925
926        private static final long serialVersionUID = 1911928470L;
927
928    /**
929     * Constructor
930     */
931      public DeviceNameComponent() {
932        super();
933      }
934
935    /**
936     * Constructor
937     */
938      public DeviceNameComponent(String value, DeviceNameType type) {
939        super();
940        this.setValue(value);
941        this.setType(type);
942      }
943
944        /**
945         * @return {@link #value} (The actual name that identifies the device.). This is the underlying object with id, value and extensions. The accessor "getValue" gives direct access to the value
946         */
947        public StringType getValueElement() { 
948          if (this.value == null)
949            if (Configuration.errorOnAutoCreate())
950              throw new Error("Attempt to auto-create DeviceNameComponent.value");
951            else if (Configuration.doAutoCreate())
952              this.value = new StringType(); // bb
953          return this.value;
954        }
955
956        public boolean hasValueElement() { 
957          return this.value != null && !this.value.isEmpty();
958        }
959
960        public boolean hasValue() { 
961          return this.value != null && !this.value.isEmpty();
962        }
963
964        /**
965         * @param value {@link #value} (The actual name that identifies the device.). This is the underlying object with id, value and extensions. The accessor "getValue" gives direct access to the value
966         */
967        public DeviceNameComponent setValueElement(StringType value) { 
968          this.value = value;
969          return this;
970        }
971
972        /**
973         * @return The actual name that identifies the device.
974         */
975        public String getValue() { 
976          return this.value == null ? null : this.value.getValue();
977        }
978
979        /**
980         * @param value The actual name that identifies the device.
981         */
982        public DeviceNameComponent setValue(String value) { 
983            if (this.value == null)
984              this.value = new StringType();
985            this.value.setValue(value);
986          return this;
987        }
988
989        /**
990         * @return {@link #type} (Indicates the kind of name. RegisteredName | UserFriendlyName | PatientReportedName.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
991         */
992        public Enumeration<DeviceNameType> getTypeElement() { 
993          if (this.type == null)
994            if (Configuration.errorOnAutoCreate())
995              throw new Error("Attempt to auto-create DeviceNameComponent.type");
996            else if (Configuration.doAutoCreate())
997              this.type = new Enumeration<DeviceNameType>(new DeviceNameTypeEnumFactory()); // bb
998          return this.type;
999        }
1000
1001        public boolean hasTypeElement() { 
1002          return this.type != null && !this.type.isEmpty();
1003        }
1004
1005        public boolean hasType() { 
1006          return this.type != null && !this.type.isEmpty();
1007        }
1008
1009        /**
1010         * @param value {@link #type} (Indicates the kind of name. RegisteredName | UserFriendlyName | PatientReportedName.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
1011         */
1012        public DeviceNameComponent setTypeElement(Enumeration<DeviceNameType> value) { 
1013          this.type = value;
1014          return this;
1015        }
1016
1017        /**
1018         * @return Indicates the kind of name. RegisteredName | UserFriendlyName | PatientReportedName.
1019         */
1020        public DeviceNameType getType() { 
1021          return this.type == null ? null : this.type.getValue();
1022        }
1023
1024        /**
1025         * @param value Indicates the kind of name. RegisteredName | UserFriendlyName | PatientReportedName.
1026         */
1027        public DeviceNameComponent setType(DeviceNameType value) { 
1028            if (this.type == null)
1029              this.type = new Enumeration<DeviceNameType>(new DeviceNameTypeEnumFactory());
1030            this.type.setValue(value);
1031          return this;
1032        }
1033
1034        /**
1035         * @return {@link #display} (Indicates the default or preferred name to be displayed.). This is the underlying object with id, value and extensions. The accessor "getDisplay" gives direct access to the value
1036         */
1037        public BooleanType getDisplayElement() { 
1038          if (this.display == null)
1039            if (Configuration.errorOnAutoCreate())
1040              throw new Error("Attempt to auto-create DeviceNameComponent.display");
1041            else if (Configuration.doAutoCreate())
1042              this.display = new BooleanType(); // bb
1043          return this.display;
1044        }
1045
1046        public boolean hasDisplayElement() { 
1047          return this.display != null && !this.display.isEmpty();
1048        }
1049
1050        public boolean hasDisplay() { 
1051          return this.display != null && !this.display.isEmpty();
1052        }
1053
1054        /**
1055         * @param value {@link #display} (Indicates the default or preferred name to be displayed.). This is the underlying object with id, value and extensions. The accessor "getDisplay" gives direct access to the value
1056         */
1057        public DeviceNameComponent setDisplayElement(BooleanType value) { 
1058          this.display = value;
1059          return this;
1060        }
1061
1062        /**
1063         * @return Indicates the default or preferred name to be displayed.
1064         */
1065        public boolean getDisplay() { 
1066          return this.display == null || this.display.isEmpty() ? false : this.display.getValue();
1067        }
1068
1069        /**
1070         * @param value Indicates the default or preferred name to be displayed.
1071         */
1072        public DeviceNameComponent setDisplay(boolean value) { 
1073            if (this.display == null)
1074              this.display = new BooleanType();
1075            this.display.setValue(value);
1076          return this;
1077        }
1078
1079        protected void listChildren(List<Property> children) {
1080          super.listChildren(children);
1081          children.add(new Property("value", "string", "The actual name that identifies the device.", 0, 1, value));
1082          children.add(new Property("type", "code", "Indicates the kind of name. RegisteredName | UserFriendlyName | PatientReportedName.", 0, 1, type));
1083          children.add(new Property("display", "boolean", "Indicates the default or preferred name to be displayed.", 0, 1, display));
1084        }
1085
1086        @Override
1087        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1088          switch (_hash) {
1089          case 111972721: /*value*/  return new Property("value", "string", "The actual name that identifies the device.", 0, 1, value);
1090          case 3575610: /*type*/  return new Property("type", "code", "Indicates the kind of name. RegisteredName | UserFriendlyName | PatientReportedName.", 0, 1, type);
1091          case 1671764162: /*display*/  return new Property("display", "boolean", "Indicates the default or preferred name to be displayed.", 0, 1, display);
1092          default: return super.getNamedProperty(_hash, _name, _checkValid);
1093          }
1094
1095        }
1096
1097      @Override
1098      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1099        switch (hash) {
1100        case 111972721: /*value*/ return this.value == null ? new Base[0] : new Base[] {this.value}; // StringType
1101        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<DeviceNameType>
1102        case 1671764162: /*display*/ return this.display == null ? new Base[0] : new Base[] {this.display}; // BooleanType
1103        default: return super.getProperty(hash, name, checkValid);
1104        }
1105
1106      }
1107
1108      @Override
1109      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1110        switch (hash) {
1111        case 111972721: // value
1112          this.value = TypeConvertor.castToString(value); // StringType
1113          return value;
1114        case 3575610: // type
1115          value = new DeviceNameTypeEnumFactory().fromType(TypeConvertor.castToCode(value));
1116          this.type = (Enumeration) value; // Enumeration<DeviceNameType>
1117          return value;
1118        case 1671764162: // display
1119          this.display = TypeConvertor.castToBoolean(value); // BooleanType
1120          return value;
1121        default: return super.setProperty(hash, name, value);
1122        }
1123
1124      }
1125
1126      @Override
1127      public Base setProperty(String name, Base value) throws FHIRException {
1128        if (name.equals("value")) {
1129          this.value = TypeConvertor.castToString(value); // StringType
1130        } else if (name.equals("type")) {
1131          value = new DeviceNameTypeEnumFactory().fromType(TypeConvertor.castToCode(value));
1132          this.type = (Enumeration) value; // Enumeration<DeviceNameType>
1133        } else if (name.equals("display")) {
1134          this.display = TypeConvertor.castToBoolean(value); // BooleanType
1135        } else
1136          return super.setProperty(name, value);
1137        return value;
1138      }
1139
1140      @Override
1141      public Base makeProperty(int hash, String name) throws FHIRException {
1142        switch (hash) {
1143        case 111972721:  return getValueElement();
1144        case 3575610:  return getTypeElement();
1145        case 1671764162:  return getDisplayElement();
1146        default: return super.makeProperty(hash, name);
1147        }
1148
1149      }
1150
1151      @Override
1152      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1153        switch (hash) {
1154        case 111972721: /*value*/ return new String[] {"string"};
1155        case 3575610: /*type*/ return new String[] {"code"};
1156        case 1671764162: /*display*/ return new String[] {"boolean"};
1157        default: return super.getTypesForProperty(hash, name);
1158        }
1159
1160      }
1161
1162      @Override
1163      public Base addChild(String name) throws FHIRException {
1164        if (name.equals("value")) {
1165          throw new FHIRException("Cannot call addChild on a singleton property Device.name.value");
1166        }
1167        else if (name.equals("type")) {
1168          throw new FHIRException("Cannot call addChild on a singleton property Device.name.type");
1169        }
1170        else if (name.equals("display")) {
1171          throw new FHIRException("Cannot call addChild on a singleton property Device.name.display");
1172        }
1173        else
1174          return super.addChild(name);
1175      }
1176
1177      public DeviceNameComponent copy() {
1178        DeviceNameComponent dst = new DeviceNameComponent();
1179        copyValues(dst);
1180        return dst;
1181      }
1182
1183      public void copyValues(DeviceNameComponent dst) {
1184        super.copyValues(dst);
1185        dst.value = value == null ? null : value.copy();
1186        dst.type = type == null ? null : type.copy();
1187        dst.display = display == null ? null : display.copy();
1188      }
1189
1190      @Override
1191      public boolean equalsDeep(Base other_) {
1192        if (!super.equalsDeep(other_))
1193          return false;
1194        if (!(other_ instanceof DeviceNameComponent))
1195          return false;
1196        DeviceNameComponent o = (DeviceNameComponent) other_;
1197        return compareDeep(value, o.value, true) && compareDeep(type, o.type, true) && compareDeep(display, o.display, true)
1198          ;
1199      }
1200
1201      @Override
1202      public boolean equalsShallow(Base other_) {
1203        if (!super.equalsShallow(other_))
1204          return false;
1205        if (!(other_ instanceof DeviceNameComponent))
1206          return false;
1207        DeviceNameComponent o = (DeviceNameComponent) other_;
1208        return compareValues(value, o.value, true) && compareValues(type, o.type, true) && compareValues(display, o.display, true)
1209          ;
1210      }
1211
1212      public boolean isEmpty() {
1213        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(value, type, display);
1214      }
1215
1216  public String fhirType() {
1217    return "Device.name";
1218
1219  }
1220
1221  }
1222
1223    @Block()
1224    public static class DeviceVersionComponent extends BackboneElement implements IBaseBackboneElement {
1225        /**
1226         * The type of the device version, e.g. manufacturer, approved, internal.
1227         */
1228        @Child(name = "type", type = {CodeableConcept.class}, order=1, min=0, max=1, modifier=false, summary=false)
1229        @Description(shortDefinition="The type of the device version, e.g. manufacturer, approved, internal", formalDefinition="The type of the device version, e.g. manufacturer, approved, internal." )
1230        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/device-versiontype")
1231        protected CodeableConcept type;
1232
1233        /**
1234         * The hardware or software module of the device to which the version applies.
1235         */
1236        @Child(name = "component", type = {Identifier.class}, order=2, min=0, max=1, modifier=false, summary=false)
1237        @Description(shortDefinition="The hardware or software module of the device to which the version applies", formalDefinition="The hardware or software module of the device to which the version applies." )
1238        protected Identifier component;
1239
1240        /**
1241         * The date the version was installed on the device.
1242         */
1243        @Child(name = "installDate", type = {DateTimeType.class}, order=3, min=0, max=1, modifier=false, summary=false)
1244        @Description(shortDefinition="The date the version was installed on the device", formalDefinition="The date the version was installed on the device." )
1245        protected DateTimeType installDate;
1246
1247        /**
1248         * The version text.
1249         */
1250        @Child(name = "value", type = {StringType.class}, order=4, min=1, max=1, modifier=false, summary=false)
1251        @Description(shortDefinition="The version text", formalDefinition="The version text." )
1252        protected StringType value;
1253
1254        private static final long serialVersionUID = 1358422741L;
1255
1256    /**
1257     * Constructor
1258     */
1259      public DeviceVersionComponent() {
1260        super();
1261      }
1262
1263    /**
1264     * Constructor
1265     */
1266      public DeviceVersionComponent(String value) {
1267        super();
1268        this.setValue(value);
1269      }
1270
1271        /**
1272         * @return {@link #type} (The type of the device version, e.g. manufacturer, approved, internal.)
1273         */
1274        public CodeableConcept getType() { 
1275          if (this.type == null)
1276            if (Configuration.errorOnAutoCreate())
1277              throw new Error("Attempt to auto-create DeviceVersionComponent.type");
1278            else if (Configuration.doAutoCreate())
1279              this.type = new CodeableConcept(); // cc
1280          return this.type;
1281        }
1282
1283        public boolean hasType() { 
1284          return this.type != null && !this.type.isEmpty();
1285        }
1286
1287        /**
1288         * @param value {@link #type} (The type of the device version, e.g. manufacturer, approved, internal.)
1289         */
1290        public DeviceVersionComponent setType(CodeableConcept value) { 
1291          this.type = value;
1292          return this;
1293        }
1294
1295        /**
1296         * @return {@link #component} (The hardware or software module of the device to which the version applies.)
1297         */
1298        public Identifier getComponent() { 
1299          if (this.component == null)
1300            if (Configuration.errorOnAutoCreate())
1301              throw new Error("Attempt to auto-create DeviceVersionComponent.component");
1302            else if (Configuration.doAutoCreate())
1303              this.component = new Identifier(); // cc
1304          return this.component;
1305        }
1306
1307        public boolean hasComponent() { 
1308          return this.component != null && !this.component.isEmpty();
1309        }
1310
1311        /**
1312         * @param value {@link #component} (The hardware or software module of the device to which the version applies.)
1313         */
1314        public DeviceVersionComponent setComponent(Identifier value) { 
1315          this.component = value;
1316          return this;
1317        }
1318
1319        /**
1320         * @return {@link #installDate} (The date the version was installed on the device.). This is the underlying object with id, value and extensions. The accessor "getInstallDate" gives direct access to the value
1321         */
1322        public DateTimeType getInstallDateElement() { 
1323          if (this.installDate == null)
1324            if (Configuration.errorOnAutoCreate())
1325              throw new Error("Attempt to auto-create DeviceVersionComponent.installDate");
1326            else if (Configuration.doAutoCreate())
1327              this.installDate = new DateTimeType(); // bb
1328          return this.installDate;
1329        }
1330
1331        public boolean hasInstallDateElement() { 
1332          return this.installDate != null && !this.installDate.isEmpty();
1333        }
1334
1335        public boolean hasInstallDate() { 
1336          return this.installDate != null && !this.installDate.isEmpty();
1337        }
1338
1339        /**
1340         * @param value {@link #installDate} (The date the version was installed on the device.). This is the underlying object with id, value and extensions. The accessor "getInstallDate" gives direct access to the value
1341         */
1342        public DeviceVersionComponent setInstallDateElement(DateTimeType value) { 
1343          this.installDate = value;
1344          return this;
1345        }
1346
1347        /**
1348         * @return The date the version was installed on the device.
1349         */
1350        public Date getInstallDate() { 
1351          return this.installDate == null ? null : this.installDate.getValue();
1352        }
1353
1354        /**
1355         * @param value The date the version was installed on the device.
1356         */
1357        public DeviceVersionComponent setInstallDate(Date value) { 
1358          if (value == null)
1359            this.installDate = null;
1360          else {
1361            if (this.installDate == null)
1362              this.installDate = new DateTimeType();
1363            this.installDate.setValue(value);
1364          }
1365          return this;
1366        }
1367
1368        /**
1369         * @return {@link #value} (The version text.). This is the underlying object with id, value and extensions. The accessor "getValue" gives direct access to the value
1370         */
1371        public StringType getValueElement() { 
1372          if (this.value == null)
1373            if (Configuration.errorOnAutoCreate())
1374              throw new Error("Attempt to auto-create DeviceVersionComponent.value");
1375            else if (Configuration.doAutoCreate())
1376              this.value = new StringType(); // bb
1377          return this.value;
1378        }
1379
1380        public boolean hasValueElement() { 
1381          return this.value != null && !this.value.isEmpty();
1382        }
1383
1384        public boolean hasValue() { 
1385          return this.value != null && !this.value.isEmpty();
1386        }
1387
1388        /**
1389         * @param value {@link #value} (The version text.). This is the underlying object with id, value and extensions. The accessor "getValue" gives direct access to the value
1390         */
1391        public DeviceVersionComponent setValueElement(StringType value) { 
1392          this.value = value;
1393          return this;
1394        }
1395
1396        /**
1397         * @return The version text.
1398         */
1399        public String getValue() { 
1400          return this.value == null ? null : this.value.getValue();
1401        }
1402
1403        /**
1404         * @param value The version text.
1405         */
1406        public DeviceVersionComponent setValue(String value) { 
1407            if (this.value == null)
1408              this.value = new StringType();
1409            this.value.setValue(value);
1410          return this;
1411        }
1412
1413        protected void listChildren(List<Property> children) {
1414          super.listChildren(children);
1415          children.add(new Property("type", "CodeableConcept", "The type of the device version, e.g. manufacturer, approved, internal.", 0, 1, type));
1416          children.add(new Property("component", "Identifier", "The hardware or software module of the device to which the version applies.", 0, 1, component));
1417          children.add(new Property("installDate", "dateTime", "The date the version was installed on the device.", 0, 1, installDate));
1418          children.add(new Property("value", "string", "The version text.", 0, 1, value));
1419        }
1420
1421        @Override
1422        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1423          switch (_hash) {
1424          case 3575610: /*type*/  return new Property("type", "CodeableConcept", "The type of the device version, e.g. manufacturer, approved, internal.", 0, 1, type);
1425          case -1399907075: /*component*/  return new Property("component", "Identifier", "The hardware or software module of the device to which the version applies.", 0, 1, component);
1426          case 2143044585: /*installDate*/  return new Property("installDate", "dateTime", "The date the version was installed on the device.", 0, 1, installDate);
1427          case 111972721: /*value*/  return new Property("value", "string", "The version text.", 0, 1, value);
1428          default: return super.getNamedProperty(_hash, _name, _checkValid);
1429          }
1430
1431        }
1432
1433      @Override
1434      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1435        switch (hash) {
1436        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // CodeableConcept
1437        case -1399907075: /*component*/ return this.component == null ? new Base[0] : new Base[] {this.component}; // Identifier
1438        case 2143044585: /*installDate*/ return this.installDate == null ? new Base[0] : new Base[] {this.installDate}; // DateTimeType
1439        case 111972721: /*value*/ return this.value == null ? new Base[0] : new Base[] {this.value}; // StringType
1440        default: return super.getProperty(hash, name, checkValid);
1441        }
1442
1443      }
1444
1445      @Override
1446      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1447        switch (hash) {
1448        case 3575610: // type
1449          this.type = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
1450          return value;
1451        case -1399907075: // component
1452          this.component = TypeConvertor.castToIdentifier(value); // Identifier
1453          return value;
1454        case 2143044585: // installDate
1455          this.installDate = TypeConvertor.castToDateTime(value); // DateTimeType
1456          return value;
1457        case 111972721: // value
1458          this.value = TypeConvertor.castToString(value); // StringType
1459          return value;
1460        default: return super.setProperty(hash, name, value);
1461        }
1462
1463      }
1464
1465      @Override
1466      public Base setProperty(String name, Base value) throws FHIRException {
1467        if (name.equals("type")) {
1468          this.type = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
1469        } else if (name.equals("component")) {
1470          this.component = TypeConvertor.castToIdentifier(value); // Identifier
1471        } else if (name.equals("installDate")) {
1472          this.installDate = TypeConvertor.castToDateTime(value); // DateTimeType
1473        } else if (name.equals("value")) {
1474          this.value = TypeConvertor.castToString(value); // StringType
1475        } else
1476          return super.setProperty(name, value);
1477        return value;
1478      }
1479
1480      @Override
1481      public Base makeProperty(int hash, String name) throws FHIRException {
1482        switch (hash) {
1483        case 3575610:  return getType();
1484        case -1399907075:  return getComponent();
1485        case 2143044585:  return getInstallDateElement();
1486        case 111972721:  return getValueElement();
1487        default: return super.makeProperty(hash, name);
1488        }
1489
1490      }
1491
1492      @Override
1493      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1494        switch (hash) {
1495        case 3575610: /*type*/ return new String[] {"CodeableConcept"};
1496        case -1399907075: /*component*/ return new String[] {"Identifier"};
1497        case 2143044585: /*installDate*/ return new String[] {"dateTime"};
1498        case 111972721: /*value*/ return new String[] {"string"};
1499        default: return super.getTypesForProperty(hash, name);
1500        }
1501
1502      }
1503
1504      @Override
1505      public Base addChild(String name) throws FHIRException {
1506        if (name.equals("type")) {
1507          this.type = new CodeableConcept();
1508          return this.type;
1509        }
1510        else if (name.equals("component")) {
1511          this.component = new Identifier();
1512          return this.component;
1513        }
1514        else if (name.equals("installDate")) {
1515          throw new FHIRException("Cannot call addChild on a singleton property Device.version.installDate");
1516        }
1517        else if (name.equals("value")) {
1518          throw new FHIRException("Cannot call addChild on a singleton property Device.version.value");
1519        }
1520        else
1521          return super.addChild(name);
1522      }
1523
1524      public DeviceVersionComponent copy() {
1525        DeviceVersionComponent dst = new DeviceVersionComponent();
1526        copyValues(dst);
1527        return dst;
1528      }
1529
1530      public void copyValues(DeviceVersionComponent dst) {
1531        super.copyValues(dst);
1532        dst.type = type == null ? null : type.copy();
1533        dst.component = component == null ? null : component.copy();
1534        dst.installDate = installDate == null ? null : installDate.copy();
1535        dst.value = value == null ? null : value.copy();
1536      }
1537
1538      @Override
1539      public boolean equalsDeep(Base other_) {
1540        if (!super.equalsDeep(other_))
1541          return false;
1542        if (!(other_ instanceof DeviceVersionComponent))
1543          return false;
1544        DeviceVersionComponent o = (DeviceVersionComponent) other_;
1545        return compareDeep(type, o.type, true) && compareDeep(component, o.component, true) && compareDeep(installDate, o.installDate, true)
1546           && compareDeep(value, o.value, true);
1547      }
1548
1549      @Override
1550      public boolean equalsShallow(Base other_) {
1551        if (!super.equalsShallow(other_))
1552          return false;
1553        if (!(other_ instanceof DeviceVersionComponent))
1554          return false;
1555        DeviceVersionComponent o = (DeviceVersionComponent) other_;
1556        return compareValues(installDate, o.installDate, true) && compareValues(value, o.value, true);
1557      }
1558
1559      public boolean isEmpty() {
1560        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(type, component, installDate
1561          , value);
1562      }
1563
1564  public String fhirType() {
1565    return "Device.version";
1566
1567  }
1568
1569  }
1570
1571    @Block()
1572    public static class DeviceConformsToComponent extends BackboneElement implements IBaseBackboneElement {
1573        /**
1574         * Describes the type of the standard, specification, or formal guidance.
1575         */
1576        @Child(name = "category", type = {CodeableConcept.class}, order=1, min=0, max=1, modifier=false, summary=false)
1577        @Description(shortDefinition="Describes the common type of the standard, specification, or formal guidance.  communication | performance | measurement", formalDefinition="Describes the type of the standard, specification, or formal guidance." )
1578        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/device-specification-category")
1579        protected CodeableConcept category;
1580
1581        /**
1582         * Code that identifies the specific standard, specification, protocol, formal guidance, regulation, legislation, or certification scheme to which the device adheres.
1583         */
1584        @Child(name = "specification", type = {CodeableConcept.class}, order=2, min=1, max=1, modifier=false, summary=false)
1585        @Description(shortDefinition="Identifies the standard, specification, or formal guidance that the device adheres to", formalDefinition="Code that identifies the specific standard, specification, protocol, formal guidance, regulation, legislation, or certification scheme to which the device adheres." )
1586        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/device-specification-type")
1587        protected CodeableConcept specification;
1588
1589        /**
1590         * Identifies the specific form or variant of the standard, specification, or formal guidance. This may be a 'version number', release, document edition, publication year, or other label.
1591         */
1592        @Child(name = "version", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=false)
1593        @Description(shortDefinition="Specific form or variant of the standard", formalDefinition="Identifies the specific form or variant of the standard, specification, or formal guidance. This may be a 'version number', release, document edition, publication year, or other label." )
1594        protected StringType version;
1595
1596        private static final long serialVersionUID = 1592712180L;
1597
1598    /**
1599     * Constructor
1600     */
1601      public DeviceConformsToComponent() {
1602        super();
1603      }
1604
1605    /**
1606     * Constructor
1607     */
1608      public DeviceConformsToComponent(CodeableConcept specification) {
1609        super();
1610        this.setSpecification(specification);
1611      }
1612
1613        /**
1614         * @return {@link #category} (Describes the type of the standard, specification, or formal guidance.)
1615         */
1616        public CodeableConcept getCategory() { 
1617          if (this.category == null)
1618            if (Configuration.errorOnAutoCreate())
1619              throw new Error("Attempt to auto-create DeviceConformsToComponent.category");
1620            else if (Configuration.doAutoCreate())
1621              this.category = new CodeableConcept(); // cc
1622          return this.category;
1623        }
1624
1625        public boolean hasCategory() { 
1626          return this.category != null && !this.category.isEmpty();
1627        }
1628
1629        /**
1630         * @param value {@link #category} (Describes the type of the standard, specification, or formal guidance.)
1631         */
1632        public DeviceConformsToComponent setCategory(CodeableConcept value) { 
1633          this.category = value;
1634          return this;
1635        }
1636
1637        /**
1638         * @return {@link #specification} (Code that identifies the specific standard, specification, protocol, formal guidance, regulation, legislation, or certification scheme to which the device adheres.)
1639         */
1640        public CodeableConcept getSpecification() { 
1641          if (this.specification == null)
1642            if (Configuration.errorOnAutoCreate())
1643              throw new Error("Attempt to auto-create DeviceConformsToComponent.specification");
1644            else if (Configuration.doAutoCreate())
1645              this.specification = new CodeableConcept(); // cc
1646          return this.specification;
1647        }
1648
1649        public boolean hasSpecification() { 
1650          return this.specification != null && !this.specification.isEmpty();
1651        }
1652
1653        /**
1654         * @param value {@link #specification} (Code that identifies the specific standard, specification, protocol, formal guidance, regulation, legislation, or certification scheme to which the device adheres.)
1655         */
1656        public DeviceConformsToComponent setSpecification(CodeableConcept value) { 
1657          this.specification = value;
1658          return this;
1659        }
1660
1661        /**
1662         * @return {@link #version} (Identifies the specific form or variant of the standard, specification, or formal guidance. This may be a 'version number', release, document edition, publication year, or other label.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value
1663         */
1664        public StringType getVersionElement() { 
1665          if (this.version == null)
1666            if (Configuration.errorOnAutoCreate())
1667              throw new Error("Attempt to auto-create DeviceConformsToComponent.version");
1668            else if (Configuration.doAutoCreate())
1669              this.version = new StringType(); // bb
1670          return this.version;
1671        }
1672
1673        public boolean hasVersionElement() { 
1674          return this.version != null && !this.version.isEmpty();
1675        }
1676
1677        public boolean hasVersion() { 
1678          return this.version != null && !this.version.isEmpty();
1679        }
1680
1681        /**
1682         * @param value {@link #version} (Identifies the specific form or variant of the standard, specification, or formal guidance. This may be a 'version number', release, document edition, publication year, or other label.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value
1683         */
1684        public DeviceConformsToComponent setVersionElement(StringType value) { 
1685          this.version = value;
1686          return this;
1687        }
1688
1689        /**
1690         * @return Identifies the specific form or variant of the standard, specification, or formal guidance. This may be a 'version number', release, document edition, publication year, or other label.
1691         */
1692        public String getVersion() { 
1693          return this.version == null ? null : this.version.getValue();
1694        }
1695
1696        /**
1697         * @param value Identifies the specific form or variant of the standard, specification, or formal guidance. This may be a 'version number', release, document edition, publication year, or other label.
1698         */
1699        public DeviceConformsToComponent setVersion(String value) { 
1700          if (Utilities.noString(value))
1701            this.version = null;
1702          else {
1703            if (this.version == null)
1704              this.version = new StringType();
1705            this.version.setValue(value);
1706          }
1707          return this;
1708        }
1709
1710        protected void listChildren(List<Property> children) {
1711          super.listChildren(children);
1712          children.add(new Property("category", "CodeableConcept", "Describes the type of the standard, specification, or formal guidance.", 0, 1, category));
1713          children.add(new Property("specification", "CodeableConcept", "Code that identifies the specific standard, specification, protocol, formal guidance, regulation, legislation, or certification scheme to which the device adheres.", 0, 1, specification));
1714          children.add(new Property("version", "string", "Identifies the specific form or variant of the standard, specification, or formal guidance. This may be a 'version number', release, document edition, publication year, or other label.", 0, 1, version));
1715        }
1716
1717        @Override
1718        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1719          switch (_hash) {
1720          case 50511102: /*category*/  return new Property("category", "CodeableConcept", "Describes the type of the standard, specification, or formal guidance.", 0, 1, category);
1721          case 1307197699: /*specification*/  return new Property("specification", "CodeableConcept", "Code that identifies the specific standard, specification, protocol, formal guidance, regulation, legislation, or certification scheme to which the device adheres.", 0, 1, specification);
1722          case 351608024: /*version*/  return new Property("version", "string", "Identifies the specific form or variant of the standard, specification, or formal guidance. This may be a 'version number', release, document edition, publication year, or other label.", 0, 1, version);
1723          default: return super.getNamedProperty(_hash, _name, _checkValid);
1724          }
1725
1726        }
1727
1728      @Override
1729      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1730        switch (hash) {
1731        case 50511102: /*category*/ return this.category == null ? new Base[0] : new Base[] {this.category}; // CodeableConcept
1732        case 1307197699: /*specification*/ return this.specification == null ? new Base[0] : new Base[] {this.specification}; // CodeableConcept
1733        case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType
1734        default: return super.getProperty(hash, name, checkValid);
1735        }
1736
1737      }
1738
1739      @Override
1740      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1741        switch (hash) {
1742        case 50511102: // category
1743          this.category = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
1744          return value;
1745        case 1307197699: // specification
1746          this.specification = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
1747          return value;
1748        case 351608024: // version
1749          this.version = TypeConvertor.castToString(value); // StringType
1750          return value;
1751        default: return super.setProperty(hash, name, value);
1752        }
1753
1754      }
1755
1756      @Override
1757      public Base setProperty(String name, Base value) throws FHIRException {
1758        if (name.equals("category")) {
1759          this.category = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
1760        } else if (name.equals("specification")) {
1761          this.specification = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
1762        } else if (name.equals("version")) {
1763          this.version = TypeConvertor.castToString(value); // StringType
1764        } else
1765          return super.setProperty(name, value);
1766        return value;
1767      }
1768
1769      @Override
1770      public Base makeProperty(int hash, String name) throws FHIRException {
1771        switch (hash) {
1772        case 50511102:  return getCategory();
1773        case 1307197699:  return getSpecification();
1774        case 351608024:  return getVersionElement();
1775        default: return super.makeProperty(hash, name);
1776        }
1777
1778      }
1779
1780      @Override
1781      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1782        switch (hash) {
1783        case 50511102: /*category*/ return new String[] {"CodeableConcept"};
1784        case 1307197699: /*specification*/ return new String[] {"CodeableConcept"};
1785        case 351608024: /*version*/ return new String[] {"string"};
1786        default: return super.getTypesForProperty(hash, name);
1787        }
1788
1789      }
1790
1791      @Override
1792      public Base addChild(String name) throws FHIRException {
1793        if (name.equals("category")) {
1794          this.category = new CodeableConcept();
1795          return this.category;
1796        }
1797        else if (name.equals("specification")) {
1798          this.specification = new CodeableConcept();
1799          return this.specification;
1800        }
1801        else if (name.equals("version")) {
1802          throw new FHIRException("Cannot call addChild on a singleton property Device.conformsTo.version");
1803        }
1804        else
1805          return super.addChild(name);
1806      }
1807
1808      public DeviceConformsToComponent copy() {
1809        DeviceConformsToComponent dst = new DeviceConformsToComponent();
1810        copyValues(dst);
1811        return dst;
1812      }
1813
1814      public void copyValues(DeviceConformsToComponent dst) {
1815        super.copyValues(dst);
1816        dst.category = category == null ? null : category.copy();
1817        dst.specification = specification == null ? null : specification.copy();
1818        dst.version = version == null ? null : version.copy();
1819      }
1820
1821      @Override
1822      public boolean equalsDeep(Base other_) {
1823        if (!super.equalsDeep(other_))
1824          return false;
1825        if (!(other_ instanceof DeviceConformsToComponent))
1826          return false;
1827        DeviceConformsToComponent o = (DeviceConformsToComponent) other_;
1828        return compareDeep(category, o.category, true) && compareDeep(specification, o.specification, true)
1829           && compareDeep(version, o.version, true);
1830      }
1831
1832      @Override
1833      public boolean equalsShallow(Base other_) {
1834        if (!super.equalsShallow(other_))
1835          return false;
1836        if (!(other_ instanceof DeviceConformsToComponent))
1837          return false;
1838        DeviceConformsToComponent o = (DeviceConformsToComponent) other_;
1839        return compareValues(version, o.version, true);
1840      }
1841
1842      public boolean isEmpty() {
1843        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(category, specification, version
1844          );
1845      }
1846
1847  public String fhirType() {
1848    return "Device.conformsTo";
1849
1850  }
1851
1852  }
1853
1854    @Block()
1855    public static class DevicePropertyComponent extends BackboneElement implements IBaseBackboneElement {
1856        /**
1857         * Code that specifies the property, such as resolution, color, size, being represented.
1858         */
1859        @Child(name = "type", type = {CodeableConcept.class}, order=1, min=1, max=1, modifier=false, summary=false)
1860        @Description(shortDefinition="Code that specifies the property being represented", formalDefinition="Code that specifies the property, such as resolution, color, size, being represented." )
1861        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/device-property-type")
1862        protected CodeableConcept type;
1863
1864        /**
1865         * The value of the property specified by the associated property.type code.
1866         */
1867        @Child(name = "value", type = {Quantity.class, CodeableConcept.class, StringType.class, BooleanType.class, IntegerType.class, Range.class, Attachment.class}, order=2, min=1, max=1, modifier=false, summary=false)
1868        @Description(shortDefinition="Value of the property", formalDefinition="The value of the property specified by the associated property.type code." )
1869        protected DataType value;
1870
1871        private static final long serialVersionUID = -1659186716L;
1872
1873    /**
1874     * Constructor
1875     */
1876      public DevicePropertyComponent() {
1877        super();
1878      }
1879
1880    /**
1881     * Constructor
1882     */
1883      public DevicePropertyComponent(CodeableConcept type, DataType value) {
1884        super();
1885        this.setType(type);
1886        this.setValue(value);
1887      }
1888
1889        /**
1890         * @return {@link #type} (Code that specifies the property, such as resolution, color, size, being represented.)
1891         */
1892        public CodeableConcept getType() { 
1893          if (this.type == null)
1894            if (Configuration.errorOnAutoCreate())
1895              throw new Error("Attempt to auto-create DevicePropertyComponent.type");
1896            else if (Configuration.doAutoCreate())
1897              this.type = new CodeableConcept(); // cc
1898          return this.type;
1899        }
1900
1901        public boolean hasType() { 
1902          return this.type != null && !this.type.isEmpty();
1903        }
1904
1905        /**
1906         * @param value {@link #type} (Code that specifies the property, such as resolution, color, size, being represented.)
1907         */
1908        public DevicePropertyComponent setType(CodeableConcept value) { 
1909          this.type = value;
1910          return this;
1911        }
1912
1913        /**
1914         * @return {@link #value} (The value of the property specified by the associated property.type code.)
1915         */
1916        public DataType getValue() { 
1917          return this.value;
1918        }
1919
1920        /**
1921         * @return {@link #value} (The value of the property specified by the associated property.type code.)
1922         */
1923        public Quantity getValueQuantity() throws FHIRException { 
1924          if (this.value == null)
1925            this.value = new Quantity();
1926          if (!(this.value instanceof Quantity))
1927            throw new FHIRException("Type mismatch: the type Quantity was expected, but "+this.value.getClass().getName()+" was encountered");
1928          return (Quantity) this.value;
1929        }
1930
1931        public boolean hasValueQuantity() { 
1932          return this != null && this.value instanceof Quantity;
1933        }
1934
1935        /**
1936         * @return {@link #value} (The value of the property specified by the associated property.type code.)
1937         */
1938        public CodeableConcept getValueCodeableConcept() throws FHIRException { 
1939          if (this.value == null)
1940            this.value = new CodeableConcept();
1941          if (!(this.value instanceof CodeableConcept))
1942            throw new FHIRException("Type mismatch: the type CodeableConcept was expected, but "+this.value.getClass().getName()+" was encountered");
1943          return (CodeableConcept) this.value;
1944        }
1945
1946        public boolean hasValueCodeableConcept() { 
1947          return this != null && this.value instanceof CodeableConcept;
1948        }
1949
1950        /**
1951         * @return {@link #value} (The value of the property specified by the associated property.type code.)
1952         */
1953        public StringType getValueStringType() throws FHIRException { 
1954          if (this.value == null)
1955            this.value = new StringType();
1956          if (!(this.value instanceof StringType))
1957            throw new FHIRException("Type mismatch: the type StringType was expected, but "+this.value.getClass().getName()+" was encountered");
1958          return (StringType) this.value;
1959        }
1960
1961        public boolean hasValueStringType() { 
1962          return this != null && this.value instanceof StringType;
1963        }
1964
1965        /**
1966         * @return {@link #value} (The value of the property specified by the associated property.type code.)
1967         */
1968        public BooleanType getValueBooleanType() throws FHIRException { 
1969          if (this.value == null)
1970            this.value = new BooleanType();
1971          if (!(this.value instanceof BooleanType))
1972            throw new FHIRException("Type mismatch: the type BooleanType was expected, but "+this.value.getClass().getName()+" was encountered");
1973          return (BooleanType) this.value;
1974        }
1975
1976        public boolean hasValueBooleanType() { 
1977          return this != null && this.value instanceof BooleanType;
1978        }
1979
1980        /**
1981         * @return {@link #value} (The value of the property specified by the associated property.type code.)
1982         */
1983        public IntegerType getValueIntegerType() throws FHIRException { 
1984          if (this.value == null)
1985            this.value = new IntegerType();
1986          if (!(this.value instanceof IntegerType))
1987            throw new FHIRException("Type mismatch: the type IntegerType was expected, but "+this.value.getClass().getName()+" was encountered");
1988          return (IntegerType) this.value;
1989        }
1990
1991        public boolean hasValueIntegerType() { 
1992          return this != null && this.value instanceof IntegerType;
1993        }
1994
1995        /**
1996         * @return {@link #value} (The value of the property specified by the associated property.type code.)
1997         */
1998        public Range getValueRange() throws FHIRException { 
1999          if (this.value == null)
2000            this.value = new Range();
2001          if (!(this.value instanceof Range))
2002            throw new FHIRException("Type mismatch: the type Range was expected, but "+this.value.getClass().getName()+" was encountered");
2003          return (Range) this.value;
2004        }
2005
2006        public boolean hasValueRange() { 
2007          return this != null && this.value instanceof Range;
2008        }
2009
2010        /**
2011         * @return {@link #value} (The value of the property specified by the associated property.type code.)
2012         */
2013        public Attachment getValueAttachment() throws FHIRException { 
2014          if (this.value == null)
2015            this.value = new Attachment();
2016          if (!(this.value instanceof Attachment))
2017            throw new FHIRException("Type mismatch: the type Attachment was expected, but "+this.value.getClass().getName()+" was encountered");
2018          return (Attachment) this.value;
2019        }
2020
2021        public boolean hasValueAttachment() { 
2022          return this != null && this.value instanceof Attachment;
2023        }
2024
2025        public boolean hasValue() { 
2026          return this.value != null && !this.value.isEmpty();
2027        }
2028
2029        /**
2030         * @param value {@link #value} (The value of the property specified by the associated property.type code.)
2031         */
2032        public DevicePropertyComponent setValue(DataType value) { 
2033          if (value != null && !(value instanceof Quantity || value instanceof CodeableConcept || value instanceof StringType || value instanceof BooleanType || value instanceof IntegerType || value instanceof Range || value instanceof Attachment))
2034            throw new FHIRException("Not the right type for Device.property.value[x]: "+value.fhirType());
2035          this.value = value;
2036          return this;
2037        }
2038
2039        protected void listChildren(List<Property> children) {
2040          super.listChildren(children);
2041          children.add(new Property("type", "CodeableConcept", "Code that specifies the property, such as resolution, color, size, being represented.", 0, 1, type));
2042          children.add(new Property("value[x]", "Quantity|CodeableConcept|string|boolean|integer|Range|Attachment", "The value of the property specified by the associated property.type code.", 0, 1, value));
2043        }
2044
2045        @Override
2046        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2047          switch (_hash) {
2048          case 3575610: /*type*/  return new Property("type", "CodeableConcept", "Code that specifies the property, such as resolution, color, size, being represented.", 0, 1, type);
2049          case -1410166417: /*value[x]*/  return new Property("value[x]", "Quantity|CodeableConcept|string|boolean|integer|Range|Attachment", "The value of the property specified by the associated property.type code.", 0, 1, value);
2050          case 111972721: /*value*/  return new Property("value[x]", "Quantity|CodeableConcept|string|boolean|integer|Range|Attachment", "The value of the property specified by the associated property.type code.", 0, 1, value);
2051          case -2029823716: /*valueQuantity*/  return new Property("value[x]", "Quantity", "The value of the property specified by the associated property.type code.", 0, 1, value);
2052          case 924902896: /*valueCodeableConcept*/  return new Property("value[x]", "CodeableConcept", "The value of the property specified by the associated property.type code.", 0, 1, value);
2053          case -1424603934: /*valueString*/  return new Property("value[x]", "string", "The value of the property specified by the associated property.type code.", 0, 1, value);
2054          case 733421943: /*valueBoolean*/  return new Property("value[x]", "boolean", "The value of the property specified by the associated property.type code.", 0, 1, value);
2055          case -1668204915: /*valueInteger*/  return new Property("value[x]", "integer", "The value of the property specified by the associated property.type code.", 0, 1, value);
2056          case 2030761548: /*valueRange*/  return new Property("value[x]", "Range", "The value of the property specified by the associated property.type code.", 0, 1, value);
2057          case -475566732: /*valueAttachment*/  return new Property("value[x]", "Attachment", "The value of the property specified by the associated property.type code.", 0, 1, value);
2058          default: return super.getNamedProperty(_hash, _name, _checkValid);
2059          }
2060
2061        }
2062
2063      @Override
2064      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2065        switch (hash) {
2066        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // CodeableConcept
2067        case 111972721: /*value*/ return this.value == null ? new Base[0] : new Base[] {this.value}; // DataType
2068        default: return super.getProperty(hash, name, checkValid);
2069        }
2070
2071      }
2072
2073      @Override
2074      public Base setProperty(int hash, String name, Base value) throws FHIRException {
2075        switch (hash) {
2076        case 3575610: // type
2077          this.type = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
2078          return value;
2079        case 111972721: // value
2080          this.value = TypeConvertor.castToType(value); // DataType
2081          return value;
2082        default: return super.setProperty(hash, name, value);
2083        }
2084
2085      }
2086
2087      @Override
2088      public Base setProperty(String name, Base value) throws FHIRException {
2089        if (name.equals("type")) {
2090          this.type = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
2091        } else if (name.equals("value[x]")) {
2092          this.value = TypeConvertor.castToType(value); // DataType
2093        } else
2094          return super.setProperty(name, value);
2095        return value;
2096      }
2097
2098      @Override
2099      public Base makeProperty(int hash, String name) throws FHIRException {
2100        switch (hash) {
2101        case 3575610:  return getType();
2102        case -1410166417:  return getValue();
2103        case 111972721:  return getValue();
2104        default: return super.makeProperty(hash, name);
2105        }
2106
2107      }
2108
2109      @Override
2110      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2111        switch (hash) {
2112        case 3575610: /*type*/ return new String[] {"CodeableConcept"};
2113        case 111972721: /*value*/ return new String[] {"Quantity", "CodeableConcept", "string", "boolean", "integer", "Range", "Attachment"};
2114        default: return super.getTypesForProperty(hash, name);
2115        }
2116
2117      }
2118
2119      @Override
2120      public Base addChild(String name) throws FHIRException {
2121        if (name.equals("type")) {
2122          this.type = new CodeableConcept();
2123          return this.type;
2124        }
2125        else if (name.equals("valueQuantity")) {
2126          this.value = new Quantity();
2127          return this.value;
2128        }
2129        else if (name.equals("valueCodeableConcept")) {
2130          this.value = new CodeableConcept();
2131          return this.value;
2132        }
2133        else if (name.equals("valueString")) {
2134          this.value = new StringType();
2135          return this.value;
2136        }
2137        else if (name.equals("valueBoolean")) {
2138          this.value = new BooleanType();
2139          return this.value;
2140        }
2141        else if (name.equals("valueInteger")) {
2142          this.value = new IntegerType();
2143          return this.value;
2144        }
2145        else if (name.equals("valueRange")) {
2146          this.value = new Range();
2147          return this.value;
2148        }
2149        else if (name.equals("valueAttachment")) {
2150          this.value = new Attachment();
2151          return this.value;
2152        }
2153        else
2154          return super.addChild(name);
2155      }
2156
2157      public DevicePropertyComponent copy() {
2158        DevicePropertyComponent dst = new DevicePropertyComponent();
2159        copyValues(dst);
2160        return dst;
2161      }
2162
2163      public void copyValues(DevicePropertyComponent dst) {
2164        super.copyValues(dst);
2165        dst.type = type == null ? null : type.copy();
2166        dst.value = value == null ? null : value.copy();
2167      }
2168
2169      @Override
2170      public boolean equalsDeep(Base other_) {
2171        if (!super.equalsDeep(other_))
2172          return false;
2173        if (!(other_ instanceof DevicePropertyComponent))
2174          return false;
2175        DevicePropertyComponent o = (DevicePropertyComponent) other_;
2176        return compareDeep(type, o.type, true) && compareDeep(value, o.value, true);
2177      }
2178
2179      @Override
2180      public boolean equalsShallow(Base other_) {
2181        if (!super.equalsShallow(other_))
2182          return false;
2183        if (!(other_ instanceof DevicePropertyComponent))
2184          return false;
2185        DevicePropertyComponent o = (DevicePropertyComponent) other_;
2186        return true;
2187      }
2188
2189      public boolean isEmpty() {
2190        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(type, value);
2191      }
2192
2193  public String fhirType() {
2194    return "Device.property";
2195
2196  }
2197
2198  }
2199
2200    /**
2201     * Unique instance identifiers assigned to a device by manufacturers other organizations or owners.
2202     */
2203    @Child(name = "identifier", type = {Identifier.class}, order=0, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2204    @Description(shortDefinition="Instance identifier", formalDefinition="Unique instance identifiers assigned to a device by manufacturers other organizations or owners." )
2205    protected List<Identifier> identifier;
2206
2207    /**
2208     * The name used to display by default when the device is referenced. Based on intent of use by the resource creator, this may reflect one of the names in Device.name, or may be another simple name.
2209     */
2210    @Child(name = "displayName", type = {StringType.class}, order=1, min=0, max=1, modifier=false, summary=false)
2211    @Description(shortDefinition="The name used to display by default when the device is referenced", formalDefinition="The name used to display by default when the device is referenced. Based on intent of use by the resource creator, this may reflect one of the names in Device.name, or may be another simple name." )
2212    protected StringType displayName;
2213
2214    /**
2215     * The reference to the definition for the device.
2216     */
2217    @Child(name = "definition", type = {CodeableReference.class}, order=2, min=0, max=1, modifier=false, summary=false)
2218    @Description(shortDefinition="The reference to the definition for the device", formalDefinition="The reference to the definition for the device." )
2219    protected CodeableReference definition;
2220
2221    /**
2222     * Unique device identifier (UDI) assigned to device label or package.  Note that the Device may include multiple udiCarriers as it either may include just the udiCarrier for the jurisdiction it is sold, or for multiple jurisdictions it could have been sold.
2223     */
2224    @Child(name = "udiCarrier", type = {}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
2225    @Description(shortDefinition="Unique Device Identifier (UDI) Barcode string", formalDefinition="Unique device identifier (UDI) assigned to device label or package.  Note that the Device may include multiple udiCarriers as it either may include just the udiCarrier for the jurisdiction it is sold, or for multiple jurisdictions it could have been sold." )
2226    protected List<DeviceUdiCarrierComponent> udiCarrier;
2227
2228    /**
2229     * The Device record status. This is not the status of the device like availability.
2230     */
2231    @Child(name = "status", type = {CodeType.class}, order=4, min=0, max=1, modifier=true, summary=true)
2232    @Description(shortDefinition="active | inactive | entered-in-error", formalDefinition="The Device record status. This is not the status of the device like availability." )
2233    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/device-status")
2234    protected Enumeration<FHIRDeviceStatus> status;
2235
2236    /**
2237     * The availability of the device.
2238     */
2239    @Child(name = "availabilityStatus", type = {CodeableConcept.class}, order=5, min=0, max=1, modifier=false, summary=false)
2240    @Description(shortDefinition="lost | damaged | destroyed | available", formalDefinition="The availability of the device." )
2241    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/device-availability-status")
2242    protected CodeableConcept availabilityStatus;
2243
2244    /**
2245     * An identifier that supports traceability to the event during which material in this product from one or more biological entities was obtained or pooled.
2246     */
2247    @Child(name = "biologicalSourceEvent", type = {Identifier.class}, order=6, min=0, max=1, modifier=false, summary=false)
2248    @Description(shortDefinition="An identifier that supports traceability to the event during which material in this product from one or more biological entities was obtained or pooled", formalDefinition="An identifier that supports traceability to the event during which material in this product from one or more biological entities was obtained or pooled." )
2249    protected Identifier biologicalSourceEvent;
2250
2251    /**
2252     * A name of the manufacturer or entity legally responsible for the device.
2253     */
2254    @Child(name = "manufacturer", type = {StringType.class}, order=7, min=0, max=1, modifier=false, summary=false)
2255    @Description(shortDefinition="Name of device manufacturer", formalDefinition="A name of the manufacturer or entity legally responsible for the device." )
2256    protected StringType manufacturer;
2257
2258    /**
2259     * The date and time when the device was manufactured.
2260     */
2261    @Child(name = "manufactureDate", type = {DateTimeType.class}, order=8, min=0, max=1, modifier=false, summary=false)
2262    @Description(shortDefinition="Date when the device was made", formalDefinition="The date and time when the device was manufactured." )
2263    protected DateTimeType manufactureDate;
2264
2265    /**
2266     * The date and time beyond which this device is no longer valid or should not be used (if applicable).
2267     */
2268    @Child(name = "expirationDate", type = {DateTimeType.class}, order=9, min=0, max=1, modifier=false, summary=false)
2269    @Description(shortDefinition="Date and time of expiry of this device (if applicable)", formalDefinition="The date and time beyond which this device is no longer valid or should not be used (if applicable)." )
2270    protected DateTimeType expirationDate;
2271
2272    /**
2273     * Lot number assigned by the manufacturer.
2274     */
2275    @Child(name = "lotNumber", type = {StringType.class}, order=10, min=0, max=1, modifier=false, summary=false)
2276    @Description(shortDefinition="Lot number of manufacture", formalDefinition="Lot number assigned by the manufacturer." )
2277    protected StringType lotNumber;
2278
2279    /**
2280     * The serial number assigned by the organization when the device was manufactured.
2281     */
2282    @Child(name = "serialNumber", type = {StringType.class}, order=11, min=0, max=1, modifier=false, summary=false)
2283    @Description(shortDefinition="Serial number assigned by the manufacturer", formalDefinition="The serial number assigned by the organization when the device was manufactured." )
2284    protected StringType serialNumber;
2285
2286    /**
2287     * This represents the manufacturer's name of the device as provided by the device, from a UDI label, or by a person describing the Device.  This typically would be used when a person provides the name(s) or when the device represents one of the names available from DeviceDefinition.
2288     */
2289    @Child(name = "name", type = {}, order=12, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2290    @Description(shortDefinition="The name or names of the device as known to the manufacturer and/or patient", formalDefinition="This represents the manufacturer's name of the device as provided by the device, from a UDI label, or by a person describing the Device.  This typically would be used when a person provides the name(s) or when the device represents one of the names available from DeviceDefinition." )
2291    protected List<DeviceNameComponent> name;
2292
2293    /**
2294     * The manufacturer's model number for the device.
2295     */
2296    @Child(name = "modelNumber", type = {StringType.class}, order=13, min=0, max=1, modifier=false, summary=false)
2297    @Description(shortDefinition="The manufacturer's model number for the device", formalDefinition="The manufacturer's model number for the device." )
2298    protected StringType modelNumber;
2299
2300    /**
2301     * The part number or catalog number of the device.
2302     */
2303    @Child(name = "partNumber", type = {StringType.class}, order=14, min=0, max=1, modifier=false, summary=false)
2304    @Description(shortDefinition="The part number or catalog number of the device", formalDefinition="The part number or catalog number of the device." )
2305    protected StringType partNumber;
2306
2307    /**
2308     * Devices may be associated with one or more categories.
2309     */
2310    @Child(name = "category", type = {CodeableConcept.class}, order=15, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2311    @Description(shortDefinition="Indicates a high-level grouping of the device", formalDefinition="Devices may be associated with one or more categories." )
2312    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/device-category")
2313    protected List<CodeableConcept> category;
2314
2315    /**
2316     * The kind or type of device. A device instance may have more than one type - in which case those are the types that apply to the specific instance of the device.
2317     */
2318    @Child(name = "type", type = {CodeableConcept.class}, order=16, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2319    @Description(shortDefinition="The kind or type of device", formalDefinition="The kind or type of device. A device instance may have more than one type - in which case those are the types that apply to the specific instance of the device." )
2320    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/device-type")
2321    protected List<CodeableConcept> type;
2322
2323    /**
2324     * The actual design of the device or software version running on the device.
2325     */
2326    @Child(name = "version", type = {}, order=17, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2327    @Description(shortDefinition="The actual design of the device or software version running on the device", formalDefinition="The actual design of the device or software version running on the device." )
2328    protected List<DeviceVersionComponent> version;
2329
2330    /**
2331     * Identifies the standards, specifications, or formal guidances for the capabilities supported by the device. The device may be certified as conformant to these specifications e.g., communication, performance, process, measurement, or specialization standards.
2332     */
2333    @Child(name = "conformsTo", type = {}, order=18, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2334    @Description(shortDefinition="Identifies the standards, specifications, or formal guidances for the capabilities supported by the device", formalDefinition="Identifies the standards, specifications, or formal guidances for the capabilities supported by the device. The device may be certified as conformant to these specifications e.g., communication, performance, process, measurement, or specialization standards." )
2335    protected List<DeviceConformsToComponent> conformsTo;
2336
2337    /**
2338     * Static or essentially fixed characteristics or features of the device (e.g., time or timing attributes, resolution, accuracy, intended use or instructions for use, and physical attributes) that are not otherwise captured in more specific attributes.
2339     */
2340    @Child(name = "property", type = {}, order=19, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2341    @Description(shortDefinition="Inherent, essentially fixed, characteristics of the device.  e.g., time properties, size, material, etc.", formalDefinition="Static or essentially fixed characteristics or features of the device (e.g., time or timing attributes, resolution, accuracy, intended use or instructions for use, and physical attributes) that are not otherwise captured in more specific attributes." )
2342    protected List<DevicePropertyComponent> property;
2343
2344    /**
2345     * The designated condition for performing a task with the device.
2346     */
2347    @Child(name = "mode", type = {CodeableConcept.class}, order=20, min=0, max=1, modifier=false, summary=false)
2348    @Description(shortDefinition="The designated condition for performing a task", formalDefinition="The designated condition for performing a task with the device." )
2349    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/device-operation-mode")
2350    protected CodeableConcept mode;
2351
2352    /**
2353     * The series of occurrences that repeats during the operation of the device.
2354     */
2355    @Child(name = "cycle", type = {Count.class}, order=21, min=0, max=1, modifier=false, summary=false)
2356    @Description(shortDefinition="The series of occurrences that repeats during the operation of the device", formalDefinition="The series of occurrences that repeats during the operation of the device." )
2357    protected Count cycle;
2358
2359    /**
2360     * A measurement of time during the device's operation (e.g., days, hours, mins, etc.).
2361     */
2362    @Child(name = "duration", type = {Duration.class}, order=22, min=0, max=1, modifier=false, summary=false)
2363    @Description(shortDefinition="A measurement of time during the device's operation (e.g., days, hours, mins, etc.)", formalDefinition="A measurement of time during the device's operation (e.g., days, hours, mins, etc.)." )
2364    protected Duration duration;
2365
2366    /**
2367     * An organization that is responsible for the provision and ongoing maintenance of the device.
2368     */
2369    @Child(name = "owner", type = {Organization.class}, order=23, min=0, max=1, modifier=false, summary=false)
2370    @Description(shortDefinition="Organization responsible for device", formalDefinition="An organization that is responsible for the provision and ongoing maintenance of the device." )
2371    protected Reference owner;
2372
2373    /**
2374     * Contact details for an organization or a particular human that is responsible for the device.
2375     */
2376    @Child(name = "contact", type = {ContactPoint.class}, order=24, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2377    @Description(shortDefinition="Details for human/organization for support", formalDefinition="Contact details for an organization or a particular human that is responsible for the device." )
2378    protected List<ContactPoint> contact;
2379
2380    /**
2381     * The place where the device can be found.
2382     */
2383    @Child(name = "location", type = {Location.class}, order=25, min=0, max=1, modifier=false, summary=false)
2384    @Description(shortDefinition="Where the device is found", formalDefinition="The place where the device can be found." )
2385    protected Reference location;
2386
2387    /**
2388     * A network address on which the device may be contacted directly.
2389     */
2390    @Child(name = "url", type = {UriType.class}, order=26, min=0, max=1, modifier=false, summary=false)
2391    @Description(shortDefinition="Network address to contact device", formalDefinition="A network address on which the device may be contacted directly." )
2392    protected UriType url;
2393
2394    /**
2395     * Technical endpoints providing access to services provided by the device defined at this resource.
2396     */
2397    @Child(name = "endpoint", type = {Endpoint.class}, order=27, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2398    @Description(shortDefinition="Technical endpoints providing access to electronic services provided by the device", formalDefinition="Technical endpoints providing access to services provided by the device defined at this resource." )
2399    protected List<Reference> endpoint;
2400
2401    /**
2402     * The linked device acting as a communication controller, data collector, translator, or concentrator for the current device (e.g., mobile phone application that relays a blood pressure device's data).
2403     */
2404    @Child(name = "gateway", type = {CodeableReference.class}, order=28, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2405    @Description(shortDefinition="Linked device acting as a communication/data collector, translator or controller", formalDefinition="The linked device acting as a communication controller, data collector, translator, or concentrator for the current device (e.g., mobile phone application that relays a blood pressure device's data)." )
2406    protected List<CodeableReference> gateway;
2407
2408    /**
2409     * Descriptive information, usage information or implantation information that is not captured in an existing element.
2410     */
2411    @Child(name = "note", type = {Annotation.class}, order=29, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2412    @Description(shortDefinition="Device notes and comments", formalDefinition="Descriptive information, usage information or implantation information that is not captured in an existing element." )
2413    protected List<Annotation> note;
2414
2415    /**
2416     * Provides additional safety characteristics about a medical device.  For example devices containing latex.
2417     */
2418    @Child(name = "safety", type = {CodeableConcept.class}, order=30, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
2419    @Description(shortDefinition="Safety Characteristics of Device", formalDefinition="Provides additional safety characteristics about a medical device.  For example devices containing latex." )
2420    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/device-safety")
2421    protected List<CodeableConcept> safety;
2422
2423    /**
2424     * The higher level or encompassing device that this device is a logical part of.
2425     */
2426    @Child(name = "parent", type = {Device.class}, order=31, min=0, max=1, modifier=false, summary=false)
2427    @Description(shortDefinition="The higher level or encompassing device that this device is a logical part of", formalDefinition="The higher level or encompassing device that this device is a logical part of." )
2428    protected Reference parent;
2429
2430    private static final long serialVersionUID = 2120085847L;
2431
2432  /**
2433   * Constructor
2434   */
2435    public Device() {
2436      super();
2437    }
2438
2439    /**
2440     * @return {@link #identifier} (Unique instance identifiers assigned to a device by manufacturers other organizations or owners.)
2441     */
2442    public List<Identifier> getIdentifier() { 
2443      if (this.identifier == null)
2444        this.identifier = new ArrayList<Identifier>();
2445      return this.identifier;
2446    }
2447
2448    /**
2449     * @return Returns a reference to <code>this</code> for easy method chaining
2450     */
2451    public Device setIdentifier(List<Identifier> theIdentifier) { 
2452      this.identifier = theIdentifier;
2453      return this;
2454    }
2455
2456    public boolean hasIdentifier() { 
2457      if (this.identifier == null)
2458        return false;
2459      for (Identifier item : this.identifier)
2460        if (!item.isEmpty())
2461          return true;
2462      return false;
2463    }
2464
2465    public Identifier addIdentifier() { //3
2466      Identifier t = new Identifier();
2467      if (this.identifier == null)
2468        this.identifier = new ArrayList<Identifier>();
2469      this.identifier.add(t);
2470      return t;
2471    }
2472
2473    public Device addIdentifier(Identifier t) { //3
2474      if (t == null)
2475        return this;
2476      if (this.identifier == null)
2477        this.identifier = new ArrayList<Identifier>();
2478      this.identifier.add(t);
2479      return this;
2480    }
2481
2482    /**
2483     * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist {3}
2484     */
2485    public Identifier getIdentifierFirstRep() { 
2486      if (getIdentifier().isEmpty()) {
2487        addIdentifier();
2488      }
2489      return getIdentifier().get(0);
2490    }
2491
2492    /**
2493     * @return {@link #displayName} (The name used to display by default when the device is referenced. Based on intent of use by the resource creator, this may reflect one of the names in Device.name, or may be another simple name.). This is the underlying object with id, value and extensions. The accessor "getDisplayName" gives direct access to the value
2494     */
2495    public StringType getDisplayNameElement() { 
2496      if (this.displayName == null)
2497        if (Configuration.errorOnAutoCreate())
2498          throw new Error("Attempt to auto-create Device.displayName");
2499        else if (Configuration.doAutoCreate())
2500          this.displayName = new StringType(); // bb
2501      return this.displayName;
2502    }
2503
2504    public boolean hasDisplayNameElement() { 
2505      return this.displayName != null && !this.displayName.isEmpty();
2506    }
2507
2508    public boolean hasDisplayName() { 
2509      return this.displayName != null && !this.displayName.isEmpty();
2510    }
2511
2512    /**
2513     * @param value {@link #displayName} (The name used to display by default when the device is referenced. Based on intent of use by the resource creator, this may reflect one of the names in Device.name, or may be another simple name.). This is the underlying object with id, value and extensions. The accessor "getDisplayName" gives direct access to the value
2514     */
2515    public Device setDisplayNameElement(StringType value) { 
2516      this.displayName = value;
2517      return this;
2518    }
2519
2520    /**
2521     * @return The name used to display by default when the device is referenced. Based on intent of use by the resource creator, this may reflect one of the names in Device.name, or may be another simple name.
2522     */
2523    public String getDisplayName() { 
2524      return this.displayName == null ? null : this.displayName.getValue();
2525    }
2526
2527    /**
2528     * @param value The name used to display by default when the device is referenced. Based on intent of use by the resource creator, this may reflect one of the names in Device.name, or may be another simple name.
2529     */
2530    public Device setDisplayName(String value) { 
2531      if (Utilities.noString(value))
2532        this.displayName = null;
2533      else {
2534        if (this.displayName == null)
2535          this.displayName = new StringType();
2536        this.displayName.setValue(value);
2537      }
2538      return this;
2539    }
2540
2541    /**
2542     * @return {@link #definition} (The reference to the definition for the device.)
2543     */
2544    public CodeableReference getDefinition() { 
2545      if (this.definition == null)
2546        if (Configuration.errorOnAutoCreate())
2547          throw new Error("Attempt to auto-create Device.definition");
2548        else if (Configuration.doAutoCreate())
2549          this.definition = new CodeableReference(); // cc
2550      return this.definition;
2551    }
2552
2553    public boolean hasDefinition() { 
2554      return this.definition != null && !this.definition.isEmpty();
2555    }
2556
2557    /**
2558     * @param value {@link #definition} (The reference to the definition for the device.)
2559     */
2560    public Device setDefinition(CodeableReference value) { 
2561      this.definition = value;
2562      return this;
2563    }
2564
2565    /**
2566     * @return {@link #udiCarrier} (Unique device identifier (UDI) assigned to device label or package.  Note that the Device may include multiple udiCarriers as it either may include just the udiCarrier for the jurisdiction it is sold, or for multiple jurisdictions it could have been sold.)
2567     */
2568    public List<DeviceUdiCarrierComponent> getUdiCarrier() { 
2569      if (this.udiCarrier == null)
2570        this.udiCarrier = new ArrayList<DeviceUdiCarrierComponent>();
2571      return this.udiCarrier;
2572    }
2573
2574    /**
2575     * @return Returns a reference to <code>this</code> for easy method chaining
2576     */
2577    public Device setUdiCarrier(List<DeviceUdiCarrierComponent> theUdiCarrier) { 
2578      this.udiCarrier = theUdiCarrier;
2579      return this;
2580    }
2581
2582    public boolean hasUdiCarrier() { 
2583      if (this.udiCarrier == null)
2584        return false;
2585      for (DeviceUdiCarrierComponent item : this.udiCarrier)
2586        if (!item.isEmpty())
2587          return true;
2588      return false;
2589    }
2590
2591    public DeviceUdiCarrierComponent addUdiCarrier() { //3
2592      DeviceUdiCarrierComponent t = new DeviceUdiCarrierComponent();
2593      if (this.udiCarrier == null)
2594        this.udiCarrier = new ArrayList<DeviceUdiCarrierComponent>();
2595      this.udiCarrier.add(t);
2596      return t;
2597    }
2598
2599    public Device addUdiCarrier(DeviceUdiCarrierComponent t) { //3
2600      if (t == null)
2601        return this;
2602      if (this.udiCarrier == null)
2603        this.udiCarrier = new ArrayList<DeviceUdiCarrierComponent>();
2604      this.udiCarrier.add(t);
2605      return this;
2606    }
2607
2608    /**
2609     * @return The first repetition of repeating field {@link #udiCarrier}, creating it if it does not already exist {3}
2610     */
2611    public DeviceUdiCarrierComponent getUdiCarrierFirstRep() { 
2612      if (getUdiCarrier().isEmpty()) {
2613        addUdiCarrier();
2614      }
2615      return getUdiCarrier().get(0);
2616    }
2617
2618    /**
2619     * @return {@link #status} (The Device record status. This is not the status of the device like availability.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value
2620     */
2621    public Enumeration<FHIRDeviceStatus> getStatusElement() { 
2622      if (this.status == null)
2623        if (Configuration.errorOnAutoCreate())
2624          throw new Error("Attempt to auto-create Device.status");
2625        else if (Configuration.doAutoCreate())
2626          this.status = new Enumeration<FHIRDeviceStatus>(new FHIRDeviceStatusEnumFactory()); // bb
2627      return this.status;
2628    }
2629
2630    public boolean hasStatusElement() { 
2631      return this.status != null && !this.status.isEmpty();
2632    }
2633
2634    public boolean hasStatus() { 
2635      return this.status != null && !this.status.isEmpty();
2636    }
2637
2638    /**
2639     * @param value {@link #status} (The Device record status. This is not the status of the device like availability.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value
2640     */
2641    public Device setStatusElement(Enumeration<FHIRDeviceStatus> value) { 
2642      this.status = value;
2643      return this;
2644    }
2645
2646    /**
2647     * @return The Device record status. This is not the status of the device like availability.
2648     */
2649    public FHIRDeviceStatus getStatus() { 
2650      return this.status == null ? null : this.status.getValue();
2651    }
2652
2653    /**
2654     * @param value The Device record status. This is not the status of the device like availability.
2655     */
2656    public Device setStatus(FHIRDeviceStatus value) { 
2657      if (value == null)
2658        this.status = null;
2659      else {
2660        if (this.status == null)
2661          this.status = new Enumeration<FHIRDeviceStatus>(new FHIRDeviceStatusEnumFactory());
2662        this.status.setValue(value);
2663      }
2664      return this;
2665    }
2666
2667    /**
2668     * @return {@link #availabilityStatus} (The availability of the device.)
2669     */
2670    public CodeableConcept getAvailabilityStatus() { 
2671      if (this.availabilityStatus == null)
2672        if (Configuration.errorOnAutoCreate())
2673          throw new Error("Attempt to auto-create Device.availabilityStatus");
2674        else if (Configuration.doAutoCreate())
2675          this.availabilityStatus = new CodeableConcept(); // cc
2676      return this.availabilityStatus;
2677    }
2678
2679    public boolean hasAvailabilityStatus() { 
2680      return this.availabilityStatus != null && !this.availabilityStatus.isEmpty();
2681    }
2682
2683    /**
2684     * @param value {@link #availabilityStatus} (The availability of the device.)
2685     */
2686    public Device setAvailabilityStatus(CodeableConcept value) { 
2687      this.availabilityStatus = value;
2688      return this;
2689    }
2690
2691    /**
2692     * @return {@link #biologicalSourceEvent} (An identifier that supports traceability to the event during which material in this product from one or more biological entities was obtained or pooled.)
2693     */
2694    public Identifier getBiologicalSourceEvent() { 
2695      if (this.biologicalSourceEvent == null)
2696        if (Configuration.errorOnAutoCreate())
2697          throw new Error("Attempt to auto-create Device.biologicalSourceEvent");
2698        else if (Configuration.doAutoCreate())
2699          this.biologicalSourceEvent = new Identifier(); // cc
2700      return this.biologicalSourceEvent;
2701    }
2702
2703    public boolean hasBiologicalSourceEvent() { 
2704      return this.biologicalSourceEvent != null && !this.biologicalSourceEvent.isEmpty();
2705    }
2706
2707    /**
2708     * @param value {@link #biologicalSourceEvent} (An identifier that supports traceability to the event during which material in this product from one or more biological entities was obtained or pooled.)
2709     */
2710    public Device setBiologicalSourceEvent(Identifier value) { 
2711      this.biologicalSourceEvent = value;
2712      return this;
2713    }
2714
2715    /**
2716     * @return {@link #manufacturer} (A name of the manufacturer or entity legally responsible for the device.). This is the underlying object with id, value and extensions. The accessor "getManufacturer" gives direct access to the value
2717     */
2718    public StringType getManufacturerElement() { 
2719      if (this.manufacturer == null)
2720        if (Configuration.errorOnAutoCreate())
2721          throw new Error("Attempt to auto-create Device.manufacturer");
2722        else if (Configuration.doAutoCreate())
2723          this.manufacturer = new StringType(); // bb
2724      return this.manufacturer;
2725    }
2726
2727    public boolean hasManufacturerElement() { 
2728      return this.manufacturer != null && !this.manufacturer.isEmpty();
2729    }
2730
2731    public boolean hasManufacturer() { 
2732      return this.manufacturer != null && !this.manufacturer.isEmpty();
2733    }
2734
2735    /**
2736     * @param value {@link #manufacturer} (A name of the manufacturer or entity legally responsible for the device.). This is the underlying object with id, value and extensions. The accessor "getManufacturer" gives direct access to the value
2737     */
2738    public Device setManufacturerElement(StringType value) { 
2739      this.manufacturer = value;
2740      return this;
2741    }
2742
2743    /**
2744     * @return A name of the manufacturer or entity legally responsible for the device.
2745     */
2746    public String getManufacturer() { 
2747      return this.manufacturer == null ? null : this.manufacturer.getValue();
2748    }
2749
2750    /**
2751     * @param value A name of the manufacturer or entity legally responsible for the device.
2752     */
2753    public Device setManufacturer(String value) { 
2754      if (Utilities.noString(value))
2755        this.manufacturer = null;
2756      else {
2757        if (this.manufacturer == null)
2758          this.manufacturer = new StringType();
2759        this.manufacturer.setValue(value);
2760      }
2761      return this;
2762    }
2763
2764    /**
2765     * @return {@link #manufactureDate} (The date and time when the device was manufactured.). This is the underlying object with id, value and extensions. The accessor "getManufactureDate" gives direct access to the value
2766     */
2767    public DateTimeType getManufactureDateElement() { 
2768      if (this.manufactureDate == null)
2769        if (Configuration.errorOnAutoCreate())
2770          throw new Error("Attempt to auto-create Device.manufactureDate");
2771        else if (Configuration.doAutoCreate())
2772          this.manufactureDate = new DateTimeType(); // bb
2773      return this.manufactureDate;
2774    }
2775
2776    public boolean hasManufactureDateElement() { 
2777      return this.manufactureDate != null && !this.manufactureDate.isEmpty();
2778    }
2779
2780    public boolean hasManufactureDate() { 
2781      return this.manufactureDate != null && !this.manufactureDate.isEmpty();
2782    }
2783
2784    /**
2785     * @param value {@link #manufactureDate} (The date and time when the device was manufactured.). This is the underlying object with id, value and extensions. The accessor "getManufactureDate" gives direct access to the value
2786     */
2787    public Device setManufactureDateElement(DateTimeType value) { 
2788      this.manufactureDate = value;
2789      return this;
2790    }
2791
2792    /**
2793     * @return The date and time when the device was manufactured.
2794     */
2795    public Date getManufactureDate() { 
2796      return this.manufactureDate == null ? null : this.manufactureDate.getValue();
2797    }
2798
2799    /**
2800     * @param value The date and time when the device was manufactured.
2801     */
2802    public Device setManufactureDate(Date value) { 
2803      if (value == null)
2804        this.manufactureDate = null;
2805      else {
2806        if (this.manufactureDate == null)
2807          this.manufactureDate = new DateTimeType();
2808        this.manufactureDate.setValue(value);
2809      }
2810      return this;
2811    }
2812
2813    /**
2814     * @return {@link #expirationDate} (The date and time beyond which this device is no longer valid or should not be used (if applicable).). This is the underlying object with id, value and extensions. The accessor "getExpirationDate" gives direct access to the value
2815     */
2816    public DateTimeType getExpirationDateElement() { 
2817      if (this.expirationDate == null)
2818        if (Configuration.errorOnAutoCreate())
2819          throw new Error("Attempt to auto-create Device.expirationDate");
2820        else if (Configuration.doAutoCreate())
2821          this.expirationDate = new DateTimeType(); // bb
2822      return this.expirationDate;
2823    }
2824
2825    public boolean hasExpirationDateElement() { 
2826      return this.expirationDate != null && !this.expirationDate.isEmpty();
2827    }
2828
2829    public boolean hasExpirationDate() { 
2830      return this.expirationDate != null && !this.expirationDate.isEmpty();
2831    }
2832
2833    /**
2834     * @param value {@link #expirationDate} (The date and time beyond which this device is no longer valid or should not be used (if applicable).). This is the underlying object with id, value and extensions. The accessor "getExpirationDate" gives direct access to the value
2835     */
2836    public Device setExpirationDateElement(DateTimeType value) { 
2837      this.expirationDate = value;
2838      return this;
2839    }
2840
2841    /**
2842     * @return The date and time beyond which this device is no longer valid or should not be used (if applicable).
2843     */
2844    public Date getExpirationDate() { 
2845      return this.expirationDate == null ? null : this.expirationDate.getValue();
2846    }
2847
2848    /**
2849     * @param value The date and time beyond which this device is no longer valid or should not be used (if applicable).
2850     */
2851    public Device setExpirationDate(Date value) { 
2852      if (value == null)
2853        this.expirationDate = null;
2854      else {
2855        if (this.expirationDate == null)
2856          this.expirationDate = new DateTimeType();
2857        this.expirationDate.setValue(value);
2858      }
2859      return this;
2860    }
2861
2862    /**
2863     * @return {@link #lotNumber} (Lot number assigned by the manufacturer.). This is the underlying object with id, value and extensions. The accessor "getLotNumber" gives direct access to the value
2864     */
2865    public StringType getLotNumberElement() { 
2866      if (this.lotNumber == null)
2867        if (Configuration.errorOnAutoCreate())
2868          throw new Error("Attempt to auto-create Device.lotNumber");
2869        else if (Configuration.doAutoCreate())
2870          this.lotNumber = new StringType(); // bb
2871      return this.lotNumber;
2872    }
2873
2874    public boolean hasLotNumberElement() { 
2875      return this.lotNumber != null && !this.lotNumber.isEmpty();
2876    }
2877
2878    public boolean hasLotNumber() { 
2879      return this.lotNumber != null && !this.lotNumber.isEmpty();
2880    }
2881
2882    /**
2883     * @param value {@link #lotNumber} (Lot number assigned by the manufacturer.). This is the underlying object with id, value and extensions. The accessor "getLotNumber" gives direct access to the value
2884     */
2885    public Device setLotNumberElement(StringType value) { 
2886      this.lotNumber = value;
2887      return this;
2888    }
2889
2890    /**
2891     * @return Lot number assigned by the manufacturer.
2892     */
2893    public String getLotNumber() { 
2894      return this.lotNumber == null ? null : this.lotNumber.getValue();
2895    }
2896
2897    /**
2898     * @param value Lot number assigned by the manufacturer.
2899     */
2900    public Device setLotNumber(String value) { 
2901      if (Utilities.noString(value))
2902        this.lotNumber = null;
2903      else {
2904        if (this.lotNumber == null)
2905          this.lotNumber = new StringType();
2906        this.lotNumber.setValue(value);
2907      }
2908      return this;
2909    }
2910
2911    /**
2912     * @return {@link #serialNumber} (The serial number assigned by the organization when the device was manufactured.). This is the underlying object with id, value and extensions. The accessor "getSerialNumber" gives direct access to the value
2913     */
2914    public StringType getSerialNumberElement() { 
2915      if (this.serialNumber == null)
2916        if (Configuration.errorOnAutoCreate())
2917          throw new Error("Attempt to auto-create Device.serialNumber");
2918        else if (Configuration.doAutoCreate())
2919          this.serialNumber = new StringType(); // bb
2920      return this.serialNumber;
2921    }
2922
2923    public boolean hasSerialNumberElement() { 
2924      return this.serialNumber != null && !this.serialNumber.isEmpty();
2925    }
2926
2927    public boolean hasSerialNumber() { 
2928      return this.serialNumber != null && !this.serialNumber.isEmpty();
2929    }
2930
2931    /**
2932     * @param value {@link #serialNumber} (The serial number assigned by the organization when the device was manufactured.). This is the underlying object with id, value and extensions. The accessor "getSerialNumber" gives direct access to the value
2933     */
2934    public Device setSerialNumberElement(StringType value) { 
2935      this.serialNumber = value;
2936      return this;
2937    }
2938
2939    /**
2940     * @return The serial number assigned by the organization when the device was manufactured.
2941     */
2942    public String getSerialNumber() { 
2943      return this.serialNumber == null ? null : this.serialNumber.getValue();
2944    }
2945
2946    /**
2947     * @param value The serial number assigned by the organization when the device was manufactured.
2948     */
2949    public Device setSerialNumber(String value) { 
2950      if (Utilities.noString(value))
2951        this.serialNumber = null;
2952      else {
2953        if (this.serialNumber == null)
2954          this.serialNumber = new StringType();
2955        this.serialNumber.setValue(value);
2956      }
2957      return this;
2958    }
2959
2960    /**
2961     * @return {@link #name} (This represents the manufacturer's name of the device as provided by the device, from a UDI label, or by a person describing the Device.  This typically would be used when a person provides the name(s) or when the device represents one of the names available from DeviceDefinition.)
2962     */
2963    public List<DeviceNameComponent> getName() { 
2964      if (this.name == null)
2965        this.name = new ArrayList<DeviceNameComponent>();
2966      return this.name;
2967    }
2968
2969    /**
2970     * @return Returns a reference to <code>this</code> for easy method chaining
2971     */
2972    public Device setName(List<DeviceNameComponent> theName) { 
2973      this.name = theName;
2974      return this;
2975    }
2976
2977    public boolean hasName() { 
2978      if (this.name == null)
2979        return false;
2980      for (DeviceNameComponent item : this.name)
2981        if (!item.isEmpty())
2982          return true;
2983      return false;
2984    }
2985
2986    public DeviceNameComponent addName() { //3
2987      DeviceNameComponent t = new DeviceNameComponent();
2988      if (this.name == null)
2989        this.name = new ArrayList<DeviceNameComponent>();
2990      this.name.add(t);
2991      return t;
2992    }
2993
2994    public Device addName(DeviceNameComponent t) { //3
2995      if (t == null)
2996        return this;
2997      if (this.name == null)
2998        this.name = new ArrayList<DeviceNameComponent>();
2999      this.name.add(t);
3000      return this;
3001    }
3002
3003    /**
3004     * @return The first repetition of repeating field {@link #name}, creating it if it does not already exist {3}
3005     */
3006    public DeviceNameComponent getNameFirstRep() { 
3007      if (getName().isEmpty()) {
3008        addName();
3009      }
3010      return getName().get(0);
3011    }
3012
3013    /**
3014     * @return {@link #modelNumber} (The manufacturer's model number for the device.). This is the underlying object with id, value and extensions. The accessor "getModelNumber" gives direct access to the value
3015     */
3016    public StringType getModelNumberElement() { 
3017      if (this.modelNumber == null)
3018        if (Configuration.errorOnAutoCreate())
3019          throw new Error("Attempt to auto-create Device.modelNumber");
3020        else if (Configuration.doAutoCreate())
3021          this.modelNumber = new StringType(); // bb
3022      return this.modelNumber;
3023    }
3024
3025    public boolean hasModelNumberElement() { 
3026      return this.modelNumber != null && !this.modelNumber.isEmpty();
3027    }
3028
3029    public boolean hasModelNumber() { 
3030      return this.modelNumber != null && !this.modelNumber.isEmpty();
3031    }
3032
3033    /**
3034     * @param value {@link #modelNumber} (The manufacturer's model number for the device.). This is the underlying object with id, value and extensions. The accessor "getModelNumber" gives direct access to the value
3035     */
3036    public Device setModelNumberElement(StringType value) { 
3037      this.modelNumber = value;
3038      return this;
3039    }
3040
3041    /**
3042     * @return The manufacturer's model number for the device.
3043     */
3044    public String getModelNumber() { 
3045      return this.modelNumber == null ? null : this.modelNumber.getValue();
3046    }
3047
3048    /**
3049     * @param value The manufacturer's model number for the device.
3050     */
3051    public Device setModelNumber(String value) { 
3052      if (Utilities.noString(value))
3053        this.modelNumber = null;
3054      else {
3055        if (this.modelNumber == null)
3056          this.modelNumber = new StringType();
3057        this.modelNumber.setValue(value);
3058      }
3059      return this;
3060    }
3061
3062    /**
3063     * @return {@link #partNumber} (The part number or catalog number of the device.). This is the underlying object with id, value and extensions. The accessor "getPartNumber" gives direct access to the value
3064     */
3065    public StringType getPartNumberElement() { 
3066      if (this.partNumber == null)
3067        if (Configuration.errorOnAutoCreate())
3068          throw new Error("Attempt to auto-create Device.partNumber");
3069        else if (Configuration.doAutoCreate())
3070          this.partNumber = new StringType(); // bb
3071      return this.partNumber;
3072    }
3073
3074    public boolean hasPartNumberElement() { 
3075      return this.partNumber != null && !this.partNumber.isEmpty();
3076    }
3077
3078    public boolean hasPartNumber() { 
3079      return this.partNumber != null && !this.partNumber.isEmpty();
3080    }
3081
3082    /**
3083     * @param value {@link #partNumber} (The part number or catalog number of the device.). This is the underlying object with id, value and extensions. The accessor "getPartNumber" gives direct access to the value
3084     */
3085    public Device setPartNumberElement(StringType value) { 
3086      this.partNumber = value;
3087      return this;
3088    }
3089
3090    /**
3091     * @return The part number or catalog number of the device.
3092     */
3093    public String getPartNumber() { 
3094      return this.partNumber == null ? null : this.partNumber.getValue();
3095    }
3096
3097    /**
3098     * @param value The part number or catalog number of the device.
3099     */
3100    public Device setPartNumber(String value) { 
3101      if (Utilities.noString(value))
3102        this.partNumber = null;
3103      else {
3104        if (this.partNumber == null)
3105          this.partNumber = new StringType();
3106        this.partNumber.setValue(value);
3107      }
3108      return this;
3109    }
3110
3111    /**
3112     * @return {@link #category} (Devices may be associated with one or more categories.)
3113     */
3114    public List<CodeableConcept> getCategory() { 
3115      if (this.category == null)
3116        this.category = new ArrayList<CodeableConcept>();
3117      return this.category;
3118    }
3119
3120    /**
3121     * @return Returns a reference to <code>this</code> for easy method chaining
3122     */
3123    public Device setCategory(List<CodeableConcept> theCategory) { 
3124      this.category = theCategory;
3125      return this;
3126    }
3127
3128    public boolean hasCategory() { 
3129      if (this.category == null)
3130        return false;
3131      for (CodeableConcept item : this.category)
3132        if (!item.isEmpty())
3133          return true;
3134      return false;
3135    }
3136
3137    public CodeableConcept addCategory() { //3
3138      CodeableConcept t = new CodeableConcept();
3139      if (this.category == null)
3140        this.category = new ArrayList<CodeableConcept>();
3141      this.category.add(t);
3142      return t;
3143    }
3144
3145    public Device addCategory(CodeableConcept t) { //3
3146      if (t == null)
3147        return this;
3148      if (this.category == null)
3149        this.category = new ArrayList<CodeableConcept>();
3150      this.category.add(t);
3151      return this;
3152    }
3153
3154    /**
3155     * @return The first repetition of repeating field {@link #category}, creating it if it does not already exist {3}
3156     */
3157    public CodeableConcept getCategoryFirstRep() { 
3158      if (getCategory().isEmpty()) {
3159        addCategory();
3160      }
3161      return getCategory().get(0);
3162    }
3163
3164    /**
3165     * @return {@link #type} (The kind or type of device. A device instance may have more than one type - in which case those are the types that apply to the specific instance of the device.)
3166     */
3167    public List<CodeableConcept> getType() { 
3168      if (this.type == null)
3169        this.type = new ArrayList<CodeableConcept>();
3170      return this.type;
3171    }
3172
3173    /**
3174     * @return Returns a reference to <code>this</code> for easy method chaining
3175     */
3176    public Device setType(List<CodeableConcept> theType) { 
3177      this.type = theType;
3178      return this;
3179    }
3180
3181    public boolean hasType() { 
3182      if (this.type == null)
3183        return false;
3184      for (CodeableConcept item : this.type)
3185        if (!item.isEmpty())
3186          return true;
3187      return false;
3188    }
3189
3190    public CodeableConcept addType() { //3
3191      CodeableConcept t = new CodeableConcept();
3192      if (this.type == null)
3193        this.type = new ArrayList<CodeableConcept>();
3194      this.type.add(t);
3195      return t;
3196    }
3197
3198    public Device addType(CodeableConcept t) { //3
3199      if (t == null)
3200        return this;
3201      if (this.type == null)
3202        this.type = new ArrayList<CodeableConcept>();
3203      this.type.add(t);
3204      return this;
3205    }
3206
3207    /**
3208     * @return The first repetition of repeating field {@link #type}, creating it if it does not already exist {3}
3209     */
3210    public CodeableConcept getTypeFirstRep() { 
3211      if (getType().isEmpty()) {
3212        addType();
3213      }
3214      return getType().get(0);
3215    }
3216
3217    /**
3218     * @return {@link #version} (The actual design of the device or software version running on the device.)
3219     */
3220    public List<DeviceVersionComponent> getVersion() { 
3221      if (this.version == null)
3222        this.version = new ArrayList<DeviceVersionComponent>();
3223      return this.version;
3224    }
3225
3226    /**
3227     * @return Returns a reference to <code>this</code> for easy method chaining
3228     */
3229    public Device setVersion(List<DeviceVersionComponent> theVersion) { 
3230      this.version = theVersion;
3231      return this;
3232    }
3233
3234    public boolean hasVersion() { 
3235      if (this.version == null)
3236        return false;
3237      for (DeviceVersionComponent item : this.version)
3238        if (!item.isEmpty())
3239          return true;
3240      return false;
3241    }
3242
3243    public DeviceVersionComponent addVersion() { //3
3244      DeviceVersionComponent t = new DeviceVersionComponent();
3245      if (this.version == null)
3246        this.version = new ArrayList<DeviceVersionComponent>();
3247      this.version.add(t);
3248      return t;
3249    }
3250
3251    public Device addVersion(DeviceVersionComponent t) { //3
3252      if (t == null)
3253        return this;
3254      if (this.version == null)
3255        this.version = new ArrayList<DeviceVersionComponent>();
3256      this.version.add(t);
3257      return this;
3258    }
3259
3260    /**
3261     * @return The first repetition of repeating field {@link #version}, creating it if it does not already exist {3}
3262     */
3263    public DeviceVersionComponent getVersionFirstRep() { 
3264      if (getVersion().isEmpty()) {
3265        addVersion();
3266      }
3267      return getVersion().get(0);
3268    }
3269
3270    /**
3271     * @return {@link #conformsTo} (Identifies the standards, specifications, or formal guidances for the capabilities supported by the device. The device may be certified as conformant to these specifications e.g., communication, performance, process, measurement, or specialization standards.)
3272     */
3273    public List<DeviceConformsToComponent> getConformsTo() { 
3274      if (this.conformsTo == null)
3275        this.conformsTo = new ArrayList<DeviceConformsToComponent>();
3276      return this.conformsTo;
3277    }
3278
3279    /**
3280     * @return Returns a reference to <code>this</code> for easy method chaining
3281     */
3282    public Device setConformsTo(List<DeviceConformsToComponent> theConformsTo) { 
3283      this.conformsTo = theConformsTo;
3284      return this;
3285    }
3286
3287    public boolean hasConformsTo() { 
3288      if (this.conformsTo == null)
3289        return false;
3290      for (DeviceConformsToComponent item : this.conformsTo)
3291        if (!item.isEmpty())
3292          return true;
3293      return false;
3294    }
3295
3296    public DeviceConformsToComponent addConformsTo() { //3
3297      DeviceConformsToComponent t = new DeviceConformsToComponent();
3298      if (this.conformsTo == null)
3299        this.conformsTo = new ArrayList<DeviceConformsToComponent>();
3300      this.conformsTo.add(t);
3301      return t;
3302    }
3303
3304    public Device addConformsTo(DeviceConformsToComponent t) { //3
3305      if (t == null)
3306        return this;
3307      if (this.conformsTo == null)
3308        this.conformsTo = new ArrayList<DeviceConformsToComponent>();
3309      this.conformsTo.add(t);
3310      return this;
3311    }
3312
3313    /**
3314     * @return The first repetition of repeating field {@link #conformsTo}, creating it if it does not already exist {3}
3315     */
3316    public DeviceConformsToComponent getConformsToFirstRep() { 
3317      if (getConformsTo().isEmpty()) {
3318        addConformsTo();
3319      }
3320      return getConformsTo().get(0);
3321    }
3322
3323    /**
3324     * @return {@link #property} (Static or essentially fixed characteristics or features of the device (e.g., time or timing attributes, resolution, accuracy, intended use or instructions for use, and physical attributes) that are not otherwise captured in more specific attributes.)
3325     */
3326    public List<DevicePropertyComponent> getProperty() { 
3327      if (this.property == null)
3328        this.property = new ArrayList<DevicePropertyComponent>();
3329      return this.property;
3330    }
3331
3332    /**
3333     * @return Returns a reference to <code>this</code> for easy method chaining
3334     */
3335    public Device setProperty(List<DevicePropertyComponent> theProperty) { 
3336      this.property = theProperty;
3337      return this;
3338    }
3339
3340    public boolean hasProperty() { 
3341      if (this.property == null)
3342        return false;
3343      for (DevicePropertyComponent item : this.property)
3344        if (!item.isEmpty())
3345          return true;
3346      return false;
3347    }
3348
3349    public DevicePropertyComponent addProperty() { //3
3350      DevicePropertyComponent t = new DevicePropertyComponent();
3351      if (this.property == null)
3352        this.property = new ArrayList<DevicePropertyComponent>();
3353      this.property.add(t);
3354      return t;
3355    }
3356
3357    public Device addProperty(DevicePropertyComponent t) { //3
3358      if (t == null)
3359        return this;
3360      if (this.property == null)
3361        this.property = new ArrayList<DevicePropertyComponent>();
3362      this.property.add(t);
3363      return this;
3364    }
3365
3366    /**
3367     * @return The first repetition of repeating field {@link #property}, creating it if it does not already exist {3}
3368     */
3369    public DevicePropertyComponent getPropertyFirstRep() { 
3370      if (getProperty().isEmpty()) {
3371        addProperty();
3372      }
3373      return getProperty().get(0);
3374    }
3375
3376    /**
3377     * @return {@link #mode} (The designated condition for performing a task with the device.)
3378     */
3379    public CodeableConcept getMode() { 
3380      if (this.mode == null)
3381        if (Configuration.errorOnAutoCreate())
3382          throw new Error("Attempt to auto-create Device.mode");
3383        else if (Configuration.doAutoCreate())
3384          this.mode = new CodeableConcept(); // cc
3385      return this.mode;
3386    }
3387
3388    public boolean hasMode() { 
3389      return this.mode != null && !this.mode.isEmpty();
3390    }
3391
3392    /**
3393     * @param value {@link #mode} (The designated condition for performing a task with the device.)
3394     */
3395    public Device setMode(CodeableConcept value) { 
3396      this.mode = value;
3397      return this;
3398    }
3399
3400    /**
3401     * @return {@link #cycle} (The series of occurrences that repeats during the operation of the device.)
3402     */
3403    public Count getCycle() { 
3404      if (this.cycle == null)
3405        if (Configuration.errorOnAutoCreate())
3406          throw new Error("Attempt to auto-create Device.cycle");
3407        else if (Configuration.doAutoCreate())
3408          this.cycle = new Count(); // cc
3409      return this.cycle;
3410    }
3411
3412    public boolean hasCycle() { 
3413      return this.cycle != null && !this.cycle.isEmpty();
3414    }
3415
3416    /**
3417     * @param value {@link #cycle} (The series of occurrences that repeats during the operation of the device.)
3418     */
3419    public Device setCycle(Count value) { 
3420      this.cycle = value;
3421      return this;
3422    }
3423
3424    /**
3425     * @return {@link #duration} (A measurement of time during the device's operation (e.g., days, hours, mins, etc.).)
3426     */
3427    public Duration getDuration() { 
3428      if (this.duration == null)
3429        if (Configuration.errorOnAutoCreate())
3430          throw new Error("Attempt to auto-create Device.duration");
3431        else if (Configuration.doAutoCreate())
3432          this.duration = new Duration(); // cc
3433      return this.duration;
3434    }
3435
3436    public boolean hasDuration() { 
3437      return this.duration != null && !this.duration.isEmpty();
3438    }
3439
3440    /**
3441     * @param value {@link #duration} (A measurement of time during the device's operation (e.g., days, hours, mins, etc.).)
3442     */
3443    public Device setDuration(Duration value) { 
3444      this.duration = value;
3445      return this;
3446    }
3447
3448    /**
3449     * @return {@link #owner} (An organization that is responsible for the provision and ongoing maintenance of the device.)
3450     */
3451    public Reference getOwner() { 
3452      if (this.owner == null)
3453        if (Configuration.errorOnAutoCreate())
3454          throw new Error("Attempt to auto-create Device.owner");
3455        else if (Configuration.doAutoCreate())
3456          this.owner = new Reference(); // cc
3457      return this.owner;
3458    }
3459
3460    public boolean hasOwner() { 
3461      return this.owner != null && !this.owner.isEmpty();
3462    }
3463
3464    /**
3465     * @param value {@link #owner} (An organization that is responsible for the provision and ongoing maintenance of the device.)
3466     */
3467    public Device setOwner(Reference value) { 
3468      this.owner = value;
3469      return this;
3470    }
3471
3472    /**
3473     * @return {@link #contact} (Contact details for an organization or a particular human that is responsible for the device.)
3474     */
3475    public List<ContactPoint> getContact() { 
3476      if (this.contact == null)
3477        this.contact = new ArrayList<ContactPoint>();
3478      return this.contact;
3479    }
3480
3481    /**
3482     * @return Returns a reference to <code>this</code> for easy method chaining
3483     */
3484    public Device setContact(List<ContactPoint> theContact) { 
3485      this.contact = theContact;
3486      return this;
3487    }
3488
3489    public boolean hasContact() { 
3490      if (this.contact == null)
3491        return false;
3492      for (ContactPoint item : this.contact)
3493        if (!item.isEmpty())
3494          return true;
3495      return false;
3496    }
3497
3498    public ContactPoint addContact() { //3
3499      ContactPoint t = new ContactPoint();
3500      if (this.contact == null)
3501        this.contact = new ArrayList<ContactPoint>();
3502      this.contact.add(t);
3503      return t;
3504    }
3505
3506    public Device addContact(ContactPoint t) { //3
3507      if (t == null)
3508        return this;
3509      if (this.contact == null)
3510        this.contact = new ArrayList<ContactPoint>();
3511      this.contact.add(t);
3512      return this;
3513    }
3514
3515    /**
3516     * @return The first repetition of repeating field {@link #contact}, creating it if it does not already exist {3}
3517     */
3518    public ContactPoint getContactFirstRep() { 
3519      if (getContact().isEmpty()) {
3520        addContact();
3521      }
3522      return getContact().get(0);
3523    }
3524
3525    /**
3526     * @return {@link #location} (The place where the device can be found.)
3527     */
3528    public Reference getLocation() { 
3529      if (this.location == null)
3530        if (Configuration.errorOnAutoCreate())
3531          throw new Error("Attempt to auto-create Device.location");
3532        else if (Configuration.doAutoCreate())
3533          this.location = new Reference(); // cc
3534      return this.location;
3535    }
3536
3537    public boolean hasLocation() { 
3538      return this.location != null && !this.location.isEmpty();
3539    }
3540
3541    /**
3542     * @param value {@link #location} (The place where the device can be found.)
3543     */
3544    public Device setLocation(Reference value) { 
3545      this.location = value;
3546      return this;
3547    }
3548
3549    /**
3550     * @return {@link #url} (A network address on which the device may be contacted directly.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
3551     */
3552    public UriType getUrlElement() { 
3553      if (this.url == null)
3554        if (Configuration.errorOnAutoCreate())
3555          throw new Error("Attempt to auto-create Device.url");
3556        else if (Configuration.doAutoCreate())
3557          this.url = new UriType(); // bb
3558      return this.url;
3559    }
3560
3561    public boolean hasUrlElement() { 
3562      return this.url != null && !this.url.isEmpty();
3563    }
3564
3565    public boolean hasUrl() { 
3566      return this.url != null && !this.url.isEmpty();
3567    }
3568
3569    /**
3570     * @param value {@link #url} (A network address on which the device may be contacted directly.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
3571     */
3572    public Device setUrlElement(UriType value) { 
3573      this.url = value;
3574      return this;
3575    }
3576
3577    /**
3578     * @return A network address on which the device may be contacted directly.
3579     */
3580    public String getUrl() { 
3581      return this.url == null ? null : this.url.getValue();
3582    }
3583
3584    /**
3585     * @param value A network address on which the device may be contacted directly.
3586     */
3587    public Device setUrl(String value) { 
3588      if (Utilities.noString(value))
3589        this.url = null;
3590      else {
3591        if (this.url == null)
3592          this.url = new UriType();
3593        this.url.setValue(value);
3594      }
3595      return this;
3596    }
3597
3598    /**
3599     * @return {@link #endpoint} (Technical endpoints providing access to services provided by the device defined at this resource.)
3600     */
3601    public List<Reference> getEndpoint() { 
3602      if (this.endpoint == null)
3603        this.endpoint = new ArrayList<Reference>();
3604      return this.endpoint;
3605    }
3606
3607    /**
3608     * @return Returns a reference to <code>this</code> for easy method chaining
3609     */
3610    public Device setEndpoint(List<Reference> theEndpoint) { 
3611      this.endpoint = theEndpoint;
3612      return this;
3613    }
3614
3615    public boolean hasEndpoint() { 
3616      if (this.endpoint == null)
3617        return false;
3618      for (Reference item : this.endpoint)
3619        if (!item.isEmpty())
3620          return true;
3621      return false;
3622    }
3623
3624    public Reference addEndpoint() { //3
3625      Reference t = new Reference();
3626      if (this.endpoint == null)
3627        this.endpoint = new ArrayList<Reference>();
3628      this.endpoint.add(t);
3629      return t;
3630    }
3631
3632    public Device addEndpoint(Reference t) { //3
3633      if (t == null)
3634        return this;
3635      if (this.endpoint == null)
3636        this.endpoint = new ArrayList<Reference>();
3637      this.endpoint.add(t);
3638      return this;
3639    }
3640
3641    /**
3642     * @return The first repetition of repeating field {@link #endpoint}, creating it if it does not already exist {3}
3643     */
3644    public Reference getEndpointFirstRep() { 
3645      if (getEndpoint().isEmpty()) {
3646        addEndpoint();
3647      }
3648      return getEndpoint().get(0);
3649    }
3650
3651    /**
3652     * @return {@link #gateway} (The linked device acting as a communication controller, data collector, translator, or concentrator for the current device (e.g., mobile phone application that relays a blood pressure device's data).)
3653     */
3654    public List<CodeableReference> getGateway() { 
3655      if (this.gateway == null)
3656        this.gateway = new ArrayList<CodeableReference>();
3657      return this.gateway;
3658    }
3659
3660    /**
3661     * @return Returns a reference to <code>this</code> for easy method chaining
3662     */
3663    public Device setGateway(List<CodeableReference> theGateway) { 
3664      this.gateway = theGateway;
3665      return this;
3666    }
3667
3668    public boolean hasGateway() { 
3669      if (this.gateway == null)
3670        return false;
3671      for (CodeableReference item : this.gateway)
3672        if (!item.isEmpty())
3673          return true;
3674      return false;
3675    }
3676
3677    public CodeableReference addGateway() { //3
3678      CodeableReference t = new CodeableReference();
3679      if (this.gateway == null)
3680        this.gateway = new ArrayList<CodeableReference>();
3681      this.gateway.add(t);
3682      return t;
3683    }
3684
3685    public Device addGateway(CodeableReference t) { //3
3686      if (t == null)
3687        return this;
3688      if (this.gateway == null)
3689        this.gateway = new ArrayList<CodeableReference>();
3690      this.gateway.add(t);
3691      return this;
3692    }
3693
3694    /**
3695     * @return The first repetition of repeating field {@link #gateway}, creating it if it does not already exist {3}
3696     */
3697    public CodeableReference getGatewayFirstRep() { 
3698      if (getGateway().isEmpty()) {
3699        addGateway();
3700      }
3701      return getGateway().get(0);
3702    }
3703
3704    /**
3705     * @return {@link #note} (Descriptive information, usage information or implantation information that is not captured in an existing element.)
3706     */
3707    public List<Annotation> getNote() { 
3708      if (this.note == null)
3709        this.note = new ArrayList<Annotation>();
3710      return this.note;
3711    }
3712
3713    /**
3714     * @return Returns a reference to <code>this</code> for easy method chaining
3715     */
3716    public Device setNote(List<Annotation> theNote) { 
3717      this.note = theNote;
3718      return this;
3719    }
3720
3721    public boolean hasNote() { 
3722      if (this.note == null)
3723        return false;
3724      for (Annotation item : this.note)
3725        if (!item.isEmpty())
3726          return true;
3727      return false;
3728    }
3729
3730    public Annotation addNote() { //3
3731      Annotation t = new Annotation();
3732      if (this.note == null)
3733        this.note = new ArrayList<Annotation>();
3734      this.note.add(t);
3735      return t;
3736    }
3737
3738    public Device addNote(Annotation t) { //3
3739      if (t == null)
3740        return this;
3741      if (this.note == null)
3742        this.note = new ArrayList<Annotation>();
3743      this.note.add(t);
3744      return this;
3745    }
3746
3747    /**
3748     * @return The first repetition of repeating field {@link #note}, creating it if it does not already exist {3}
3749     */
3750    public Annotation getNoteFirstRep() { 
3751      if (getNote().isEmpty()) {
3752        addNote();
3753      }
3754      return getNote().get(0);
3755    }
3756
3757    /**
3758     * @return {@link #safety} (Provides additional safety characteristics about a medical device.  For example devices containing latex.)
3759     */
3760    public List<CodeableConcept> getSafety() { 
3761      if (this.safety == null)
3762        this.safety = new ArrayList<CodeableConcept>();
3763      return this.safety;
3764    }
3765
3766    /**
3767     * @return Returns a reference to <code>this</code> for easy method chaining
3768     */
3769    public Device setSafety(List<CodeableConcept> theSafety) { 
3770      this.safety = theSafety;
3771      return this;
3772    }
3773
3774    public boolean hasSafety() { 
3775      if (this.safety == null)
3776        return false;
3777      for (CodeableConcept item : this.safety)
3778        if (!item.isEmpty())
3779          return true;
3780      return false;
3781    }
3782
3783    public CodeableConcept addSafety() { //3
3784      CodeableConcept t = new CodeableConcept();
3785      if (this.safety == null)
3786        this.safety = new ArrayList<CodeableConcept>();
3787      this.safety.add(t);
3788      return t;
3789    }
3790
3791    public Device addSafety(CodeableConcept t) { //3
3792      if (t == null)
3793        return this;
3794      if (this.safety == null)
3795        this.safety = new ArrayList<CodeableConcept>();
3796      this.safety.add(t);
3797      return this;
3798    }
3799
3800    /**
3801     * @return The first repetition of repeating field {@link #safety}, creating it if it does not already exist {3}
3802     */
3803    public CodeableConcept getSafetyFirstRep() { 
3804      if (getSafety().isEmpty()) {
3805        addSafety();
3806      }
3807      return getSafety().get(0);
3808    }
3809
3810    /**
3811     * @return {@link #parent} (The higher level or encompassing device that this device is a logical part of.)
3812     */
3813    public Reference getParent() { 
3814      if (this.parent == null)
3815        if (Configuration.errorOnAutoCreate())
3816          throw new Error("Attempt to auto-create Device.parent");
3817        else if (Configuration.doAutoCreate())
3818          this.parent = new Reference(); // cc
3819      return this.parent;
3820    }
3821
3822    public boolean hasParent() { 
3823      return this.parent != null && !this.parent.isEmpty();
3824    }
3825
3826    /**
3827     * @param value {@link #parent} (The higher level or encompassing device that this device is a logical part of.)
3828     */
3829    public Device setParent(Reference value) { 
3830      this.parent = value;
3831      return this;
3832    }
3833
3834      protected void listChildren(List<Property> children) {
3835        super.listChildren(children);
3836        children.add(new Property("identifier", "Identifier", "Unique instance identifiers assigned to a device by manufacturers other organizations or owners.", 0, java.lang.Integer.MAX_VALUE, identifier));
3837        children.add(new Property("displayName", "string", "The name used to display by default when the device is referenced. Based on intent of use by the resource creator, this may reflect one of the names in Device.name, or may be another simple name.", 0, 1, displayName));
3838        children.add(new Property("definition", "CodeableReference(DeviceDefinition)", "The reference to the definition for the device.", 0, 1, definition));
3839        children.add(new Property("udiCarrier", "", "Unique device identifier (UDI) assigned to device label or package.  Note that the Device may include multiple udiCarriers as it either may include just the udiCarrier for the jurisdiction it is sold, or for multiple jurisdictions it could have been sold.", 0, java.lang.Integer.MAX_VALUE, udiCarrier));
3840        children.add(new Property("status", "code", "The Device record status. This is not the status of the device like availability.", 0, 1, status));
3841        children.add(new Property("availabilityStatus", "CodeableConcept", "The availability of the device.", 0, 1, availabilityStatus));
3842        children.add(new Property("biologicalSourceEvent", "Identifier", "An identifier that supports traceability to the event during which material in this product from one or more biological entities was obtained or pooled.", 0, 1, biologicalSourceEvent));
3843        children.add(new Property("manufacturer", "string", "A name of the manufacturer or entity legally responsible for the device.", 0, 1, manufacturer));
3844        children.add(new Property("manufactureDate", "dateTime", "The date and time when the device was manufactured.", 0, 1, manufactureDate));
3845        children.add(new Property("expirationDate", "dateTime", "The date and time beyond which this device is no longer valid or should not be used (if applicable).", 0, 1, expirationDate));
3846        children.add(new Property("lotNumber", "string", "Lot number assigned by the manufacturer.", 0, 1, lotNumber));
3847        children.add(new Property("serialNumber", "string", "The serial number assigned by the organization when the device was manufactured.", 0, 1, serialNumber));
3848        children.add(new Property("name", "", "This represents the manufacturer's name of the device as provided by the device, from a UDI label, or by a person describing the Device.  This typically would be used when a person provides the name(s) or when the device represents one of the names available from DeviceDefinition.", 0, java.lang.Integer.MAX_VALUE, name));
3849        children.add(new Property("modelNumber", "string", "The manufacturer's model number for the device.", 0, 1, modelNumber));
3850        children.add(new Property("partNumber", "string", "The part number or catalog number of the device.", 0, 1, partNumber));
3851        children.add(new Property("category", "CodeableConcept", "Devices may be associated with one or more categories.", 0, java.lang.Integer.MAX_VALUE, category));
3852        children.add(new Property("type", "CodeableConcept", "The kind or type of device. A device instance may have more than one type - in which case those are the types that apply to the specific instance of the device.", 0, java.lang.Integer.MAX_VALUE, type));
3853        children.add(new Property("version", "", "The actual design of the device or software version running on the device.", 0, java.lang.Integer.MAX_VALUE, version));
3854        children.add(new Property("conformsTo", "", "Identifies the standards, specifications, or formal guidances for the capabilities supported by the device. The device may be certified as conformant to these specifications e.g., communication, performance, process, measurement, or specialization standards.", 0, java.lang.Integer.MAX_VALUE, conformsTo));
3855        children.add(new Property("property", "", "Static or essentially fixed characteristics or features of the device (e.g., time or timing attributes, resolution, accuracy, intended use or instructions for use, and physical attributes) that are not otherwise captured in more specific attributes.", 0, java.lang.Integer.MAX_VALUE, property));
3856        children.add(new Property("mode", "CodeableConcept", "The designated condition for performing a task with the device.", 0, 1, mode));
3857        children.add(new Property("cycle", "Count", "The series of occurrences that repeats during the operation of the device.", 0, 1, cycle));
3858        children.add(new Property("duration", "Duration", "A measurement of time during the device's operation (e.g., days, hours, mins, etc.).", 0, 1, duration));
3859        children.add(new Property("owner", "Reference(Organization)", "An organization that is responsible for the provision and ongoing maintenance of the device.", 0, 1, owner));
3860        children.add(new Property("contact", "ContactPoint", "Contact details for an organization or a particular human that is responsible for the device.", 0, java.lang.Integer.MAX_VALUE, contact));
3861        children.add(new Property("location", "Reference(Location)", "The place where the device can be found.", 0, 1, location));
3862        children.add(new Property("url", "uri", "A network address on which the device may be contacted directly.", 0, 1, url));
3863        children.add(new Property("endpoint", "Reference(Endpoint)", "Technical endpoints providing access to services provided by the device defined at this resource.", 0, java.lang.Integer.MAX_VALUE, endpoint));
3864        children.add(new Property("gateway", "CodeableReference(Device)", "The linked device acting as a communication controller, data collector, translator, or concentrator for the current device (e.g., mobile phone application that relays a blood pressure device's data).", 0, java.lang.Integer.MAX_VALUE, gateway));
3865        children.add(new Property("note", "Annotation", "Descriptive information, usage information or implantation information that is not captured in an existing element.", 0, java.lang.Integer.MAX_VALUE, note));
3866        children.add(new Property("safety", "CodeableConcept", "Provides additional safety characteristics about a medical device.  For example devices containing latex.", 0, java.lang.Integer.MAX_VALUE, safety));
3867        children.add(new Property("parent", "Reference(Device)", "The higher level or encompassing device that this device is a logical part of.", 0, 1, parent));
3868      }
3869
3870      @Override
3871      public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
3872        switch (_hash) {
3873        case -1618432855: /*identifier*/  return new Property("identifier", "Identifier", "Unique instance identifiers assigned to a device by manufacturers other organizations or owners.", 0, java.lang.Integer.MAX_VALUE, identifier);
3874        case 1714148973: /*displayName*/  return new Property("displayName", "string", "The name used to display by default when the device is referenced. Based on intent of use by the resource creator, this may reflect one of the names in Device.name, or may be another simple name.", 0, 1, displayName);
3875        case -1014418093: /*definition*/  return new Property("definition", "CodeableReference(DeviceDefinition)", "The reference to the definition for the device.", 0, 1, definition);
3876        case -1343558178: /*udiCarrier*/  return new Property("udiCarrier", "", "Unique device identifier (UDI) assigned to device label or package.  Note that the Device may include multiple udiCarriers as it either may include just the udiCarrier for the jurisdiction it is sold, or for multiple jurisdictions it could have been sold.", 0, java.lang.Integer.MAX_VALUE, udiCarrier);
3877        case -892481550: /*status*/  return new Property("status", "code", "The Device record status. This is not the status of the device like availability.", 0, 1, status);
3878        case 804659501: /*availabilityStatus*/  return new Property("availabilityStatus", "CodeableConcept", "The availability of the device.", 0, 1, availabilityStatus);
3879        case -654468482: /*biologicalSourceEvent*/  return new Property("biologicalSourceEvent", "Identifier", "An identifier that supports traceability to the event during which material in this product from one or more biological entities was obtained or pooled.", 0, 1, biologicalSourceEvent);
3880        case -1969347631: /*manufacturer*/  return new Property("manufacturer", "string", "A name of the manufacturer or entity legally responsible for the device.", 0, 1, manufacturer);
3881        case 416714767: /*manufactureDate*/  return new Property("manufactureDate", "dateTime", "The date and time when the device was manufactured.", 0, 1, manufactureDate);
3882        case -668811523: /*expirationDate*/  return new Property("expirationDate", "dateTime", "The date and time beyond which this device is no longer valid or should not be used (if applicable).", 0, 1, expirationDate);
3883        case 462547450: /*lotNumber*/  return new Property("lotNumber", "string", "Lot number assigned by the manufacturer.", 0, 1, lotNumber);
3884        case 83787357: /*serialNumber*/  return new Property("serialNumber", "string", "The serial number assigned by the organization when the device was manufactured.", 0, 1, serialNumber);
3885        case 3373707: /*name*/  return new Property("name", "", "This represents the manufacturer's name of the device as provided by the device, from a UDI label, or by a person describing the Device.  This typically would be used when a person provides the name(s) or when the device represents one of the names available from DeviceDefinition.", 0, java.lang.Integer.MAX_VALUE, name);
3886        case 346619858: /*modelNumber*/  return new Property("modelNumber", "string", "The manufacturer's model number for the device.", 0, 1, modelNumber);
3887        case -731502308: /*partNumber*/  return new Property("partNumber", "string", "The part number or catalog number of the device.", 0, 1, partNumber);
3888        case 50511102: /*category*/  return new Property("category", "CodeableConcept", "Devices may be associated with one or more categories.", 0, java.lang.Integer.MAX_VALUE, category);
3889        case 3575610: /*type*/  return new Property("type", "CodeableConcept", "The kind or type of device. A device instance may have more than one type - in which case those are the types that apply to the specific instance of the device.", 0, java.lang.Integer.MAX_VALUE, type);
3890        case 351608024: /*version*/  return new Property("version", "", "The actual design of the device or software version running on the device.", 0, java.lang.Integer.MAX_VALUE, version);
3891        case 1014198088: /*conformsTo*/  return new Property("conformsTo", "", "Identifies the standards, specifications, or formal guidances for the capabilities supported by the device. The device may be certified as conformant to these specifications e.g., communication, performance, process, measurement, or specialization standards.", 0, java.lang.Integer.MAX_VALUE, conformsTo);
3892        case -993141291: /*property*/  return new Property("property", "", "Static or essentially fixed characteristics or features of the device (e.g., time or timing attributes, resolution, accuracy, intended use or instructions for use, and physical attributes) that are not otherwise captured in more specific attributes.", 0, java.lang.Integer.MAX_VALUE, property);
3893        case 3357091: /*mode*/  return new Property("mode", "CodeableConcept", "The designated condition for performing a task with the device.", 0, 1, mode);
3894        case 95131878: /*cycle*/  return new Property("cycle", "Count", "The series of occurrences that repeats during the operation of the device.", 0, 1, cycle);
3895        case -1992012396: /*duration*/  return new Property("duration", "Duration", "A measurement of time during the device's operation (e.g., days, hours, mins, etc.).", 0, 1, duration);
3896        case 106164915: /*owner*/  return new Property("owner", "Reference(Organization)", "An organization that is responsible for the provision and ongoing maintenance of the device.", 0, 1, owner);
3897        case 951526432: /*contact*/  return new Property("contact", "ContactPoint", "Contact details for an organization or a particular human that is responsible for the device.", 0, java.lang.Integer.MAX_VALUE, contact);
3898        case 1901043637: /*location*/  return new Property("location", "Reference(Location)", "The place where the device can be found.", 0, 1, location);
3899        case 116079: /*url*/  return new Property("url", "uri", "A network address on which the device may be contacted directly.", 0, 1, url);
3900        case 1741102485: /*endpoint*/  return new Property("endpoint", "Reference(Endpoint)", "Technical endpoints providing access to services provided by the device defined at this resource.", 0, java.lang.Integer.MAX_VALUE, endpoint);
3901        case -189118908: /*gateway*/  return new Property("gateway", "CodeableReference(Device)", "The linked device acting as a communication controller, data collector, translator, or concentrator for the current device (e.g., mobile phone application that relays a blood pressure device's data).", 0, java.lang.Integer.MAX_VALUE, gateway);
3902        case 3387378: /*note*/  return new Property("note", "Annotation", "Descriptive information, usage information or implantation information that is not captured in an existing element.", 0, java.lang.Integer.MAX_VALUE, note);
3903        case -909893934: /*safety*/  return new Property("safety", "CodeableConcept", "Provides additional safety characteristics about a medical device.  For example devices containing latex.", 0, java.lang.Integer.MAX_VALUE, safety);
3904        case -995424086: /*parent*/  return new Property("parent", "Reference(Device)", "The higher level or encompassing device that this device is a logical part of.", 0, 1, parent);
3905        default: return super.getNamedProperty(_hash, _name, _checkValid);
3906        }
3907
3908      }
3909
3910      @Override
3911      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3912        switch (hash) {
3913        case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier
3914        case 1714148973: /*displayName*/ return this.displayName == null ? new Base[0] : new Base[] {this.displayName}; // StringType
3915        case -1014418093: /*definition*/ return this.definition == null ? new Base[0] : new Base[] {this.definition}; // CodeableReference
3916        case -1343558178: /*udiCarrier*/ return this.udiCarrier == null ? new Base[0] : this.udiCarrier.toArray(new Base[this.udiCarrier.size()]); // DeviceUdiCarrierComponent
3917        case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<FHIRDeviceStatus>
3918        case 804659501: /*availabilityStatus*/ return this.availabilityStatus == null ? new Base[0] : new Base[] {this.availabilityStatus}; // CodeableConcept
3919        case -654468482: /*biologicalSourceEvent*/ return this.biologicalSourceEvent == null ? new Base[0] : new Base[] {this.biologicalSourceEvent}; // Identifier
3920        case -1969347631: /*manufacturer*/ return this.manufacturer == null ? new Base[0] : new Base[] {this.manufacturer}; // StringType
3921        case 416714767: /*manufactureDate*/ return this.manufactureDate == null ? new Base[0] : new Base[] {this.manufactureDate}; // DateTimeType
3922        case -668811523: /*expirationDate*/ return this.expirationDate == null ? new Base[0] : new Base[] {this.expirationDate}; // DateTimeType
3923        case 462547450: /*lotNumber*/ return this.lotNumber == null ? new Base[0] : new Base[] {this.lotNumber}; // StringType
3924        case 83787357: /*serialNumber*/ return this.serialNumber == null ? new Base[0] : new Base[] {this.serialNumber}; // StringType
3925        case 3373707: /*name*/ return this.name == null ? new Base[0] : this.name.toArray(new Base[this.name.size()]); // DeviceNameComponent
3926        case 346619858: /*modelNumber*/ return this.modelNumber == null ? new Base[0] : new Base[] {this.modelNumber}; // StringType
3927        case -731502308: /*partNumber*/ return this.partNumber == null ? new Base[0] : new Base[] {this.partNumber}; // StringType
3928        case 50511102: /*category*/ return this.category == null ? new Base[0] : this.category.toArray(new Base[this.category.size()]); // CodeableConcept
3929        case 3575610: /*type*/ return this.type == null ? new Base[0] : this.type.toArray(new Base[this.type.size()]); // CodeableConcept
3930        case 351608024: /*version*/ return this.version == null ? new Base[0] : this.version.toArray(new Base[this.version.size()]); // DeviceVersionComponent
3931        case 1014198088: /*conformsTo*/ return this.conformsTo == null ? new Base[0] : this.conformsTo.toArray(new Base[this.conformsTo.size()]); // DeviceConformsToComponent
3932        case -993141291: /*property*/ return this.property == null ? new Base[0] : this.property.toArray(new Base[this.property.size()]); // DevicePropertyComponent
3933        case 3357091: /*mode*/ return this.mode == null ? new Base[0] : new Base[] {this.mode}; // CodeableConcept
3934        case 95131878: /*cycle*/ return this.cycle == null ? new Base[0] : new Base[] {this.cycle}; // Count
3935        case -1992012396: /*duration*/ return this.duration == null ? new Base[0] : new Base[] {this.duration}; // Duration
3936        case 106164915: /*owner*/ return this.owner == null ? new Base[0] : new Base[] {this.owner}; // Reference
3937        case 951526432: /*contact*/ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactPoint
3938        case 1901043637: /*location*/ return this.location == null ? new Base[0] : new Base[] {this.location}; // Reference
3939        case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType
3940        case 1741102485: /*endpoint*/ return this.endpoint == null ? new Base[0] : this.endpoint.toArray(new Base[this.endpoint.size()]); // Reference
3941        case -189118908: /*gateway*/ return this.gateway == null ? new Base[0] : this.gateway.toArray(new Base[this.gateway.size()]); // CodeableReference
3942        case 3387378: /*note*/ return this.note == null ? new Base[0] : this.note.toArray(new Base[this.note.size()]); // Annotation
3943        case -909893934: /*safety*/ return this.safety == null ? new Base[0] : this.safety.toArray(new Base[this.safety.size()]); // CodeableConcept
3944        case -995424086: /*parent*/ return this.parent == null ? new Base[0] : new Base[] {this.parent}; // Reference
3945        default: return super.getProperty(hash, name, checkValid);
3946        }
3947
3948      }
3949
3950      @Override
3951      public Base setProperty(int hash, String name, Base value) throws FHIRException {
3952        switch (hash) {
3953        case -1618432855: // identifier
3954          this.getIdentifier().add(TypeConvertor.castToIdentifier(value)); // Identifier
3955          return value;
3956        case 1714148973: // displayName
3957          this.displayName = TypeConvertor.castToString(value); // StringType
3958          return value;
3959        case -1014418093: // definition
3960          this.definition = TypeConvertor.castToCodeableReference(value); // CodeableReference
3961          return value;
3962        case -1343558178: // udiCarrier
3963          this.getUdiCarrier().add((DeviceUdiCarrierComponent) value); // DeviceUdiCarrierComponent
3964          return value;
3965        case -892481550: // status
3966          value = new FHIRDeviceStatusEnumFactory().fromType(TypeConvertor.castToCode(value));
3967          this.status = (Enumeration) value; // Enumeration<FHIRDeviceStatus>
3968          return value;
3969        case 804659501: // availabilityStatus
3970          this.availabilityStatus = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
3971          return value;
3972        case -654468482: // biologicalSourceEvent
3973          this.biologicalSourceEvent = TypeConvertor.castToIdentifier(value); // Identifier
3974          return value;
3975        case -1969347631: // manufacturer
3976          this.manufacturer = TypeConvertor.castToString(value); // StringType
3977          return value;
3978        case 416714767: // manufactureDate
3979          this.manufactureDate = TypeConvertor.castToDateTime(value); // DateTimeType
3980          return value;
3981        case -668811523: // expirationDate
3982          this.expirationDate = TypeConvertor.castToDateTime(value); // DateTimeType
3983          return value;
3984        case 462547450: // lotNumber
3985          this.lotNumber = TypeConvertor.castToString(value); // StringType
3986          return value;
3987        case 83787357: // serialNumber
3988          this.serialNumber = TypeConvertor.castToString(value); // StringType
3989          return value;
3990        case 3373707: // name
3991          this.getName().add((DeviceNameComponent) value); // DeviceNameComponent
3992          return value;
3993        case 346619858: // modelNumber
3994          this.modelNumber = TypeConvertor.castToString(value); // StringType
3995          return value;
3996        case -731502308: // partNumber
3997          this.partNumber = TypeConvertor.castToString(value); // StringType
3998          return value;
3999        case 50511102: // category
4000          this.getCategory().add(TypeConvertor.castToCodeableConcept(value)); // CodeableConcept
4001          return value;
4002        case 3575610: // type
4003          this.getType().add(TypeConvertor.castToCodeableConcept(value)); // CodeableConcept
4004          return value;
4005        case 351608024: // version
4006          this.getVersion().add((DeviceVersionComponent) value); // DeviceVersionComponent
4007          return value;
4008        case 1014198088: // conformsTo
4009          this.getConformsTo().add((DeviceConformsToComponent) value); // DeviceConformsToComponent
4010          return value;
4011        case -993141291: // property
4012          this.getProperty().add((DevicePropertyComponent) value); // DevicePropertyComponent
4013          return value;
4014        case 3357091: // mode
4015          this.mode = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
4016          return value;
4017        case 95131878: // cycle
4018          this.cycle = TypeConvertor.castToCount(value); // Count
4019          return value;
4020        case -1992012396: // duration
4021          this.duration = TypeConvertor.castToDuration(value); // Duration
4022          return value;
4023        case 106164915: // owner
4024          this.owner = TypeConvertor.castToReference(value); // Reference
4025          return value;
4026        case 951526432: // contact
4027          this.getContact().add(TypeConvertor.castToContactPoint(value)); // ContactPoint
4028          return value;
4029        case 1901043637: // location
4030          this.location = TypeConvertor.castToReference(value); // Reference
4031          return value;
4032        case 116079: // url
4033          this.url = TypeConvertor.castToUri(value); // UriType
4034          return value;
4035        case 1741102485: // endpoint
4036          this.getEndpoint().add(TypeConvertor.castToReference(value)); // Reference
4037          return value;
4038        case -189118908: // gateway
4039          this.getGateway().add(TypeConvertor.castToCodeableReference(value)); // CodeableReference
4040          return value;
4041        case 3387378: // note
4042          this.getNote().add(TypeConvertor.castToAnnotation(value)); // Annotation
4043          return value;
4044        case -909893934: // safety
4045          this.getSafety().add(TypeConvertor.castToCodeableConcept(value)); // CodeableConcept
4046          return value;
4047        case -995424086: // parent
4048          this.parent = TypeConvertor.castToReference(value); // Reference
4049          return value;
4050        default: return super.setProperty(hash, name, value);
4051        }
4052
4053      }
4054
4055      @Override
4056      public Base setProperty(String name, Base value) throws FHIRException {
4057        if (name.equals("identifier")) {
4058          this.getIdentifier().add(TypeConvertor.castToIdentifier(value));
4059        } else if (name.equals("displayName")) {
4060          this.displayName = TypeConvertor.castToString(value); // StringType
4061        } else if (name.equals("definition")) {
4062          this.definition = TypeConvertor.castToCodeableReference(value); // CodeableReference
4063        } else if (name.equals("udiCarrier")) {
4064          this.getUdiCarrier().add((DeviceUdiCarrierComponent) value);
4065        } else if (name.equals("status")) {
4066          value = new FHIRDeviceStatusEnumFactory().fromType(TypeConvertor.castToCode(value));
4067          this.status = (Enumeration) value; // Enumeration<FHIRDeviceStatus>
4068        } else if (name.equals("availabilityStatus")) {
4069          this.availabilityStatus = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
4070        } else if (name.equals("biologicalSourceEvent")) {
4071          this.biologicalSourceEvent = TypeConvertor.castToIdentifier(value); // Identifier
4072        } else if (name.equals("manufacturer")) {
4073          this.manufacturer = TypeConvertor.castToString(value); // StringType
4074        } else if (name.equals("manufactureDate")) {
4075          this.manufactureDate = TypeConvertor.castToDateTime(value); // DateTimeType
4076        } else if (name.equals("expirationDate")) {
4077          this.expirationDate = TypeConvertor.castToDateTime(value); // DateTimeType
4078        } else if (name.equals("lotNumber")) {
4079          this.lotNumber = TypeConvertor.castToString(value); // StringType
4080        } else if (name.equals("serialNumber")) {
4081          this.serialNumber = TypeConvertor.castToString(value); // StringType
4082        } else if (name.equals("name")) {
4083          this.getName().add((DeviceNameComponent) value);
4084        } else if (name.equals("modelNumber")) {
4085          this.modelNumber = TypeConvertor.castToString(value); // StringType
4086        } else if (name.equals("partNumber")) {
4087          this.partNumber = TypeConvertor.castToString(value); // StringType
4088        } else if (name.equals("category")) {
4089          this.getCategory().add(TypeConvertor.castToCodeableConcept(value));
4090        } else if (name.equals("type")) {
4091          this.getType().add(TypeConvertor.castToCodeableConcept(value));
4092        } else if (name.equals("version")) {
4093          this.getVersion().add((DeviceVersionComponent) value);
4094        } else if (name.equals("conformsTo")) {
4095          this.getConformsTo().add((DeviceConformsToComponent) value);
4096        } else if (name.equals("property")) {
4097          this.getProperty().add((DevicePropertyComponent) value);
4098        } else if (name.equals("mode")) {
4099          this.mode = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
4100        } else if (name.equals("cycle")) {
4101          this.cycle = TypeConvertor.castToCount(value); // Count
4102        } else if (name.equals("duration")) {
4103          this.duration = TypeConvertor.castToDuration(value); // Duration
4104        } else if (name.equals("owner")) {
4105          this.owner = TypeConvertor.castToReference(value); // Reference
4106        } else if (name.equals("contact")) {
4107          this.getContact().add(TypeConvertor.castToContactPoint(value));
4108        } else if (name.equals("location")) {
4109          this.location = TypeConvertor.castToReference(value); // Reference
4110        } else if (name.equals("url")) {
4111          this.url = TypeConvertor.castToUri(value); // UriType
4112        } else if (name.equals("endpoint")) {
4113          this.getEndpoint().add(TypeConvertor.castToReference(value));
4114        } else if (name.equals("gateway")) {
4115          this.getGateway().add(TypeConvertor.castToCodeableReference(value));
4116        } else if (name.equals("note")) {
4117          this.getNote().add(TypeConvertor.castToAnnotation(value));
4118        } else if (name.equals("safety")) {
4119          this.getSafety().add(TypeConvertor.castToCodeableConcept(value));
4120        } else if (name.equals("parent")) {
4121          this.parent = TypeConvertor.castToReference(value); // Reference
4122        } else
4123          return super.setProperty(name, value);
4124        return value;
4125      }
4126
4127      @Override
4128      public Base makeProperty(int hash, String name) throws FHIRException {
4129        switch (hash) {
4130        case -1618432855:  return addIdentifier(); 
4131        case 1714148973:  return getDisplayNameElement();
4132        case -1014418093:  return getDefinition();
4133        case -1343558178:  return addUdiCarrier(); 
4134        case -892481550:  return getStatusElement();
4135        case 804659501:  return getAvailabilityStatus();
4136        case -654468482:  return getBiologicalSourceEvent();
4137        case -1969347631:  return getManufacturerElement();
4138        case 416714767:  return getManufactureDateElement();
4139        case -668811523:  return getExpirationDateElement();
4140        case 462547450:  return getLotNumberElement();
4141        case 83787357:  return getSerialNumberElement();
4142        case 3373707:  return addName(); 
4143        case 346619858:  return getModelNumberElement();
4144        case -731502308:  return getPartNumberElement();
4145        case 50511102:  return addCategory(); 
4146        case 3575610:  return addType(); 
4147        case 351608024:  return addVersion(); 
4148        case 1014198088:  return addConformsTo(); 
4149        case -993141291:  return addProperty(); 
4150        case 3357091:  return getMode();
4151        case 95131878:  return getCycle();
4152        case -1992012396:  return getDuration();
4153        case 106164915:  return getOwner();
4154        case 951526432:  return addContact(); 
4155        case 1901043637:  return getLocation();
4156        case 116079:  return getUrlElement();
4157        case 1741102485:  return addEndpoint(); 
4158        case -189118908:  return addGateway(); 
4159        case 3387378:  return addNote(); 
4160        case -909893934:  return addSafety(); 
4161        case -995424086:  return getParent();
4162        default: return super.makeProperty(hash, name);
4163        }
4164
4165      }
4166
4167      @Override
4168      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
4169        switch (hash) {
4170        case -1618432855: /*identifier*/ return new String[] {"Identifier"};
4171        case 1714148973: /*displayName*/ return new String[] {"string"};
4172        case -1014418093: /*definition*/ return new String[] {"CodeableReference"};
4173        case -1343558178: /*udiCarrier*/ return new String[] {};
4174        case -892481550: /*status*/ return new String[] {"code"};
4175        case 804659501: /*availabilityStatus*/ return new String[] {"CodeableConcept"};
4176        case -654468482: /*biologicalSourceEvent*/ return new String[] {"Identifier"};
4177        case -1969347631: /*manufacturer*/ return new String[] {"string"};
4178        case 416714767: /*manufactureDate*/ return new String[] {"dateTime"};
4179        case -668811523: /*expirationDate*/ return new String[] {"dateTime"};
4180        case 462547450: /*lotNumber*/ return new String[] {"string"};
4181        case 83787357: /*serialNumber*/ return new String[] {"string"};
4182        case 3373707: /*name*/ return new String[] {};
4183        case 346619858: /*modelNumber*/ return new String[] {"string"};
4184        case -731502308: /*partNumber*/ return new String[] {"string"};
4185        case 50511102: /*category*/ return new String[] {"CodeableConcept"};
4186        case 3575610: /*type*/ return new String[] {"CodeableConcept"};
4187        case 351608024: /*version*/ return new String[] {};
4188        case 1014198088: /*conformsTo*/ return new String[] {};
4189        case -993141291: /*property*/ return new String[] {};
4190        case 3357091: /*mode*/ return new String[] {"CodeableConcept"};
4191        case 95131878: /*cycle*/ return new String[] {"Count"};
4192        case -1992012396: /*duration*/ return new String[] {"Duration"};
4193        case 106164915: /*owner*/ return new String[] {"Reference"};
4194        case 951526432: /*contact*/ return new String[] {"ContactPoint"};
4195        case 1901043637: /*location*/ return new String[] {"Reference"};
4196        case 116079: /*url*/ return new String[] {"uri"};
4197        case 1741102485: /*endpoint*/ return new String[] {"Reference"};
4198        case -189118908: /*gateway*/ return new String[] {"CodeableReference"};
4199        case 3387378: /*note*/ return new String[] {"Annotation"};
4200        case -909893934: /*safety*/ return new String[] {"CodeableConcept"};
4201        case -995424086: /*parent*/ return new String[] {"Reference"};
4202        default: return super.getTypesForProperty(hash, name);
4203        }
4204
4205      }
4206
4207      @Override
4208      public Base addChild(String name) throws FHIRException {
4209        if (name.equals("identifier")) {
4210          return addIdentifier();
4211        }
4212        else if (name.equals("displayName")) {
4213          throw new FHIRException("Cannot call addChild on a singleton property Device.displayName");
4214        }
4215        else if (name.equals("definition")) {
4216          this.definition = new CodeableReference();
4217          return this.definition;
4218        }
4219        else if (name.equals("udiCarrier")) {
4220          return addUdiCarrier();
4221        }
4222        else if (name.equals("status")) {
4223          throw new FHIRException("Cannot call addChild on a singleton property Device.status");
4224        }
4225        else if (name.equals("availabilityStatus")) {
4226          this.availabilityStatus = new CodeableConcept();
4227          return this.availabilityStatus;
4228        }
4229        else if (name.equals("biologicalSourceEvent")) {
4230          this.biologicalSourceEvent = new Identifier();
4231          return this.biologicalSourceEvent;
4232        }
4233        else if (name.equals("manufacturer")) {
4234          throw new FHIRException("Cannot call addChild on a singleton property Device.manufacturer");
4235        }
4236        else if (name.equals("manufactureDate")) {
4237          throw new FHIRException("Cannot call addChild on a singleton property Device.manufactureDate");
4238        }
4239        else if (name.equals("expirationDate")) {
4240          throw new FHIRException("Cannot call addChild on a singleton property Device.expirationDate");
4241        }
4242        else if (name.equals("lotNumber")) {
4243          throw new FHIRException("Cannot call addChild on a singleton property Device.lotNumber");
4244        }
4245        else if (name.equals("serialNumber")) {
4246          throw new FHIRException("Cannot call addChild on a singleton property Device.serialNumber");
4247        }
4248        else if (name.equals("name")) {
4249          return addName();
4250        }
4251        else if (name.equals("modelNumber")) {
4252          throw new FHIRException("Cannot call addChild on a singleton property Device.modelNumber");
4253        }
4254        else if (name.equals("partNumber")) {
4255          throw new FHIRException("Cannot call addChild on a singleton property Device.partNumber");
4256        }
4257        else if (name.equals("category")) {
4258          return addCategory();
4259        }
4260        else if (name.equals("type")) {
4261          return addType();
4262        }
4263        else if (name.equals("version")) {
4264          return addVersion();
4265        }
4266        else if (name.equals("conformsTo")) {
4267          return addConformsTo();
4268        }
4269        else if (name.equals("property")) {
4270          return addProperty();
4271        }
4272        else if (name.equals("mode")) {
4273          this.mode = new CodeableConcept();
4274          return this.mode;
4275        }
4276        else if (name.equals("cycle")) {
4277          this.cycle = new Count();
4278          return this.cycle;
4279        }
4280        else if (name.equals("duration")) {
4281          this.duration = new Duration();
4282          return this.duration;
4283        }
4284        else if (name.equals("owner")) {
4285          this.owner = new Reference();
4286          return this.owner;
4287        }
4288        else if (name.equals("contact")) {
4289          return addContact();
4290        }
4291        else if (name.equals("location")) {
4292          this.location = new Reference();
4293          return this.location;
4294        }
4295        else if (name.equals("url")) {
4296          throw new FHIRException("Cannot call addChild on a singleton property Device.url");
4297        }
4298        else if (name.equals("endpoint")) {
4299          return addEndpoint();
4300        }
4301        else if (name.equals("gateway")) {
4302          return addGateway();
4303        }
4304        else if (name.equals("note")) {
4305          return addNote();
4306        }
4307        else if (name.equals("safety")) {
4308          return addSafety();
4309        }
4310        else if (name.equals("parent")) {
4311          this.parent = new Reference();
4312          return this.parent;
4313        }
4314        else
4315          return super.addChild(name);
4316      }
4317
4318  public String fhirType() {
4319    return "Device";
4320
4321  }
4322
4323      public Device copy() {
4324        Device dst = new Device();
4325        copyValues(dst);
4326        return dst;
4327      }
4328
4329      public void copyValues(Device dst) {
4330        super.copyValues(dst);
4331        if (identifier != null) {
4332          dst.identifier = new ArrayList<Identifier>();
4333          for (Identifier i : identifier)
4334            dst.identifier.add(i.copy());
4335        };
4336        dst.displayName = displayName == null ? null : displayName.copy();
4337        dst.definition = definition == null ? null : definition.copy();
4338        if (udiCarrier != null) {
4339          dst.udiCarrier = new ArrayList<DeviceUdiCarrierComponent>();
4340          for (DeviceUdiCarrierComponent i : udiCarrier)
4341            dst.udiCarrier.add(i.copy());
4342        };
4343        dst.status = status == null ? null : status.copy();
4344        dst.availabilityStatus = availabilityStatus == null ? null : availabilityStatus.copy();
4345        dst.biologicalSourceEvent = biologicalSourceEvent == null ? null : biologicalSourceEvent.copy();
4346        dst.manufacturer = manufacturer == null ? null : manufacturer.copy();
4347        dst.manufactureDate = manufactureDate == null ? null : manufactureDate.copy();
4348        dst.expirationDate = expirationDate == null ? null : expirationDate.copy();
4349        dst.lotNumber = lotNumber == null ? null : lotNumber.copy();
4350        dst.serialNumber = serialNumber == null ? null : serialNumber.copy();
4351        if (name != null) {
4352          dst.name = new ArrayList<DeviceNameComponent>();
4353          for (DeviceNameComponent i : name)
4354            dst.name.add(i.copy());
4355        };
4356        dst.modelNumber = modelNumber == null ? null : modelNumber.copy();
4357        dst.partNumber = partNumber == null ? null : partNumber.copy();
4358        if (category != null) {
4359          dst.category = new ArrayList<CodeableConcept>();
4360          for (CodeableConcept i : category)
4361            dst.category.add(i.copy());
4362        };
4363        if (type != null) {
4364          dst.type = new ArrayList<CodeableConcept>();
4365          for (CodeableConcept i : type)
4366            dst.type.add(i.copy());
4367        };
4368        if (version != null) {
4369          dst.version = new ArrayList<DeviceVersionComponent>();
4370          for (DeviceVersionComponent i : version)
4371            dst.version.add(i.copy());
4372        };
4373        if (conformsTo != null) {
4374          dst.conformsTo = new ArrayList<DeviceConformsToComponent>();
4375          for (DeviceConformsToComponent i : conformsTo)
4376            dst.conformsTo.add(i.copy());
4377        };
4378        if (property != null) {
4379          dst.property = new ArrayList<DevicePropertyComponent>();
4380          for (DevicePropertyComponent i : property)
4381            dst.property.add(i.copy());
4382        };
4383        dst.mode = mode == null ? null : mode.copy();
4384        dst.cycle = cycle == null ? null : cycle.copy();
4385        dst.duration = duration == null ? null : duration.copy();
4386        dst.owner = owner == null ? null : owner.copy();
4387        if (contact != null) {
4388          dst.contact = new ArrayList<ContactPoint>();
4389          for (ContactPoint i : contact)
4390            dst.contact.add(i.copy());
4391        };
4392        dst.location = location == null ? null : location.copy();
4393        dst.url = url == null ? null : url.copy();
4394        if (endpoint != null) {
4395          dst.endpoint = new ArrayList<Reference>();
4396          for (Reference i : endpoint)
4397            dst.endpoint.add(i.copy());
4398        };
4399        if (gateway != null) {
4400          dst.gateway = new ArrayList<CodeableReference>();
4401          for (CodeableReference i : gateway)
4402            dst.gateway.add(i.copy());
4403        };
4404        if (note != null) {
4405          dst.note = new ArrayList<Annotation>();
4406          for (Annotation i : note)
4407            dst.note.add(i.copy());
4408        };
4409        if (safety != null) {
4410          dst.safety = new ArrayList<CodeableConcept>();
4411          for (CodeableConcept i : safety)
4412            dst.safety.add(i.copy());
4413        };
4414        dst.parent = parent == null ? null : parent.copy();
4415      }
4416
4417      protected Device typedCopy() {
4418        return copy();
4419      }
4420
4421      @Override
4422      public boolean equalsDeep(Base other_) {
4423        if (!super.equalsDeep(other_))
4424          return false;
4425        if (!(other_ instanceof Device))
4426          return false;
4427        Device o = (Device) other_;
4428        return compareDeep(identifier, o.identifier, true) && compareDeep(displayName, o.displayName, true)
4429           && compareDeep(definition, o.definition, true) && compareDeep(udiCarrier, o.udiCarrier, true) && compareDeep(status, o.status, true)
4430           && compareDeep(availabilityStatus, o.availabilityStatus, true) && compareDeep(biologicalSourceEvent, o.biologicalSourceEvent, true)
4431           && compareDeep(manufacturer, o.manufacturer, true) && compareDeep(manufactureDate, o.manufactureDate, true)
4432           && compareDeep(expirationDate, o.expirationDate, true) && compareDeep(lotNumber, o.lotNumber, true)
4433           && compareDeep(serialNumber, o.serialNumber, true) && compareDeep(name, o.name, true) && compareDeep(modelNumber, o.modelNumber, true)
4434           && compareDeep(partNumber, o.partNumber, true) && compareDeep(category, o.category, true) && compareDeep(type, o.type, true)
4435           && compareDeep(version, o.version, true) && compareDeep(conformsTo, o.conformsTo, true) && compareDeep(property, o.property, true)
4436           && compareDeep(mode, o.mode, true) && compareDeep(cycle, o.cycle, true) && compareDeep(duration, o.duration, true)
4437           && compareDeep(owner, o.owner, true) && compareDeep(contact, o.contact, true) && compareDeep(location, o.location, true)
4438           && compareDeep(url, o.url, true) && compareDeep(endpoint, o.endpoint, true) && compareDeep(gateway, o.gateway, true)
4439           && compareDeep(note, o.note, true) && compareDeep(safety, o.safety, true) && compareDeep(parent, o.parent, true)
4440          ;
4441      }
4442
4443      @Override
4444      public boolean equalsShallow(Base other_) {
4445        if (!super.equalsShallow(other_))
4446          return false;
4447        if (!(other_ instanceof Device))
4448          return false;
4449        Device o = (Device) other_;
4450        return compareValues(displayName, o.displayName, true) && compareValues(status, o.status, true) && compareValues(manufacturer, o.manufacturer, true)
4451           && compareValues(manufactureDate, o.manufactureDate, true) && compareValues(expirationDate, o.expirationDate, true)
4452           && compareValues(lotNumber, o.lotNumber, true) && compareValues(serialNumber, o.serialNumber, true)
4453           && compareValues(modelNumber, o.modelNumber, true) && compareValues(partNumber, o.partNumber, true)
4454           && compareValues(url, o.url, true);
4455      }
4456
4457      public boolean isEmpty() {
4458        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identifier, displayName, definition
4459          , udiCarrier, status, availabilityStatus, biologicalSourceEvent, manufacturer, manufactureDate
4460          , expirationDate, lotNumber, serialNumber, name, modelNumber, partNumber, category
4461          , type, version, conformsTo, property, mode, cycle, duration, owner, contact
4462          , location, url, endpoint, gateway, note, safety, parent);
4463      }
4464
4465  @Override
4466  public ResourceType getResourceType() {
4467    return ResourceType.Device;
4468   }
4469
4470 /**
4471   * Search parameter: <b>biological-source-event</b>
4472   * <p>
4473   * Description: <b>The biological source for the device</b><br>
4474   * Type: <b>token</b><br>
4475   * Path: <b>Device.biologicalSourceEvent</b><br>
4476   * </p>
4477   */
4478  @SearchParamDefinition(name="biological-source-event", path="Device.biologicalSourceEvent", description="The biological source for the device", type="token" )
4479  public static final String SP_BIOLOGICAL_SOURCE_EVENT = "biological-source-event";
4480 /**
4481   * <b>Fluent Client</b> search parameter constant for <b>biological-source-event</b>
4482   * <p>
4483   * Description: <b>The biological source for the device</b><br>
4484   * Type: <b>token</b><br>
4485   * Path: <b>Device.biologicalSourceEvent</b><br>
4486   * </p>
4487   */
4488  public static final ca.uhn.fhir.rest.gclient.TokenClientParam BIOLOGICAL_SOURCE_EVENT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_BIOLOGICAL_SOURCE_EVENT);
4489
4490 /**
4491   * Search parameter: <b>code-value-concept</b>
4492   * <p>
4493   * Description: <b>Code and value parameter pair</b><br>
4494   * Type: <b>composite</b><br>
4495   * Path: <b>Device</b><br>
4496   * </p>
4497   */
4498  @SearchParamDefinition(name="code-value-concept", path="Device", description="Code and value parameter pair", type="composite", compositeOf={"specification", "version"} )
4499  public static final String SP_CODE_VALUE_CONCEPT = "code-value-concept";
4500 /**
4501   * <b>Fluent Client</b> search parameter constant for <b>code-value-concept</b>
4502   * <p>
4503   * Description: <b>Code and value parameter pair</b><br>
4504   * Type: <b>composite</b><br>
4505   * Path: <b>Device</b><br>
4506   * </p>
4507   */
4508  public static final ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.StringClientParam> CODE_VALUE_CONCEPT = new ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.StringClientParam>(SP_CODE_VALUE_CONCEPT);
4509
4510 /**
4511   * Search parameter: <b>code</b>
4512   * <p>
4513   * Description: <b>The definition / type of the device (code)</b><br>
4514   * Type: <b>token</b><br>
4515   * Path: <b>Device.definition.concept</b><br>
4516   * </p>
4517   */
4518  @SearchParamDefinition(name="code", path="Device.definition.concept", description="The definition / type of the device (code)", type="token" )
4519  public static final String SP_CODE = "code";
4520 /**
4521   * <b>Fluent Client</b> search parameter constant for <b>code</b>
4522   * <p>
4523   * Description: <b>The definition / type of the device (code)</b><br>
4524   * Type: <b>token</b><br>
4525   * Path: <b>Device.definition.concept</b><br>
4526   * </p>
4527   */
4528  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CODE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CODE);
4529
4530 /**
4531   * Search parameter: <b>definition</b>
4532   * <p>
4533   * Description: <b>The definition / type of the device</b><br>
4534   * Type: <b>reference</b><br>
4535   * Path: <b>Device.definition.reference</b><br>
4536   * </p>
4537   */
4538  @SearchParamDefinition(name="definition", path="Device.definition.reference", description="The definition / type of the device", type="reference", target={DeviceDefinition.class } )
4539  public static final String SP_DEFINITION = "definition";
4540 /**
4541   * <b>Fluent Client</b> search parameter constant for <b>definition</b>
4542   * <p>
4543   * Description: <b>The definition / type of the device</b><br>
4544   * Type: <b>reference</b><br>
4545   * Path: <b>Device.definition.reference</b><br>
4546   * </p>
4547   */
4548  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam DEFINITION = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_DEFINITION);
4549
4550/**
4551   * Constant for fluent queries to be used to add include statements. Specifies
4552   * the path value of "<b>Device:definition</b>".
4553   */
4554  public static final ca.uhn.fhir.model.api.Include INCLUDE_DEFINITION = new ca.uhn.fhir.model.api.Include("Device:definition").toLocked();
4555
4556 /**
4557   * Search parameter: <b>device-name</b>
4558   * <p>
4559   * Description: <b>A server defined search that may match any of the string fields in Device.name or Device.type.</b><br>
4560   * Type: <b>string</b><br>
4561   * Path: <b>Device.name.value | Device.type.coding.display | Device.type.text</b><br>
4562   * </p>
4563   */
4564  @SearchParamDefinition(name="device-name", path="Device.name.value | Device.type.coding.display | Device.type.text", description="A server defined search that may match any of the string fields in Device.name or Device.type.", type="string" )
4565  public static final String SP_DEVICE_NAME = "device-name";
4566 /**
4567   * <b>Fluent Client</b> search parameter constant for <b>device-name</b>
4568   * <p>
4569   * Description: <b>A server defined search that may match any of the string fields in Device.name or Device.type.</b><br>
4570   * Type: <b>string</b><br>
4571   * Path: <b>Device.name.value | Device.type.coding.display | Device.type.text</b><br>
4572   * </p>
4573   */
4574  public static final ca.uhn.fhir.rest.gclient.StringClientParam DEVICE_NAME = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_DEVICE_NAME);
4575
4576 /**
4577   * Search parameter: <b>expiration-date</b>
4578   * <p>
4579   * Description: <b>The expiration date of the device</b><br>
4580   * Type: <b>date</b><br>
4581   * Path: <b>Device.expirationDate</b><br>
4582   * </p>
4583   */
4584  @SearchParamDefinition(name="expiration-date", path="Device.expirationDate", description="The expiration date of the device", type="date" )
4585  public static final String SP_EXPIRATION_DATE = "expiration-date";
4586 /**
4587   * <b>Fluent Client</b> search parameter constant for <b>expiration-date</b>
4588   * <p>
4589   * Description: <b>The expiration date of the device</b><br>
4590   * Type: <b>date</b><br>
4591   * Path: <b>Device.expirationDate</b><br>
4592   * </p>
4593   */
4594  public static final ca.uhn.fhir.rest.gclient.DateClientParam EXPIRATION_DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_EXPIRATION_DATE);
4595
4596 /**
4597   * Search parameter: <b>identifier</b>
4598   * <p>
4599   * Description: <b>Instance id from manufacturer, owner, and others</b><br>
4600   * Type: <b>token</b><br>
4601   * Path: <b>Device.identifier</b><br>
4602   * </p>
4603   */
4604  @SearchParamDefinition(name="identifier", path="Device.identifier", description="Instance id from manufacturer, owner, and others", type="token" )
4605  public static final String SP_IDENTIFIER = "identifier";
4606 /**
4607   * <b>Fluent Client</b> search parameter constant for <b>identifier</b>
4608   * <p>
4609   * Description: <b>Instance id from manufacturer, owner, and others</b><br>
4610   * Type: <b>token</b><br>
4611   * Path: <b>Device.identifier</b><br>
4612   * </p>
4613   */
4614  public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER);
4615
4616 /**
4617   * Search parameter: <b>location</b>
4618   * <p>
4619   * Description: <b>A location, where the resource is found</b><br>
4620   * Type: <b>reference</b><br>
4621   * Path: <b>Device.location</b><br>
4622   * </p>
4623   */
4624  @SearchParamDefinition(name="location", path="Device.location", description="A location, where the resource is found", type="reference", target={Location.class } )
4625  public static final String SP_LOCATION = "location";
4626 /**
4627   * <b>Fluent Client</b> search parameter constant for <b>location</b>
4628   * <p>
4629   * Description: <b>A location, where the resource is found</b><br>
4630   * Type: <b>reference</b><br>
4631   * Path: <b>Device.location</b><br>
4632   * </p>
4633   */
4634  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam LOCATION = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_LOCATION);
4635
4636/**
4637   * Constant for fluent queries to be used to add include statements. Specifies
4638   * the path value of "<b>Device:location</b>".
4639   */
4640  public static final ca.uhn.fhir.model.api.Include INCLUDE_LOCATION = new ca.uhn.fhir.model.api.Include("Device:location").toLocked();
4641
4642 /**
4643   * Search parameter: <b>lot-number</b>
4644   * <p>
4645   * Description: <b>The lot number of the device</b><br>
4646   * Type: <b>string</b><br>
4647   * Path: <b>Device.lotNumber</b><br>
4648   * </p>
4649   */
4650  @SearchParamDefinition(name="lot-number", path="Device.lotNumber", description="The lot number of the device", type="string" )
4651  public static final String SP_LOT_NUMBER = "lot-number";
4652 /**
4653   * <b>Fluent Client</b> search parameter constant for <b>lot-number</b>
4654   * <p>
4655   * Description: <b>The lot number of the device</b><br>
4656   * Type: <b>string</b><br>
4657   * Path: <b>Device.lotNumber</b><br>
4658   * </p>
4659   */
4660  public static final ca.uhn.fhir.rest.gclient.StringClientParam LOT_NUMBER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_LOT_NUMBER);
4661
4662 /**
4663   * Search parameter: <b>manufacture-date</b>
4664   * <p>
4665   * Description: <b>The manufacture date of the device</b><br>
4666   * Type: <b>date</b><br>
4667   * Path: <b>Device.manufactureDate</b><br>
4668   * </p>
4669   */
4670  @SearchParamDefinition(name="manufacture-date", path="Device.manufactureDate", description="The manufacture date of the device", type="date" )
4671  public static final String SP_MANUFACTURE_DATE = "manufacture-date";
4672 /**
4673   * <b>Fluent Client</b> search parameter constant for <b>manufacture-date</b>
4674   * <p>
4675   * Description: <b>The manufacture date of the device</b><br>
4676   * Type: <b>date</b><br>
4677   * Path: <b>Device.manufactureDate</b><br>
4678   * </p>
4679   */
4680  public static final ca.uhn.fhir.rest.gclient.DateClientParam MANUFACTURE_DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_MANUFACTURE_DATE);
4681
4682 /**
4683   * Search parameter: <b>manufacturer</b>
4684   * <p>
4685   * Description: <b>The manufacturer of the device</b><br>
4686   * Type: <b>string</b><br>
4687   * Path: <b>Device.manufacturer</b><br>
4688   * </p>
4689   */
4690  @SearchParamDefinition(name="manufacturer", path="Device.manufacturer", description="The manufacturer of the device", type="string" )
4691  public static final String SP_MANUFACTURER = "manufacturer";
4692 /**
4693   * <b>Fluent Client</b> search parameter constant for <b>manufacturer</b>
4694   * <p>
4695   * Description: <b>The manufacturer of the device</b><br>
4696   * Type: <b>string</b><br>
4697   * Path: <b>Device.manufacturer</b><br>
4698   * </p>
4699   */
4700  public static final ca.uhn.fhir.rest.gclient.StringClientParam MANUFACTURER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_MANUFACTURER);
4701
4702 /**
4703   * Search parameter: <b>model</b>
4704   * <p>
4705   * Description: <b>The model of the device</b><br>
4706   * Type: <b>string</b><br>
4707   * Path: <b>Device.modelNumber</b><br>
4708   * </p>
4709   */
4710  @SearchParamDefinition(name="model", path="Device.modelNumber", description="The model of the device", type="string" )
4711  public static final String SP_MODEL = "model";
4712 /**
4713   * <b>Fluent Client</b> search parameter constant for <b>model</b>
4714   * <p>
4715   * Description: <b>The model of the device</b><br>
4716   * Type: <b>string</b><br>
4717   * Path: <b>Device.modelNumber</b><br>
4718   * </p>
4719   */
4720  public static final ca.uhn.fhir.rest.gclient.StringClientParam MODEL = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_MODEL);
4721
4722 /**
4723   * Search parameter: <b>organization</b>
4724   * <p>
4725   * Description: <b>The organization responsible for the device</b><br>
4726   * Type: <b>reference</b><br>
4727   * Path: <b>Device.owner</b><br>
4728   * </p>
4729   */
4730  @SearchParamDefinition(name="organization", path="Device.owner", description="The organization responsible for the device", type="reference", target={Organization.class } )
4731  public static final String SP_ORGANIZATION = "organization";
4732 /**
4733   * <b>Fluent Client</b> search parameter constant for <b>organization</b>
4734   * <p>
4735   * Description: <b>The organization responsible for the device</b><br>
4736   * Type: <b>reference</b><br>
4737   * Path: <b>Device.owner</b><br>
4738   * </p>
4739   */
4740  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam ORGANIZATION = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_ORGANIZATION);
4741
4742/**
4743   * Constant for fluent queries to be used to add include statements. Specifies
4744   * the path value of "<b>Device:organization</b>".
4745   */
4746  public static final ca.uhn.fhir.model.api.Include INCLUDE_ORGANIZATION = new ca.uhn.fhir.model.api.Include("Device:organization").toLocked();
4747
4748 /**
4749   * Search parameter: <b>parent</b>
4750   * <p>
4751   * Description: <b>The parent device</b><br>
4752   * Type: <b>reference</b><br>
4753   * Path: <b>Device.parent</b><br>
4754   * </p>
4755   */
4756  @SearchParamDefinition(name="parent", path="Device.parent", description="The parent device", type="reference", target={Device.class } )
4757  public static final String SP_PARENT = "parent";
4758 /**
4759   * <b>Fluent Client</b> search parameter constant for <b>parent</b>
4760   * <p>
4761   * Description: <b>The parent device</b><br>
4762   * Type: <b>reference</b><br>
4763   * Path: <b>Device.parent</b><br>
4764   * </p>
4765   */
4766  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PARENT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_PARENT);
4767
4768/**
4769   * Constant for fluent queries to be used to add include statements. Specifies
4770   * the path value of "<b>Device:parent</b>".
4771   */
4772  public static final ca.uhn.fhir.model.api.Include INCLUDE_PARENT = new ca.uhn.fhir.model.api.Include("Device:parent").toLocked();
4773
4774 /**
4775   * Search parameter: <b>serial-number</b>
4776   * <p>
4777   * Description: <b>The serial number of the device</b><br>
4778   * Type: <b>string</b><br>
4779   * Path: <b>Device.serialNumber | Device.identifier.where(type='SNO')</b><br>
4780   * </p>
4781   */
4782  @SearchParamDefinition(name="serial-number", path="Device.serialNumber | Device.identifier.where(type='SNO')", description="The serial number of the device", type="string" )
4783  public static final String SP_SERIAL_NUMBER = "serial-number";
4784 /**
4785   * <b>Fluent Client</b> search parameter constant for <b>serial-number</b>
4786   * <p>
4787   * Description: <b>The serial number of the device</b><br>
4788   * Type: <b>string</b><br>
4789   * Path: <b>Device.serialNumber | Device.identifier.where(type='SNO')</b><br>
4790   * </p>
4791   */
4792  public static final ca.uhn.fhir.rest.gclient.StringClientParam SERIAL_NUMBER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_SERIAL_NUMBER);
4793
4794 /**
4795   * Search parameter: <b>specification-version</b>
4796   * <p>
4797   * Description: <b>A composite of both specification and version</b><br>
4798   * Type: <b>composite</b><br>
4799   * Path: <b>Device.conformsTo</b><br>
4800   * </p>
4801   */
4802  @SearchParamDefinition(name="specification-version", path="Device.conformsTo", description="A composite of both specification and version", type="composite", compositeOf={"specification", "version"} )
4803  public static final String SP_SPECIFICATION_VERSION = "specification-version";
4804 /**
4805   * <b>Fluent Client</b> search parameter constant for <b>specification-version</b>
4806   * <p>
4807   * Description: <b>A composite of both specification and version</b><br>
4808   * Type: <b>composite</b><br>
4809   * Path: <b>Device.conformsTo</b><br>
4810   * </p>
4811   */
4812  public static final ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.StringClientParam> SPECIFICATION_VERSION = new ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.StringClientParam>(SP_SPECIFICATION_VERSION);
4813
4814 /**
4815   * Search parameter: <b>specification</b>
4816   * <p>
4817   * Description: <b>The standards, specifications, or formal guidances.</b><br>
4818   * Type: <b>token</b><br>
4819   * Path: <b>Device.conformsTo.specification</b><br>
4820   * </p>
4821   */
4822  @SearchParamDefinition(name="specification", path="Device.conformsTo.specification", description="The standards, specifications, or formal guidances.", type="token" )
4823  public static final String SP_SPECIFICATION = "specification";
4824 /**
4825   * <b>Fluent Client</b> search parameter constant for <b>specification</b>
4826   * <p>
4827   * Description: <b>The standards, specifications, or formal guidances.</b><br>
4828   * Type: <b>token</b><br>
4829   * Path: <b>Device.conformsTo.specification</b><br>
4830   * </p>
4831   */
4832  public static final ca.uhn.fhir.rest.gclient.TokenClientParam SPECIFICATION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_SPECIFICATION);
4833
4834 /**
4835   * Search parameter: <b>status</b>
4836   * <p>
4837   * Description: <b>active | inactive | entered-in-error | unknown</b><br>
4838   * Type: <b>token</b><br>
4839   * Path: <b>Device.status</b><br>
4840   * </p>
4841   */
4842  @SearchParamDefinition(name="status", path="Device.status", description="active | inactive | entered-in-error | unknown", type="token" )
4843  public static final String SP_STATUS = "status";
4844 /**
4845   * <b>Fluent Client</b> search parameter constant for <b>status</b>
4846   * <p>
4847   * Description: <b>active | inactive | entered-in-error | unknown</b><br>
4848   * Type: <b>token</b><br>
4849   * Path: <b>Device.status</b><br>
4850   * </p>
4851   */
4852  public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS);
4853
4854 /**
4855   * Search parameter: <b>type</b>
4856   * <p>
4857   * Description: <b>The type of the device</b><br>
4858   * Type: <b>token</b><br>
4859   * Path: <b>Device.type</b><br>
4860   * </p>
4861   */
4862  @SearchParamDefinition(name="type", path="Device.type", description="The type of the device", type="token" )
4863  public static final String SP_TYPE = "type";
4864 /**
4865   * <b>Fluent Client</b> search parameter constant for <b>type</b>
4866   * <p>
4867   * Description: <b>The type of the device</b><br>
4868   * Type: <b>token</b><br>
4869   * Path: <b>Device.type</b><br>
4870   * </p>
4871   */
4872  public static final ca.uhn.fhir.rest.gclient.TokenClientParam TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_TYPE);
4873
4874 /**
4875   * Search parameter: <b>udi-carrier</b>
4876   * <p>
4877   * Description: <b>UDI Barcode (RFID or other technology) string in *HRF* format.</b><br>
4878   * Type: <b>string</b><br>
4879   * Path: <b>Device.udiCarrier.carrierHRF</b><br>
4880   * </p>
4881   */
4882  @SearchParamDefinition(name="udi-carrier", path="Device.udiCarrier.carrierHRF", description="UDI Barcode (RFID or other technology) string in *HRF* format.", type="string" )
4883  public static final String SP_UDI_CARRIER = "udi-carrier";
4884 /**
4885   * <b>Fluent Client</b> search parameter constant for <b>udi-carrier</b>
4886   * <p>
4887   * Description: <b>UDI Barcode (RFID or other technology) string in *HRF* format.</b><br>
4888   * Type: <b>string</b><br>
4889   * Path: <b>Device.udiCarrier.carrierHRF</b><br>
4890   * </p>
4891   */
4892  public static final ca.uhn.fhir.rest.gclient.StringClientParam UDI_CARRIER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_UDI_CARRIER);
4893
4894 /**
4895   * Search parameter: <b>udi-di</b>
4896   * <p>
4897   * Description: <b>The udi Device Identifier (DI)</b><br>
4898   * Type: <b>string</b><br>
4899   * Path: <b>Device.udiCarrier.deviceIdentifier</b><br>
4900   * </p>
4901   */
4902  @SearchParamDefinition(name="udi-di", path="Device.udiCarrier.deviceIdentifier", description="The udi Device Identifier (DI)", type="string" )
4903  public static final String SP_UDI_DI = "udi-di";
4904 /**
4905   * <b>Fluent Client</b> search parameter constant for <b>udi-di</b>
4906   * <p>
4907   * Description: <b>The udi Device Identifier (DI)</b><br>
4908   * Type: <b>string</b><br>
4909   * Path: <b>Device.udiCarrier.deviceIdentifier</b><br>
4910   * </p>
4911   */
4912  public static final ca.uhn.fhir.rest.gclient.StringClientParam UDI_DI = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_UDI_DI);
4913
4914 /**
4915   * Search parameter: <b>url</b>
4916   * <p>
4917   * Description: <b>Network address to contact device</b><br>
4918   * Type: <b>uri</b><br>
4919   * Path: <b>Device.url</b><br>
4920   * </p>
4921   */
4922  @SearchParamDefinition(name="url", path="Device.url", description="Network address to contact device", type="uri" )
4923  public static final String SP_URL = "url";
4924 /**
4925   * <b>Fluent Client</b> search parameter constant for <b>url</b>
4926   * <p>
4927   * Description: <b>Network address to contact device</b><br>
4928   * Type: <b>uri</b><br>
4929   * Path: <b>Device.url</b><br>
4930   * </p>
4931   */
4932  public static final ca.uhn.fhir.rest.gclient.UriClientParam URL = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_URL);
4933
4934 /**
4935   * Search parameter: <b>version</b>
4936   * <p>
4937   * Description: <b>The specific version of the device</b><br>
4938   * Type: <b>string</b><br>
4939   * Path: <b>Device.version.value</b><br>
4940   * </p>
4941   */
4942  @SearchParamDefinition(name="version", path="Device.version.value", description="The specific version of the device", type="string" )
4943  public static final String SP_VERSION = "version";
4944 /**
4945   * <b>Fluent Client</b> search parameter constant for <b>version</b>
4946   * <p>
4947   * Description: <b>The specific version of the device</b><br>
4948   * Type: <b>string</b><br>
4949   * Path: <b>Device.version.value</b><br>
4950   * </p>
4951   */
4952  public static final ca.uhn.fhir.rest.gclient.StringClientParam VERSION = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_VERSION);
4953
4954
4955}
4956