001package org.hl7.fhir.r5.model;
002
003
004/*
005 * #%L
006 * org.hl7.fhir.r5
007 * %%
008 * Copyright (C) 2014 - 2019 Health Level 7
009 * %%
010 * Licensed under the Apache License, Version 2.0 (the \"License\");
011 * you may not use this file except in compliance with the License.
012 * You may obtain a copy of the License at
013 * 
014 *      http://www.apache.org/licenses/LICENSE-2.0
015 * 
016 * Unless required by applicable law or agreed to in writing, software
017 * distributed under the License is distributed on an \"AS IS\" BASIS,
018 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
019 * See the License for the specific language governing permissions and
020 * limitations under the License.
021 * #L%
022 */
023
024/*
025  Copyright (c) 2011+, HL7, Inc.
026  All rights reserved.
027  
028  Redistribution and use in source and binary forms, with or without modification, \
029  are permitted provided that the following conditions are met:
030  
031   * Redistributions of source code must retain the above copyright notice, this \
032     list of conditions and the following disclaimer.
033   * Redistributions in binary form must reproduce the above copyright notice, \
034     this list of conditions and the following disclaimer in the documentation \
035     and/or other materials provided with the distribution.
036   * Neither the name of HL7 nor the names of its contributors may be used to 
037     endorse or promote products derived from this software without specific 
038     prior written permission.
039  
040  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND \
041  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED \
042  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \
043  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, \
044  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT \
045  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR \
046  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \
047  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) \
048  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \
049  POSSIBILITY OF SUCH DAMAGE.
050  */
051
052// Generated on Tue, Dec 31, 2019 12:12+1100 for FHIR vcurrent
053
054import java.util.ArrayList;
055import java.util.Date;
056import java.util.List;
057import org.hl7.fhir.utilities.Utilities;
058import org.hl7.fhir.r5.model.Enumerations.*;
059import org.hl7.fhir.instance.model.api.IBaseBackboneElement;
060import org.hl7.fhir.exceptions.FHIRException;
061import org.hl7.fhir.instance.model.api.ICompositeType;
062import ca.uhn.fhir.model.api.annotation.ResourceDef;
063import ca.uhn.fhir.model.api.annotation.SearchParamDefinition;
064import org.hl7.fhir.instance.model.api.IBaseBackboneElement;
065import ca.uhn.fhir.model.api.annotation.Child;
066import ca.uhn.fhir.model.api.annotation.ChildOrder;
067import ca.uhn.fhir.model.api.annotation.Description;
068import ca.uhn.fhir.model.api.annotation.Block;
069
070/**
071 * The characteristics, operational status and capabilities of a medical-related component of a medical device.
072 */
073@ResourceDef(name="DeviceDefinition", profile="http://hl7.org/fhir/StructureDefinition/DeviceDefinition")
074public class DeviceDefinition extends DomainResource {
075
076    @Block()
077    public static class DeviceDefinitionUdiDeviceIdentifierComponent extends BackboneElement implements IBaseBackboneElement {
078        /**
079         * The identifier that is to be associated with every Device that references this DeviceDefintiion for the issuer and jurisdication porvided in the DeviceDefinition.udiDeviceIdentifier.
080         */
081        @Child(name = "deviceIdentifier", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=false)
082        @Description(shortDefinition="The identifier that is to be associated with every Device that references this DeviceDefintiion for the issuer and jurisdication porvided in the DeviceDefinition.udiDeviceIdentifier", formalDefinition="The identifier that is to be associated with every Device that references this DeviceDefintiion for the issuer and jurisdication porvided in the DeviceDefinition.udiDeviceIdentifier." )
083        protected StringType deviceIdentifier;
084
085        /**
086         * The organization that assigns the identifier algorithm.
087         */
088        @Child(name = "issuer", type = {UriType.class}, order=2, min=1, max=1, modifier=false, summary=false)
089        @Description(shortDefinition="The organization that assigns the identifier algorithm", formalDefinition="The organization that assigns the identifier algorithm." )
090        protected UriType issuer;
091
092        /**
093         * The jurisdiction to which the deviceIdentifier applies.
094         */
095        @Child(name = "jurisdiction", type = {UriType.class}, order=3, min=1, max=1, modifier=false, summary=false)
096        @Description(shortDefinition="The jurisdiction to which the deviceIdentifier applies", formalDefinition="The jurisdiction to which the deviceIdentifier applies." )
097        protected UriType jurisdiction;
098
099        private static final long serialVersionUID = -1577319218L;
100
101    /**
102     * Constructor
103     */
104      public DeviceDefinitionUdiDeviceIdentifierComponent() {
105        super();
106      }
107
108    /**
109     * Constructor
110     */
111      public DeviceDefinitionUdiDeviceIdentifierComponent(String deviceIdentifier, String issuer, String jurisdiction) {
112        super();
113        this.setDeviceIdentifier(deviceIdentifier);
114        this.setIssuer(issuer);
115        this.setJurisdiction(jurisdiction);
116      }
117
118        /**
119         * @return {@link #deviceIdentifier} (The identifier that is to be associated with every Device that references this DeviceDefintiion for the issuer and jurisdication porvided in the DeviceDefinition.udiDeviceIdentifier.). This is the underlying object with id, value and extensions. The accessor "getDeviceIdentifier" gives direct access to the value
120         */
121        public StringType getDeviceIdentifierElement() { 
122          if (this.deviceIdentifier == null)
123            if (Configuration.errorOnAutoCreate())
124              throw new Error("Attempt to auto-create DeviceDefinitionUdiDeviceIdentifierComponent.deviceIdentifier");
125            else if (Configuration.doAutoCreate())
126              this.deviceIdentifier = new StringType(); // bb
127          return this.deviceIdentifier;
128        }
129
130        public boolean hasDeviceIdentifierElement() { 
131          return this.deviceIdentifier != null && !this.deviceIdentifier.isEmpty();
132        }
133
134        public boolean hasDeviceIdentifier() { 
135          return this.deviceIdentifier != null && !this.deviceIdentifier.isEmpty();
136        }
137
138        /**
139         * @param value {@link #deviceIdentifier} (The identifier that is to be associated with every Device that references this DeviceDefintiion for the issuer and jurisdication porvided in the DeviceDefinition.udiDeviceIdentifier.). This is the underlying object with id, value and extensions. The accessor "getDeviceIdentifier" gives direct access to the value
140         */
141        public DeviceDefinitionUdiDeviceIdentifierComponent setDeviceIdentifierElement(StringType value) { 
142          this.deviceIdentifier = value;
143          return this;
144        }
145
146        /**
147         * @return The identifier that is to be associated with every Device that references this DeviceDefintiion for the issuer and jurisdication porvided in the DeviceDefinition.udiDeviceIdentifier.
148         */
149        public String getDeviceIdentifier() { 
150          return this.deviceIdentifier == null ? null : this.deviceIdentifier.getValue();
151        }
152
153        /**
154         * @param value The identifier that is to be associated with every Device that references this DeviceDefintiion for the issuer and jurisdication porvided in the DeviceDefinition.udiDeviceIdentifier.
155         */
156        public DeviceDefinitionUdiDeviceIdentifierComponent setDeviceIdentifier(String value) { 
157            if (this.deviceIdentifier == null)
158              this.deviceIdentifier = new StringType();
159            this.deviceIdentifier.setValue(value);
160          return this;
161        }
162
163        /**
164         * @return {@link #issuer} (The organization that assigns the identifier algorithm.). This is the underlying object with id, value and extensions. The accessor "getIssuer" gives direct access to the value
165         */
166        public UriType getIssuerElement() { 
167          if (this.issuer == null)
168            if (Configuration.errorOnAutoCreate())
169              throw new Error("Attempt to auto-create DeviceDefinitionUdiDeviceIdentifierComponent.issuer");
170            else if (Configuration.doAutoCreate())
171              this.issuer = new UriType(); // bb
172          return this.issuer;
173        }
174
175        public boolean hasIssuerElement() { 
176          return this.issuer != null && !this.issuer.isEmpty();
177        }
178
179        public boolean hasIssuer() { 
180          return this.issuer != null && !this.issuer.isEmpty();
181        }
182
183        /**
184         * @param value {@link #issuer} (The organization that assigns the identifier algorithm.). This is the underlying object with id, value and extensions. The accessor "getIssuer" gives direct access to the value
185         */
186        public DeviceDefinitionUdiDeviceIdentifierComponent setIssuerElement(UriType value) { 
187          this.issuer = value;
188          return this;
189        }
190
191        /**
192         * @return The organization that assigns the identifier algorithm.
193         */
194        public String getIssuer() { 
195          return this.issuer == null ? null : this.issuer.getValue();
196        }
197
198        /**
199         * @param value The organization that assigns the identifier algorithm.
200         */
201        public DeviceDefinitionUdiDeviceIdentifierComponent setIssuer(String value) { 
202            if (this.issuer == null)
203              this.issuer = new UriType();
204            this.issuer.setValue(value);
205          return this;
206        }
207
208        /**
209         * @return {@link #jurisdiction} (The jurisdiction to which the deviceIdentifier applies.). This is the underlying object with id, value and extensions. The accessor "getJurisdiction" gives direct access to the value
210         */
211        public UriType getJurisdictionElement() { 
212          if (this.jurisdiction == null)
213            if (Configuration.errorOnAutoCreate())
214              throw new Error("Attempt to auto-create DeviceDefinitionUdiDeviceIdentifierComponent.jurisdiction");
215            else if (Configuration.doAutoCreate())
216              this.jurisdiction = new UriType(); // bb
217          return this.jurisdiction;
218        }
219
220        public boolean hasJurisdictionElement() { 
221          return this.jurisdiction != null && !this.jurisdiction.isEmpty();
222        }
223
224        public boolean hasJurisdiction() { 
225          return this.jurisdiction != null && !this.jurisdiction.isEmpty();
226        }
227
228        /**
229         * @param value {@link #jurisdiction} (The jurisdiction to which the deviceIdentifier applies.). This is the underlying object with id, value and extensions. The accessor "getJurisdiction" gives direct access to the value
230         */
231        public DeviceDefinitionUdiDeviceIdentifierComponent setJurisdictionElement(UriType value) { 
232          this.jurisdiction = value;
233          return this;
234        }
235
236        /**
237         * @return The jurisdiction to which the deviceIdentifier applies.
238         */
239        public String getJurisdiction() { 
240          return this.jurisdiction == null ? null : this.jurisdiction.getValue();
241        }
242
243        /**
244         * @param value The jurisdiction to which the deviceIdentifier applies.
245         */
246        public DeviceDefinitionUdiDeviceIdentifierComponent setJurisdiction(String value) { 
247            if (this.jurisdiction == null)
248              this.jurisdiction = new UriType();
249            this.jurisdiction.setValue(value);
250          return this;
251        }
252
253        protected void listChildren(List<Property> children) {
254          super.listChildren(children);
255          children.add(new Property("deviceIdentifier", "string", "The identifier that is to be associated with every Device that references this DeviceDefintiion for the issuer and jurisdication porvided in the DeviceDefinition.udiDeviceIdentifier.", 0, 1, deviceIdentifier));
256          children.add(new Property("issuer", "uri", "The organization that assigns the identifier algorithm.", 0, 1, issuer));
257          children.add(new Property("jurisdiction", "uri", "The jurisdiction to which the deviceIdentifier applies.", 0, 1, jurisdiction));
258        }
259
260        @Override
261        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
262          switch (_hash) {
263          case 1322005407: /*deviceIdentifier*/  return new Property("deviceIdentifier", "string", "The identifier that is to be associated with every Device that references this DeviceDefintiion for the issuer and jurisdication porvided in the DeviceDefinition.udiDeviceIdentifier.", 0, 1, deviceIdentifier);
264          case -1179159879: /*issuer*/  return new Property("issuer", "uri", "The organization that assigns the identifier algorithm.", 0, 1, issuer);
265          case -507075711: /*jurisdiction*/  return new Property("jurisdiction", "uri", "The jurisdiction to which the deviceIdentifier applies.", 0, 1, jurisdiction);
266          default: return super.getNamedProperty(_hash, _name, _checkValid);
267          }
268
269        }
270
271      @Override
272      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
273        switch (hash) {
274        case 1322005407: /*deviceIdentifier*/ return this.deviceIdentifier == null ? new Base[0] : new Base[] {this.deviceIdentifier}; // StringType
275        case -1179159879: /*issuer*/ return this.issuer == null ? new Base[0] : new Base[] {this.issuer}; // UriType
276        case -507075711: /*jurisdiction*/ return this.jurisdiction == null ? new Base[0] : new Base[] {this.jurisdiction}; // UriType
277        default: return super.getProperty(hash, name, checkValid);
278        }
279
280      }
281
282      @Override
283      public Base setProperty(int hash, String name, Base value) throws FHIRException {
284        switch (hash) {
285        case 1322005407: // deviceIdentifier
286          this.deviceIdentifier = TypeConvertor.castToString(value); // StringType
287          return value;
288        case -1179159879: // issuer
289          this.issuer = TypeConvertor.castToUri(value); // UriType
290          return value;
291        case -507075711: // jurisdiction
292          this.jurisdiction = TypeConvertor.castToUri(value); // UriType
293          return value;
294        default: return super.setProperty(hash, name, value);
295        }
296
297      }
298
299      @Override
300      public Base setProperty(String name, Base value) throws FHIRException {
301        if (name.equals("deviceIdentifier")) {
302          this.deviceIdentifier = TypeConvertor.castToString(value); // StringType
303        } else if (name.equals("issuer")) {
304          this.issuer = TypeConvertor.castToUri(value); // UriType
305        } else if (name.equals("jurisdiction")) {
306          this.jurisdiction = TypeConvertor.castToUri(value); // UriType
307        } else
308          return super.setProperty(name, value);
309        return value;
310      }
311
312      @Override
313      public Base makeProperty(int hash, String name) throws FHIRException {
314        switch (hash) {
315        case 1322005407:  return getDeviceIdentifierElement();
316        case -1179159879:  return getIssuerElement();
317        case -507075711:  return getJurisdictionElement();
318        default: return super.makeProperty(hash, name);
319        }
320
321      }
322
323      @Override
324      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
325        switch (hash) {
326        case 1322005407: /*deviceIdentifier*/ return new String[] {"string"};
327        case -1179159879: /*issuer*/ return new String[] {"uri"};
328        case -507075711: /*jurisdiction*/ return new String[] {"uri"};
329        default: return super.getTypesForProperty(hash, name);
330        }
331
332      }
333
334      @Override
335      public Base addChild(String name) throws FHIRException {
336        if (name.equals("deviceIdentifier")) {
337          throw new FHIRException("Cannot call addChild on a primitive type DeviceDefinition.udiDeviceIdentifier.deviceIdentifier");
338        }
339        else if (name.equals("issuer")) {
340          throw new FHIRException("Cannot call addChild on a primitive type DeviceDefinition.udiDeviceIdentifier.issuer");
341        }
342        else if (name.equals("jurisdiction")) {
343          throw new FHIRException("Cannot call addChild on a primitive type DeviceDefinition.udiDeviceIdentifier.jurisdiction");
344        }
345        else
346          return super.addChild(name);
347      }
348
349      public DeviceDefinitionUdiDeviceIdentifierComponent copy() {
350        DeviceDefinitionUdiDeviceIdentifierComponent dst = new DeviceDefinitionUdiDeviceIdentifierComponent();
351        copyValues(dst);
352        return dst;
353      }
354
355      public void copyValues(DeviceDefinitionUdiDeviceIdentifierComponent dst) {
356        super.copyValues(dst);
357        dst.deviceIdentifier = deviceIdentifier == null ? null : deviceIdentifier.copy();
358        dst.issuer = issuer == null ? null : issuer.copy();
359        dst.jurisdiction = jurisdiction == null ? null : jurisdiction.copy();
360      }
361
362      @Override
363      public boolean equalsDeep(Base other_) {
364        if (!super.equalsDeep(other_))
365          return false;
366        if (!(other_ instanceof DeviceDefinitionUdiDeviceIdentifierComponent))
367          return false;
368        DeviceDefinitionUdiDeviceIdentifierComponent o = (DeviceDefinitionUdiDeviceIdentifierComponent) other_;
369        return compareDeep(deviceIdentifier, o.deviceIdentifier, true) && compareDeep(issuer, o.issuer, true)
370           && compareDeep(jurisdiction, o.jurisdiction, true);
371      }
372
373      @Override
374      public boolean equalsShallow(Base other_) {
375        if (!super.equalsShallow(other_))
376          return false;
377        if (!(other_ instanceof DeviceDefinitionUdiDeviceIdentifierComponent))
378          return false;
379        DeviceDefinitionUdiDeviceIdentifierComponent o = (DeviceDefinitionUdiDeviceIdentifierComponent) other_;
380        return compareValues(deviceIdentifier, o.deviceIdentifier, true) && compareValues(issuer, o.issuer, true)
381           && compareValues(jurisdiction, o.jurisdiction, true);
382      }
383
384      public boolean isEmpty() {
385        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(deviceIdentifier, issuer, jurisdiction
386          );
387      }
388
389  public String fhirType() {
390    return "DeviceDefinition.udiDeviceIdentifier";
391
392  }
393
394  }
395
396    @Block()
397    public static class DeviceDefinitionDeviceNameComponent extends BackboneElement implements IBaseBackboneElement {
398        /**
399         * The name of the device.
400         */
401        @Child(name = "name", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=false)
402        @Description(shortDefinition="The name of the device", formalDefinition="The name of the device." )
403        protected StringType name;
404
405        /**
406         * The type of deviceName.
407UDILabelName | UserFriendlyName | PatientReportedName | ManufactureDeviceName | ModelName.
408         */
409        @Child(name = "type", type = {CodeType.class}, order=2, min=1, max=1, modifier=false, summary=false)
410        @Description(shortDefinition="udi-label-name | user-friendly-name | patient-reported-name | manufacturer-name | model-name | other", formalDefinition="The type of deviceName.\nUDILabelName | UserFriendlyName | PatientReportedName | ManufactureDeviceName | ModelName." )
411        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/device-nametype")
412        protected Enumeration<DeviceNameType> type;
413
414        private static final long serialVersionUID = 918983440L;
415
416    /**
417     * Constructor
418     */
419      public DeviceDefinitionDeviceNameComponent() {
420        super();
421      }
422
423    /**
424     * Constructor
425     */
426      public DeviceDefinitionDeviceNameComponent(String name, DeviceNameType type) {
427        super();
428        this.setName(name);
429        this.setType(type);
430      }
431
432        /**
433         * @return {@link #name} (The name of the device.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
434         */
435        public StringType getNameElement() { 
436          if (this.name == null)
437            if (Configuration.errorOnAutoCreate())
438              throw new Error("Attempt to auto-create DeviceDefinitionDeviceNameComponent.name");
439            else if (Configuration.doAutoCreate())
440              this.name = new StringType(); // bb
441          return this.name;
442        }
443
444        public boolean hasNameElement() { 
445          return this.name != null && !this.name.isEmpty();
446        }
447
448        public boolean hasName() { 
449          return this.name != null && !this.name.isEmpty();
450        }
451
452        /**
453         * @param value {@link #name} (The name of the device.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
454         */
455        public DeviceDefinitionDeviceNameComponent setNameElement(StringType value) { 
456          this.name = value;
457          return this;
458        }
459
460        /**
461         * @return The name of the device.
462         */
463        public String getName() { 
464          return this.name == null ? null : this.name.getValue();
465        }
466
467        /**
468         * @param value The name of the device.
469         */
470        public DeviceDefinitionDeviceNameComponent setName(String value) { 
471            if (this.name == null)
472              this.name = new StringType();
473            this.name.setValue(value);
474          return this;
475        }
476
477        /**
478         * @return {@link #type} (The type of deviceName.
479UDILabelName | UserFriendlyName | PatientReportedName | ManufactureDeviceName | ModelName.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
480         */
481        public Enumeration<DeviceNameType> getTypeElement() { 
482          if (this.type == null)
483            if (Configuration.errorOnAutoCreate())
484              throw new Error("Attempt to auto-create DeviceDefinitionDeviceNameComponent.type");
485            else if (Configuration.doAutoCreate())
486              this.type = new Enumeration<DeviceNameType>(new DeviceNameTypeEnumFactory()); // bb
487          return this.type;
488        }
489
490        public boolean hasTypeElement() { 
491          return this.type != null && !this.type.isEmpty();
492        }
493
494        public boolean hasType() { 
495          return this.type != null && !this.type.isEmpty();
496        }
497
498        /**
499         * @param value {@link #type} (The type of deviceName.
500UDILabelName | UserFriendlyName | PatientReportedName | ManufactureDeviceName | ModelName.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
501         */
502        public DeviceDefinitionDeviceNameComponent setTypeElement(Enumeration<DeviceNameType> value) { 
503          this.type = value;
504          return this;
505        }
506
507        /**
508         * @return The type of deviceName.
509UDILabelName | UserFriendlyName | PatientReportedName | ManufactureDeviceName | ModelName.
510         */
511        public DeviceNameType getType() { 
512          return this.type == null ? null : this.type.getValue();
513        }
514
515        /**
516         * @param value The type of deviceName.
517UDILabelName | UserFriendlyName | PatientReportedName | ManufactureDeviceName | ModelName.
518         */
519        public DeviceDefinitionDeviceNameComponent setType(DeviceNameType value) { 
520            if (this.type == null)
521              this.type = new Enumeration<DeviceNameType>(new DeviceNameTypeEnumFactory());
522            this.type.setValue(value);
523          return this;
524        }
525
526        protected void listChildren(List<Property> children) {
527          super.listChildren(children);
528          children.add(new Property("name", "string", "The name of the device.", 0, 1, name));
529          children.add(new Property("type", "code", "The type of deviceName.\nUDILabelName | UserFriendlyName | PatientReportedName | ManufactureDeviceName | ModelName.", 0, 1, type));
530        }
531
532        @Override
533        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
534          switch (_hash) {
535          case 3373707: /*name*/  return new Property("name", "string", "The name of the device.", 0, 1, name);
536          case 3575610: /*type*/  return new Property("type", "code", "The type of deviceName.\nUDILabelName | UserFriendlyName | PatientReportedName | ManufactureDeviceName | ModelName.", 0, 1, type);
537          default: return super.getNamedProperty(_hash, _name, _checkValid);
538          }
539
540        }
541
542      @Override
543      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
544        switch (hash) {
545        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
546        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<DeviceNameType>
547        default: return super.getProperty(hash, name, checkValid);
548        }
549
550      }
551
552      @Override
553      public Base setProperty(int hash, String name, Base value) throws FHIRException {
554        switch (hash) {
555        case 3373707: // name
556          this.name = TypeConvertor.castToString(value); // StringType
557          return value;
558        case 3575610: // type
559          value = new DeviceNameTypeEnumFactory().fromType(TypeConvertor.castToCode(value));
560          this.type = (Enumeration) value; // Enumeration<DeviceNameType>
561          return value;
562        default: return super.setProperty(hash, name, value);
563        }
564
565      }
566
567      @Override
568      public Base setProperty(String name, Base value) throws FHIRException {
569        if (name.equals("name")) {
570          this.name = TypeConvertor.castToString(value); // StringType
571        } else if (name.equals("type")) {
572          value = new DeviceNameTypeEnumFactory().fromType(TypeConvertor.castToCode(value));
573          this.type = (Enumeration) value; // Enumeration<DeviceNameType>
574        } else
575          return super.setProperty(name, value);
576        return value;
577      }
578
579      @Override
580      public Base makeProperty(int hash, String name) throws FHIRException {
581        switch (hash) {
582        case 3373707:  return getNameElement();
583        case 3575610:  return getTypeElement();
584        default: return super.makeProperty(hash, name);
585        }
586
587      }
588
589      @Override
590      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
591        switch (hash) {
592        case 3373707: /*name*/ return new String[] {"string"};
593        case 3575610: /*type*/ return new String[] {"code"};
594        default: return super.getTypesForProperty(hash, name);
595        }
596
597      }
598
599      @Override
600      public Base addChild(String name) throws FHIRException {
601        if (name.equals("name")) {
602          throw new FHIRException("Cannot call addChild on a primitive type DeviceDefinition.deviceName.name");
603        }
604        else if (name.equals("type")) {
605          throw new FHIRException("Cannot call addChild on a primitive type DeviceDefinition.deviceName.type");
606        }
607        else
608          return super.addChild(name);
609      }
610
611      public DeviceDefinitionDeviceNameComponent copy() {
612        DeviceDefinitionDeviceNameComponent dst = new DeviceDefinitionDeviceNameComponent();
613        copyValues(dst);
614        return dst;
615      }
616
617      public void copyValues(DeviceDefinitionDeviceNameComponent dst) {
618        super.copyValues(dst);
619        dst.name = name == null ? null : name.copy();
620        dst.type = type == null ? null : type.copy();
621      }
622
623      @Override
624      public boolean equalsDeep(Base other_) {
625        if (!super.equalsDeep(other_))
626          return false;
627        if (!(other_ instanceof DeviceDefinitionDeviceNameComponent))
628          return false;
629        DeviceDefinitionDeviceNameComponent o = (DeviceDefinitionDeviceNameComponent) other_;
630        return compareDeep(name, o.name, true) && compareDeep(type, o.type, true);
631      }
632
633      @Override
634      public boolean equalsShallow(Base other_) {
635        if (!super.equalsShallow(other_))
636          return false;
637        if (!(other_ instanceof DeviceDefinitionDeviceNameComponent))
638          return false;
639        DeviceDefinitionDeviceNameComponent o = (DeviceDefinitionDeviceNameComponent) other_;
640        return compareValues(name, o.name, true) && compareValues(type, o.type, true);
641      }
642
643      public boolean isEmpty() {
644        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, type);
645      }
646
647  public String fhirType() {
648    return "DeviceDefinition.deviceName";
649
650  }
651
652  }
653
654    @Block()
655    public static class DeviceDefinitionSpecializationComponent extends BackboneElement implements IBaseBackboneElement {
656        /**
657         * The standard that is used to operate and communicate.
658         */
659        @Child(name = "systemType", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=false)
660        @Description(shortDefinition="The standard that is used to operate and communicate", formalDefinition="The standard that is used to operate and communicate." )
661        protected StringType systemType;
662
663        /**
664         * The version of the standard that is used to operate and communicate.
665         */
666        @Child(name = "version", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=false)
667        @Description(shortDefinition="The version of the standard that is used to operate and communicate", formalDefinition="The version of the standard that is used to operate and communicate." )
668        protected StringType version;
669
670        private static final long serialVersionUID = -249304393L;
671
672    /**
673     * Constructor
674     */
675      public DeviceDefinitionSpecializationComponent() {
676        super();
677      }
678
679    /**
680     * Constructor
681     */
682      public DeviceDefinitionSpecializationComponent(String systemType) {
683        super();
684        this.setSystemType(systemType);
685      }
686
687        /**
688         * @return {@link #systemType} (The standard that is used to operate and communicate.). This is the underlying object with id, value and extensions. The accessor "getSystemType" gives direct access to the value
689         */
690        public StringType getSystemTypeElement() { 
691          if (this.systemType == null)
692            if (Configuration.errorOnAutoCreate())
693              throw new Error("Attempt to auto-create DeviceDefinitionSpecializationComponent.systemType");
694            else if (Configuration.doAutoCreate())
695              this.systemType = new StringType(); // bb
696          return this.systemType;
697        }
698
699        public boolean hasSystemTypeElement() { 
700          return this.systemType != null && !this.systemType.isEmpty();
701        }
702
703        public boolean hasSystemType() { 
704          return this.systemType != null && !this.systemType.isEmpty();
705        }
706
707        /**
708         * @param value {@link #systemType} (The standard that is used to operate and communicate.). This is the underlying object with id, value and extensions. The accessor "getSystemType" gives direct access to the value
709         */
710        public DeviceDefinitionSpecializationComponent setSystemTypeElement(StringType value) { 
711          this.systemType = value;
712          return this;
713        }
714
715        /**
716         * @return The standard that is used to operate and communicate.
717         */
718        public String getSystemType() { 
719          return this.systemType == null ? null : this.systemType.getValue();
720        }
721
722        /**
723         * @param value The standard that is used to operate and communicate.
724         */
725        public DeviceDefinitionSpecializationComponent setSystemType(String value) { 
726            if (this.systemType == null)
727              this.systemType = new StringType();
728            this.systemType.setValue(value);
729          return this;
730        }
731
732        /**
733         * @return {@link #version} (The version of the standard that is used to operate and communicate.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value
734         */
735        public StringType getVersionElement() { 
736          if (this.version == null)
737            if (Configuration.errorOnAutoCreate())
738              throw new Error("Attempt to auto-create DeviceDefinitionSpecializationComponent.version");
739            else if (Configuration.doAutoCreate())
740              this.version = new StringType(); // bb
741          return this.version;
742        }
743
744        public boolean hasVersionElement() { 
745          return this.version != null && !this.version.isEmpty();
746        }
747
748        public boolean hasVersion() { 
749          return this.version != null && !this.version.isEmpty();
750        }
751
752        /**
753         * @param value {@link #version} (The version of the standard that is used to operate and communicate.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value
754         */
755        public DeviceDefinitionSpecializationComponent setVersionElement(StringType value) { 
756          this.version = value;
757          return this;
758        }
759
760        /**
761         * @return The version of the standard that is used to operate and communicate.
762         */
763        public String getVersion() { 
764          return this.version == null ? null : this.version.getValue();
765        }
766
767        /**
768         * @param value The version of the standard that is used to operate and communicate.
769         */
770        public DeviceDefinitionSpecializationComponent setVersion(String value) { 
771          if (Utilities.noString(value))
772            this.version = null;
773          else {
774            if (this.version == null)
775              this.version = new StringType();
776            this.version.setValue(value);
777          }
778          return this;
779        }
780
781        protected void listChildren(List<Property> children) {
782          super.listChildren(children);
783          children.add(new Property("systemType", "string", "The standard that is used to operate and communicate.", 0, 1, systemType));
784          children.add(new Property("version", "string", "The version of the standard that is used to operate and communicate.", 0, 1, version));
785        }
786
787        @Override
788        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
789          switch (_hash) {
790          case 642893321: /*systemType*/  return new Property("systemType", "string", "The standard that is used to operate and communicate.", 0, 1, systemType);
791          case 351608024: /*version*/  return new Property("version", "string", "The version of the standard that is used to operate and communicate.", 0, 1, version);
792          default: return super.getNamedProperty(_hash, _name, _checkValid);
793          }
794
795        }
796
797      @Override
798      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
799        switch (hash) {
800        case 642893321: /*systemType*/ return this.systemType == null ? new Base[0] : new Base[] {this.systemType}; // StringType
801        case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType
802        default: return super.getProperty(hash, name, checkValid);
803        }
804
805      }
806
807      @Override
808      public Base setProperty(int hash, String name, Base value) throws FHIRException {
809        switch (hash) {
810        case 642893321: // systemType
811          this.systemType = TypeConvertor.castToString(value); // StringType
812          return value;
813        case 351608024: // version
814          this.version = TypeConvertor.castToString(value); // StringType
815          return value;
816        default: return super.setProperty(hash, name, value);
817        }
818
819      }
820
821      @Override
822      public Base setProperty(String name, Base value) throws FHIRException {
823        if (name.equals("systemType")) {
824          this.systemType = TypeConvertor.castToString(value); // StringType
825        } else if (name.equals("version")) {
826          this.version = TypeConvertor.castToString(value); // StringType
827        } else
828          return super.setProperty(name, value);
829        return value;
830      }
831
832      @Override
833      public Base makeProperty(int hash, String name) throws FHIRException {
834        switch (hash) {
835        case 642893321:  return getSystemTypeElement();
836        case 351608024:  return getVersionElement();
837        default: return super.makeProperty(hash, name);
838        }
839
840      }
841
842      @Override
843      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
844        switch (hash) {
845        case 642893321: /*systemType*/ return new String[] {"string"};
846        case 351608024: /*version*/ return new String[] {"string"};
847        default: return super.getTypesForProperty(hash, name);
848        }
849
850      }
851
852      @Override
853      public Base addChild(String name) throws FHIRException {
854        if (name.equals("systemType")) {
855          throw new FHIRException("Cannot call addChild on a primitive type DeviceDefinition.specialization.systemType");
856        }
857        else if (name.equals("version")) {
858          throw new FHIRException("Cannot call addChild on a primitive type DeviceDefinition.specialization.version");
859        }
860        else
861          return super.addChild(name);
862      }
863
864      public DeviceDefinitionSpecializationComponent copy() {
865        DeviceDefinitionSpecializationComponent dst = new DeviceDefinitionSpecializationComponent();
866        copyValues(dst);
867        return dst;
868      }
869
870      public void copyValues(DeviceDefinitionSpecializationComponent dst) {
871        super.copyValues(dst);
872        dst.systemType = systemType == null ? null : systemType.copy();
873        dst.version = version == null ? null : version.copy();
874      }
875
876      @Override
877      public boolean equalsDeep(Base other_) {
878        if (!super.equalsDeep(other_))
879          return false;
880        if (!(other_ instanceof DeviceDefinitionSpecializationComponent))
881          return false;
882        DeviceDefinitionSpecializationComponent o = (DeviceDefinitionSpecializationComponent) other_;
883        return compareDeep(systemType, o.systemType, true) && compareDeep(version, o.version, true);
884      }
885
886      @Override
887      public boolean equalsShallow(Base other_) {
888        if (!super.equalsShallow(other_))
889          return false;
890        if (!(other_ instanceof DeviceDefinitionSpecializationComponent))
891          return false;
892        DeviceDefinitionSpecializationComponent o = (DeviceDefinitionSpecializationComponent) other_;
893        return compareValues(systemType, o.systemType, true) && compareValues(version, o.version, true);
894      }
895
896      public boolean isEmpty() {
897        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(systemType, version);
898      }
899
900  public String fhirType() {
901    return "DeviceDefinition.specialization";
902
903  }
904
905  }
906
907    @Block()
908    public static class DeviceDefinitionCapabilityComponent extends BackboneElement implements IBaseBackboneElement {
909        /**
910         * Type of capability.
911         */
912        @Child(name = "type", type = {CodeableConcept.class}, order=1, min=1, max=1, modifier=false, summary=false)
913        @Description(shortDefinition="Type of capability", formalDefinition="Type of capability." )
914        protected CodeableConcept type;
915
916        /**
917         * Description of capability.
918         */
919        @Child(name = "description", type = {CodeableConcept.class}, order=2, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
920        @Description(shortDefinition="Description of capability", formalDefinition="Description of capability." )
921        protected List<CodeableConcept> description;
922
923        private static final long serialVersionUID = -192945344L;
924
925    /**
926     * Constructor
927     */
928      public DeviceDefinitionCapabilityComponent() {
929        super();
930      }
931
932    /**
933     * Constructor
934     */
935      public DeviceDefinitionCapabilityComponent(CodeableConcept type) {
936        super();
937        this.setType(type);
938      }
939
940        /**
941         * @return {@link #type} (Type of capability.)
942         */
943        public CodeableConcept getType() { 
944          if (this.type == null)
945            if (Configuration.errorOnAutoCreate())
946              throw new Error("Attempt to auto-create DeviceDefinitionCapabilityComponent.type");
947            else if (Configuration.doAutoCreate())
948              this.type = new CodeableConcept(); // cc
949          return this.type;
950        }
951
952        public boolean hasType() { 
953          return this.type != null && !this.type.isEmpty();
954        }
955
956        /**
957         * @param value {@link #type} (Type of capability.)
958         */
959        public DeviceDefinitionCapabilityComponent setType(CodeableConcept value) { 
960          this.type = value;
961          return this;
962        }
963
964        /**
965         * @return {@link #description} (Description of capability.)
966         */
967        public List<CodeableConcept> getDescription() { 
968          if (this.description == null)
969            this.description = new ArrayList<CodeableConcept>();
970          return this.description;
971        }
972
973        /**
974         * @return Returns a reference to <code>this</code> for easy method chaining
975         */
976        public DeviceDefinitionCapabilityComponent setDescription(List<CodeableConcept> theDescription) { 
977          this.description = theDescription;
978          return this;
979        }
980
981        public boolean hasDescription() { 
982          if (this.description == null)
983            return false;
984          for (CodeableConcept item : this.description)
985            if (!item.isEmpty())
986              return true;
987          return false;
988        }
989
990        public CodeableConcept addDescription() { //3
991          CodeableConcept t = new CodeableConcept();
992          if (this.description == null)
993            this.description = new ArrayList<CodeableConcept>();
994          this.description.add(t);
995          return t;
996        }
997
998        public DeviceDefinitionCapabilityComponent addDescription(CodeableConcept t) { //3
999          if (t == null)
1000            return this;
1001          if (this.description == null)
1002            this.description = new ArrayList<CodeableConcept>();
1003          this.description.add(t);
1004          return this;
1005        }
1006
1007        /**
1008         * @return The first repetition of repeating field {@link #description}, creating it if it does not already exist {3}
1009         */
1010        public CodeableConcept getDescriptionFirstRep() { 
1011          if (getDescription().isEmpty()) {
1012            addDescription();
1013          }
1014          return getDescription().get(0);
1015        }
1016
1017        protected void listChildren(List<Property> children) {
1018          super.listChildren(children);
1019          children.add(new Property("type", "CodeableConcept", "Type of capability.", 0, 1, type));
1020          children.add(new Property("description", "CodeableConcept", "Description of capability.", 0, java.lang.Integer.MAX_VALUE, description));
1021        }
1022
1023        @Override
1024        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1025          switch (_hash) {
1026          case 3575610: /*type*/  return new Property("type", "CodeableConcept", "Type of capability.", 0, 1, type);
1027          case -1724546052: /*description*/  return new Property("description", "CodeableConcept", "Description of capability.", 0, java.lang.Integer.MAX_VALUE, description);
1028          default: return super.getNamedProperty(_hash, _name, _checkValid);
1029          }
1030
1031        }
1032
1033      @Override
1034      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1035        switch (hash) {
1036        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // CodeableConcept
1037        case -1724546052: /*description*/ return this.description == null ? new Base[0] : this.description.toArray(new Base[this.description.size()]); // CodeableConcept
1038        default: return super.getProperty(hash, name, checkValid);
1039        }
1040
1041      }
1042
1043      @Override
1044      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1045        switch (hash) {
1046        case 3575610: // type
1047          this.type = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
1048          return value;
1049        case -1724546052: // description
1050          this.getDescription().add(TypeConvertor.castToCodeableConcept(value)); // CodeableConcept
1051          return value;
1052        default: return super.setProperty(hash, name, value);
1053        }
1054
1055      }
1056
1057      @Override
1058      public Base setProperty(String name, Base value) throws FHIRException {
1059        if (name.equals("type")) {
1060          this.type = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
1061        } else if (name.equals("description")) {
1062          this.getDescription().add(TypeConvertor.castToCodeableConcept(value));
1063        } else
1064          return super.setProperty(name, value);
1065        return value;
1066      }
1067
1068      @Override
1069      public Base makeProperty(int hash, String name) throws FHIRException {
1070        switch (hash) {
1071        case 3575610:  return getType();
1072        case -1724546052:  return addDescription(); 
1073        default: return super.makeProperty(hash, name);
1074        }
1075
1076      }
1077
1078      @Override
1079      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1080        switch (hash) {
1081        case 3575610: /*type*/ return new String[] {"CodeableConcept"};
1082        case -1724546052: /*description*/ return new String[] {"CodeableConcept"};
1083        default: return super.getTypesForProperty(hash, name);
1084        }
1085
1086      }
1087
1088      @Override
1089      public Base addChild(String name) throws FHIRException {
1090        if (name.equals("type")) {
1091          this.type = new CodeableConcept();
1092          return this.type;
1093        }
1094        else if (name.equals("description")) {
1095          return addDescription();
1096        }
1097        else
1098          return super.addChild(name);
1099      }
1100
1101      public DeviceDefinitionCapabilityComponent copy() {
1102        DeviceDefinitionCapabilityComponent dst = new DeviceDefinitionCapabilityComponent();
1103        copyValues(dst);
1104        return dst;
1105      }
1106
1107      public void copyValues(DeviceDefinitionCapabilityComponent dst) {
1108        super.copyValues(dst);
1109        dst.type = type == null ? null : type.copy();
1110        if (description != null) {
1111          dst.description = new ArrayList<CodeableConcept>();
1112          for (CodeableConcept i : description)
1113            dst.description.add(i.copy());
1114        };
1115      }
1116
1117      @Override
1118      public boolean equalsDeep(Base other_) {
1119        if (!super.equalsDeep(other_))
1120          return false;
1121        if (!(other_ instanceof DeviceDefinitionCapabilityComponent))
1122          return false;
1123        DeviceDefinitionCapabilityComponent o = (DeviceDefinitionCapabilityComponent) other_;
1124        return compareDeep(type, o.type, true) && compareDeep(description, o.description, true);
1125      }
1126
1127      @Override
1128      public boolean equalsShallow(Base other_) {
1129        if (!super.equalsShallow(other_))
1130          return false;
1131        if (!(other_ instanceof DeviceDefinitionCapabilityComponent))
1132          return false;
1133        DeviceDefinitionCapabilityComponent o = (DeviceDefinitionCapabilityComponent) other_;
1134        return true;
1135      }
1136
1137      public boolean isEmpty() {
1138        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(type, description);
1139      }
1140
1141  public String fhirType() {
1142    return "DeviceDefinition.capability";
1143
1144  }
1145
1146  }
1147
1148    @Block()
1149    public static class DeviceDefinitionPropertyComponent extends BackboneElement implements IBaseBackboneElement {
1150        /**
1151         * Code that specifies the property DeviceDefinitionPropetyCode (Extensible).
1152         */
1153        @Child(name = "type", type = {CodeableConcept.class}, order=1, min=1, max=1, modifier=false, summary=false)
1154        @Description(shortDefinition="Code that specifies the property DeviceDefinitionPropetyCode (Extensible)", formalDefinition="Code that specifies the property DeviceDefinitionPropetyCode (Extensible)." )
1155        protected CodeableConcept type;
1156
1157        /**
1158         * Property value as a quantity.
1159         */
1160        @Child(name = "valueQuantity", type = {Quantity.class}, order=2, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1161        @Description(shortDefinition="Property value as a quantity", formalDefinition="Property value as a quantity." )
1162        protected List<Quantity> valueQuantity;
1163
1164        /**
1165         * Property value as a code, e.g., NTP4 (synced to NTP).
1166         */
1167        @Child(name = "valueCode", type = {CodeableConcept.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1168        @Description(shortDefinition="Property value as a code, e.g., NTP4 (synced to NTP)", formalDefinition="Property value as a code, e.g., NTP4 (synced to NTP)." )
1169        protected List<CodeableConcept> valueCode;
1170
1171        private static final long serialVersionUID = 1512172633L;
1172
1173    /**
1174     * Constructor
1175     */
1176      public DeviceDefinitionPropertyComponent() {
1177        super();
1178      }
1179
1180    /**
1181     * Constructor
1182     */
1183      public DeviceDefinitionPropertyComponent(CodeableConcept type) {
1184        super();
1185        this.setType(type);
1186      }
1187
1188        /**
1189         * @return {@link #type} (Code that specifies the property DeviceDefinitionPropetyCode (Extensible).)
1190         */
1191        public CodeableConcept getType() { 
1192          if (this.type == null)
1193            if (Configuration.errorOnAutoCreate())
1194              throw new Error("Attempt to auto-create DeviceDefinitionPropertyComponent.type");
1195            else if (Configuration.doAutoCreate())
1196              this.type = new CodeableConcept(); // cc
1197          return this.type;
1198        }
1199
1200        public boolean hasType() { 
1201          return this.type != null && !this.type.isEmpty();
1202        }
1203
1204        /**
1205         * @param value {@link #type} (Code that specifies the property DeviceDefinitionPropetyCode (Extensible).)
1206         */
1207        public DeviceDefinitionPropertyComponent setType(CodeableConcept value) { 
1208          this.type = value;
1209          return this;
1210        }
1211
1212        /**
1213         * @return {@link #valueQuantity} (Property value as a quantity.)
1214         */
1215        public List<Quantity> getValueQuantity() { 
1216          if (this.valueQuantity == null)
1217            this.valueQuantity = new ArrayList<Quantity>();
1218          return this.valueQuantity;
1219        }
1220
1221        /**
1222         * @return Returns a reference to <code>this</code> for easy method chaining
1223         */
1224        public DeviceDefinitionPropertyComponent setValueQuantity(List<Quantity> theValueQuantity) { 
1225          this.valueQuantity = theValueQuantity;
1226          return this;
1227        }
1228
1229        public boolean hasValueQuantity() { 
1230          if (this.valueQuantity == null)
1231            return false;
1232          for (Quantity item : this.valueQuantity)
1233            if (!item.isEmpty())
1234              return true;
1235          return false;
1236        }
1237
1238        public Quantity addValueQuantity() { //3
1239          Quantity t = new Quantity();
1240          if (this.valueQuantity == null)
1241            this.valueQuantity = new ArrayList<Quantity>();
1242          this.valueQuantity.add(t);
1243          return t;
1244        }
1245
1246        public DeviceDefinitionPropertyComponent addValueQuantity(Quantity t) { //3
1247          if (t == null)
1248            return this;
1249          if (this.valueQuantity == null)
1250            this.valueQuantity = new ArrayList<Quantity>();
1251          this.valueQuantity.add(t);
1252          return this;
1253        }
1254
1255        /**
1256         * @return The first repetition of repeating field {@link #valueQuantity}, creating it if it does not already exist {3}
1257         */
1258        public Quantity getValueQuantityFirstRep() { 
1259          if (getValueQuantity().isEmpty()) {
1260            addValueQuantity();
1261          }
1262          return getValueQuantity().get(0);
1263        }
1264
1265        /**
1266         * @return {@link #valueCode} (Property value as a code, e.g., NTP4 (synced to NTP).)
1267         */
1268        public List<CodeableConcept> getValueCode() { 
1269          if (this.valueCode == null)
1270            this.valueCode = new ArrayList<CodeableConcept>();
1271          return this.valueCode;
1272        }
1273
1274        /**
1275         * @return Returns a reference to <code>this</code> for easy method chaining
1276         */
1277        public DeviceDefinitionPropertyComponent setValueCode(List<CodeableConcept> theValueCode) { 
1278          this.valueCode = theValueCode;
1279          return this;
1280        }
1281
1282        public boolean hasValueCode() { 
1283          if (this.valueCode == null)
1284            return false;
1285          for (CodeableConcept item : this.valueCode)
1286            if (!item.isEmpty())
1287              return true;
1288          return false;
1289        }
1290
1291        public CodeableConcept addValueCode() { //3
1292          CodeableConcept t = new CodeableConcept();
1293          if (this.valueCode == null)
1294            this.valueCode = new ArrayList<CodeableConcept>();
1295          this.valueCode.add(t);
1296          return t;
1297        }
1298
1299        public DeviceDefinitionPropertyComponent addValueCode(CodeableConcept t) { //3
1300          if (t == null)
1301            return this;
1302          if (this.valueCode == null)
1303            this.valueCode = new ArrayList<CodeableConcept>();
1304          this.valueCode.add(t);
1305          return this;
1306        }
1307
1308        /**
1309         * @return The first repetition of repeating field {@link #valueCode}, creating it if it does not already exist {3}
1310         */
1311        public CodeableConcept getValueCodeFirstRep() { 
1312          if (getValueCode().isEmpty()) {
1313            addValueCode();
1314          }
1315          return getValueCode().get(0);
1316        }
1317
1318        protected void listChildren(List<Property> children) {
1319          super.listChildren(children);
1320          children.add(new Property("type", "CodeableConcept", "Code that specifies the property DeviceDefinitionPropetyCode (Extensible).", 0, 1, type));
1321          children.add(new Property("valueQuantity", "Quantity", "Property value as a quantity.", 0, java.lang.Integer.MAX_VALUE, valueQuantity));
1322          children.add(new Property("valueCode", "CodeableConcept", "Property value as a code, e.g., NTP4 (synced to NTP).", 0, java.lang.Integer.MAX_VALUE, valueCode));
1323        }
1324
1325        @Override
1326        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1327          switch (_hash) {
1328          case 3575610: /*type*/  return new Property("type", "CodeableConcept", "Code that specifies the property DeviceDefinitionPropetyCode (Extensible).", 0, 1, type);
1329          case -2029823716: /*valueQuantity*/  return new Property("valueQuantity", "Quantity", "Property value as a quantity.", 0, java.lang.Integer.MAX_VALUE, valueQuantity);
1330          case -766209282: /*valueCode*/  return new Property("valueCode", "CodeableConcept", "Property value as a code, e.g., NTP4 (synced to NTP).", 0, java.lang.Integer.MAX_VALUE, valueCode);
1331          default: return super.getNamedProperty(_hash, _name, _checkValid);
1332          }
1333
1334        }
1335
1336      @Override
1337      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1338        switch (hash) {
1339        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // CodeableConcept
1340        case -2029823716: /*valueQuantity*/ return this.valueQuantity == null ? new Base[0] : this.valueQuantity.toArray(new Base[this.valueQuantity.size()]); // Quantity
1341        case -766209282: /*valueCode*/ return this.valueCode == null ? new Base[0] : this.valueCode.toArray(new Base[this.valueCode.size()]); // CodeableConcept
1342        default: return super.getProperty(hash, name, checkValid);
1343        }
1344
1345      }
1346
1347      @Override
1348      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1349        switch (hash) {
1350        case 3575610: // type
1351          this.type = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
1352          return value;
1353        case -2029823716: // valueQuantity
1354          this.getValueQuantity().add(TypeConvertor.castToQuantity(value)); // Quantity
1355          return value;
1356        case -766209282: // valueCode
1357          this.getValueCode().add(TypeConvertor.castToCodeableConcept(value)); // CodeableConcept
1358          return value;
1359        default: return super.setProperty(hash, name, value);
1360        }
1361
1362      }
1363
1364      @Override
1365      public Base setProperty(String name, Base value) throws FHIRException {
1366        if (name.equals("type")) {
1367          this.type = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
1368        } else if (name.equals("valueQuantity")) {
1369          this.getValueQuantity().add(TypeConvertor.castToQuantity(value));
1370        } else if (name.equals("valueCode")) {
1371          this.getValueCode().add(TypeConvertor.castToCodeableConcept(value));
1372        } else
1373          return super.setProperty(name, value);
1374        return value;
1375      }
1376
1377      @Override
1378      public Base makeProperty(int hash, String name) throws FHIRException {
1379        switch (hash) {
1380        case 3575610:  return getType();
1381        case -2029823716:  return addValueQuantity(); 
1382        case -766209282:  return addValueCode(); 
1383        default: return super.makeProperty(hash, name);
1384        }
1385
1386      }
1387
1388      @Override
1389      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1390        switch (hash) {
1391        case 3575610: /*type*/ return new String[] {"CodeableConcept"};
1392        case -2029823716: /*valueQuantity*/ return new String[] {"Quantity"};
1393        case -766209282: /*valueCode*/ return new String[] {"CodeableConcept"};
1394        default: return super.getTypesForProperty(hash, name);
1395        }
1396
1397      }
1398
1399      @Override
1400      public Base addChild(String name) throws FHIRException {
1401        if (name.equals("type")) {
1402          this.type = new CodeableConcept();
1403          return this.type;
1404        }
1405        else if (name.equals("valueQuantity")) {
1406          return addValueQuantity();
1407        }
1408        else if (name.equals("valueCode")) {
1409          return addValueCode();
1410        }
1411        else
1412          return super.addChild(name);
1413      }
1414
1415      public DeviceDefinitionPropertyComponent copy() {
1416        DeviceDefinitionPropertyComponent dst = new DeviceDefinitionPropertyComponent();
1417        copyValues(dst);
1418        return dst;
1419      }
1420
1421      public void copyValues(DeviceDefinitionPropertyComponent dst) {
1422        super.copyValues(dst);
1423        dst.type = type == null ? null : type.copy();
1424        if (valueQuantity != null) {
1425          dst.valueQuantity = new ArrayList<Quantity>();
1426          for (Quantity i : valueQuantity)
1427            dst.valueQuantity.add(i.copy());
1428        };
1429        if (valueCode != null) {
1430          dst.valueCode = new ArrayList<CodeableConcept>();
1431          for (CodeableConcept i : valueCode)
1432            dst.valueCode.add(i.copy());
1433        };
1434      }
1435
1436      @Override
1437      public boolean equalsDeep(Base other_) {
1438        if (!super.equalsDeep(other_))
1439          return false;
1440        if (!(other_ instanceof DeviceDefinitionPropertyComponent))
1441          return false;
1442        DeviceDefinitionPropertyComponent o = (DeviceDefinitionPropertyComponent) other_;
1443        return compareDeep(type, o.type, true) && compareDeep(valueQuantity, o.valueQuantity, true) && compareDeep(valueCode, o.valueCode, true)
1444          ;
1445      }
1446
1447      @Override
1448      public boolean equalsShallow(Base other_) {
1449        if (!super.equalsShallow(other_))
1450          return false;
1451        if (!(other_ instanceof DeviceDefinitionPropertyComponent))
1452          return false;
1453        DeviceDefinitionPropertyComponent o = (DeviceDefinitionPropertyComponent) other_;
1454        return true;
1455      }
1456
1457      public boolean isEmpty() {
1458        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(type, valueQuantity, valueCode
1459          );
1460      }
1461
1462  public String fhirType() {
1463    return "DeviceDefinition.property";
1464
1465  }
1466
1467  }
1468
1469    @Block()
1470    public static class DeviceDefinitionMaterialComponent extends BackboneElement implements IBaseBackboneElement {
1471        /**
1472         * The substance.
1473         */
1474        @Child(name = "substance", type = {CodeableConcept.class}, order=1, min=1, max=1, modifier=false, summary=false)
1475        @Description(shortDefinition="The substance", formalDefinition="The substance." )
1476        protected CodeableConcept substance;
1477
1478        /**
1479         * Indicates an alternative material of the device.
1480         */
1481        @Child(name = "alternate", type = {BooleanType.class}, order=2, min=0, max=1, modifier=false, summary=false)
1482        @Description(shortDefinition="Indicates an alternative material of the device", formalDefinition="Indicates an alternative material of the device." )
1483        protected BooleanType alternate;
1484
1485        /**
1486         * Whether the substance is a known or suspected allergen.
1487         */
1488        @Child(name = "allergenicIndicator", type = {BooleanType.class}, order=3, min=0, max=1, modifier=false, summary=false)
1489        @Description(shortDefinition="Whether the substance is a known or suspected allergen", formalDefinition="Whether the substance is a known or suspected allergen." )
1490        protected BooleanType allergenicIndicator;
1491
1492        private static final long serialVersionUID = 1232736508L;
1493
1494    /**
1495     * Constructor
1496     */
1497      public DeviceDefinitionMaterialComponent() {
1498        super();
1499      }
1500
1501    /**
1502     * Constructor
1503     */
1504      public DeviceDefinitionMaterialComponent(CodeableConcept substance) {
1505        super();
1506        this.setSubstance(substance);
1507      }
1508
1509        /**
1510         * @return {@link #substance} (The substance.)
1511         */
1512        public CodeableConcept getSubstance() { 
1513          if (this.substance == null)
1514            if (Configuration.errorOnAutoCreate())
1515              throw new Error("Attempt to auto-create DeviceDefinitionMaterialComponent.substance");
1516            else if (Configuration.doAutoCreate())
1517              this.substance = new CodeableConcept(); // cc
1518          return this.substance;
1519        }
1520
1521        public boolean hasSubstance() { 
1522          return this.substance != null && !this.substance.isEmpty();
1523        }
1524
1525        /**
1526         * @param value {@link #substance} (The substance.)
1527         */
1528        public DeviceDefinitionMaterialComponent setSubstance(CodeableConcept value) { 
1529          this.substance = value;
1530          return this;
1531        }
1532
1533        /**
1534         * @return {@link #alternate} (Indicates an alternative material of the device.). This is the underlying object with id, value and extensions. The accessor "getAlternate" gives direct access to the value
1535         */
1536        public BooleanType getAlternateElement() { 
1537          if (this.alternate == null)
1538            if (Configuration.errorOnAutoCreate())
1539              throw new Error("Attempt to auto-create DeviceDefinitionMaterialComponent.alternate");
1540            else if (Configuration.doAutoCreate())
1541              this.alternate = new BooleanType(); // bb
1542          return this.alternate;
1543        }
1544
1545        public boolean hasAlternateElement() { 
1546          return this.alternate != null && !this.alternate.isEmpty();
1547        }
1548
1549        public boolean hasAlternate() { 
1550          return this.alternate != null && !this.alternate.isEmpty();
1551        }
1552
1553        /**
1554         * @param value {@link #alternate} (Indicates an alternative material of the device.). This is the underlying object with id, value and extensions. The accessor "getAlternate" gives direct access to the value
1555         */
1556        public DeviceDefinitionMaterialComponent setAlternateElement(BooleanType value) { 
1557          this.alternate = value;
1558          return this;
1559        }
1560
1561        /**
1562         * @return Indicates an alternative material of the device.
1563         */
1564        public boolean getAlternate() { 
1565          return this.alternate == null || this.alternate.isEmpty() ? false : this.alternate.getValue();
1566        }
1567
1568        /**
1569         * @param value Indicates an alternative material of the device.
1570         */
1571        public DeviceDefinitionMaterialComponent setAlternate(boolean value) { 
1572            if (this.alternate == null)
1573              this.alternate = new BooleanType();
1574            this.alternate.setValue(value);
1575          return this;
1576        }
1577
1578        /**
1579         * @return {@link #allergenicIndicator} (Whether the substance is a known or suspected allergen.). This is the underlying object with id, value and extensions. The accessor "getAllergenicIndicator" gives direct access to the value
1580         */
1581        public BooleanType getAllergenicIndicatorElement() { 
1582          if (this.allergenicIndicator == null)
1583            if (Configuration.errorOnAutoCreate())
1584              throw new Error("Attempt to auto-create DeviceDefinitionMaterialComponent.allergenicIndicator");
1585            else if (Configuration.doAutoCreate())
1586              this.allergenicIndicator = new BooleanType(); // bb
1587          return this.allergenicIndicator;
1588        }
1589
1590        public boolean hasAllergenicIndicatorElement() { 
1591          return this.allergenicIndicator != null && !this.allergenicIndicator.isEmpty();
1592        }
1593
1594        public boolean hasAllergenicIndicator() { 
1595          return this.allergenicIndicator != null && !this.allergenicIndicator.isEmpty();
1596        }
1597
1598        /**
1599         * @param value {@link #allergenicIndicator} (Whether the substance is a known or suspected allergen.). This is the underlying object with id, value and extensions. The accessor "getAllergenicIndicator" gives direct access to the value
1600         */
1601        public DeviceDefinitionMaterialComponent setAllergenicIndicatorElement(BooleanType value) { 
1602          this.allergenicIndicator = value;
1603          return this;
1604        }
1605
1606        /**
1607         * @return Whether the substance is a known or suspected allergen.
1608         */
1609        public boolean getAllergenicIndicator() { 
1610          return this.allergenicIndicator == null || this.allergenicIndicator.isEmpty() ? false : this.allergenicIndicator.getValue();
1611        }
1612
1613        /**
1614         * @param value Whether the substance is a known or suspected allergen.
1615         */
1616        public DeviceDefinitionMaterialComponent setAllergenicIndicator(boolean value) { 
1617            if (this.allergenicIndicator == null)
1618              this.allergenicIndicator = new BooleanType();
1619            this.allergenicIndicator.setValue(value);
1620          return this;
1621        }
1622
1623        protected void listChildren(List<Property> children) {
1624          super.listChildren(children);
1625          children.add(new Property("substance", "CodeableConcept", "The substance.", 0, 1, substance));
1626          children.add(new Property("alternate", "boolean", "Indicates an alternative material of the device.", 0, 1, alternate));
1627          children.add(new Property("allergenicIndicator", "boolean", "Whether the substance is a known or suspected allergen.", 0, 1, allergenicIndicator));
1628        }
1629
1630        @Override
1631        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1632          switch (_hash) {
1633          case 530040176: /*substance*/  return new Property("substance", "CodeableConcept", "The substance.", 0, 1, substance);
1634          case -1408024454: /*alternate*/  return new Property("alternate", "boolean", "Indicates an alternative material of the device.", 0, 1, alternate);
1635          case 75406931: /*allergenicIndicator*/  return new Property("allergenicIndicator", "boolean", "Whether the substance is a known or suspected allergen.", 0, 1, allergenicIndicator);
1636          default: return super.getNamedProperty(_hash, _name, _checkValid);
1637          }
1638
1639        }
1640
1641      @Override
1642      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1643        switch (hash) {
1644        case 530040176: /*substance*/ return this.substance == null ? new Base[0] : new Base[] {this.substance}; // CodeableConcept
1645        case -1408024454: /*alternate*/ return this.alternate == null ? new Base[0] : new Base[] {this.alternate}; // BooleanType
1646        case 75406931: /*allergenicIndicator*/ return this.allergenicIndicator == null ? new Base[0] : new Base[] {this.allergenicIndicator}; // BooleanType
1647        default: return super.getProperty(hash, name, checkValid);
1648        }
1649
1650      }
1651
1652      @Override
1653      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1654        switch (hash) {
1655        case 530040176: // substance
1656          this.substance = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
1657          return value;
1658        case -1408024454: // alternate
1659          this.alternate = TypeConvertor.castToBoolean(value); // BooleanType
1660          return value;
1661        case 75406931: // allergenicIndicator
1662          this.allergenicIndicator = TypeConvertor.castToBoolean(value); // BooleanType
1663          return value;
1664        default: return super.setProperty(hash, name, value);
1665        }
1666
1667      }
1668
1669      @Override
1670      public Base setProperty(String name, Base value) throws FHIRException {
1671        if (name.equals("substance")) {
1672          this.substance = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
1673        } else if (name.equals("alternate")) {
1674          this.alternate = TypeConvertor.castToBoolean(value); // BooleanType
1675        } else if (name.equals("allergenicIndicator")) {
1676          this.allergenicIndicator = TypeConvertor.castToBoolean(value); // BooleanType
1677        } else
1678          return super.setProperty(name, value);
1679        return value;
1680      }
1681
1682      @Override
1683      public Base makeProperty(int hash, String name) throws FHIRException {
1684        switch (hash) {
1685        case 530040176:  return getSubstance();
1686        case -1408024454:  return getAlternateElement();
1687        case 75406931:  return getAllergenicIndicatorElement();
1688        default: return super.makeProperty(hash, name);
1689        }
1690
1691      }
1692
1693      @Override
1694      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1695        switch (hash) {
1696        case 530040176: /*substance*/ return new String[] {"CodeableConcept"};
1697        case -1408024454: /*alternate*/ return new String[] {"boolean"};
1698        case 75406931: /*allergenicIndicator*/ return new String[] {"boolean"};
1699        default: return super.getTypesForProperty(hash, name);
1700        }
1701
1702      }
1703
1704      @Override
1705      public Base addChild(String name) throws FHIRException {
1706        if (name.equals("substance")) {
1707          this.substance = new CodeableConcept();
1708          return this.substance;
1709        }
1710        else if (name.equals("alternate")) {
1711          throw new FHIRException("Cannot call addChild on a primitive type DeviceDefinition.material.alternate");
1712        }
1713        else if (name.equals("allergenicIndicator")) {
1714          throw new FHIRException("Cannot call addChild on a primitive type DeviceDefinition.material.allergenicIndicator");
1715        }
1716        else
1717          return super.addChild(name);
1718      }
1719
1720      public DeviceDefinitionMaterialComponent copy() {
1721        DeviceDefinitionMaterialComponent dst = new DeviceDefinitionMaterialComponent();
1722        copyValues(dst);
1723        return dst;
1724      }
1725
1726      public void copyValues(DeviceDefinitionMaterialComponent dst) {
1727        super.copyValues(dst);
1728        dst.substance = substance == null ? null : substance.copy();
1729        dst.alternate = alternate == null ? null : alternate.copy();
1730        dst.allergenicIndicator = allergenicIndicator == null ? null : allergenicIndicator.copy();
1731      }
1732
1733      @Override
1734      public boolean equalsDeep(Base other_) {
1735        if (!super.equalsDeep(other_))
1736          return false;
1737        if (!(other_ instanceof DeviceDefinitionMaterialComponent))
1738          return false;
1739        DeviceDefinitionMaterialComponent o = (DeviceDefinitionMaterialComponent) other_;
1740        return compareDeep(substance, o.substance, true) && compareDeep(alternate, o.alternate, true) && compareDeep(allergenicIndicator, o.allergenicIndicator, true)
1741          ;
1742      }
1743
1744      @Override
1745      public boolean equalsShallow(Base other_) {
1746        if (!super.equalsShallow(other_))
1747          return false;
1748        if (!(other_ instanceof DeviceDefinitionMaterialComponent))
1749          return false;
1750        DeviceDefinitionMaterialComponent o = (DeviceDefinitionMaterialComponent) other_;
1751        return compareValues(alternate, o.alternate, true) && compareValues(allergenicIndicator, o.allergenicIndicator, true)
1752          ;
1753      }
1754
1755      public boolean isEmpty() {
1756        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(substance, alternate, allergenicIndicator
1757          );
1758      }
1759
1760  public String fhirType() {
1761    return "DeviceDefinition.material";
1762
1763  }
1764
1765  }
1766
1767    /**
1768     * Unique instance identifiers assigned to a device by the software, manufacturers, other organizations or owners. For example: handle ID.
1769     */
1770    @Child(name = "identifier", type = {Identifier.class}, order=0, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1771    @Description(shortDefinition="Instance identifier", formalDefinition="Unique instance identifiers assigned to a device by the software, manufacturers, other organizations or owners. For example: handle ID." )
1772    protected List<Identifier> identifier;
1773
1774    /**
1775     * 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.
1776     */
1777    @Child(name = "udiDeviceIdentifier", type = {}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1778    @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." )
1779    protected List<DeviceDefinitionUdiDeviceIdentifierComponent> udiDeviceIdentifier;
1780
1781    /**
1782     * A name of the manufacturer.
1783     */
1784    @Child(name = "manufacturer", type = {StringType.class, Organization.class}, order=2, min=0, max=1, modifier=false, summary=false)
1785    @Description(shortDefinition="Name of device manufacturer", formalDefinition="A name of the manufacturer." )
1786    protected DataType manufacturer;
1787
1788    /**
1789     * A name given to the device to identify it.
1790     */
1791    @Child(name = "deviceName", type = {}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1792    @Description(shortDefinition="A name given to the device to identify it", formalDefinition="A name given to the device to identify it." )
1793    protected List<DeviceDefinitionDeviceNameComponent> deviceName;
1794
1795    /**
1796     * The model number for the device.
1797     */
1798    @Child(name = "modelNumber", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=false)
1799    @Description(shortDefinition="The model number for the device", formalDefinition="The model number for the device." )
1800    protected StringType modelNumber;
1801
1802    /**
1803     * What kind of device or device system this is.
1804     */
1805    @Child(name = "type", type = {CodeableConcept.class}, order=5, min=0, max=1, modifier=false, summary=false)
1806    @Description(shortDefinition="What kind of device or device system this is", formalDefinition="What kind of device or device system this is." )
1807    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/device-kind")
1808    protected CodeableConcept type;
1809
1810    /**
1811     * The capabilities supported on a  device, the standards to which the device conforms for a particular purpose, and used for the communication.
1812     */
1813    @Child(name = "specialization", type = {}, order=6, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1814    @Description(shortDefinition="The capabilities supported on a  device, the standards to which the device conforms for a particular purpose, and used for the communication", formalDefinition="The capabilities supported on a  device, the standards to which the device conforms for a particular purpose, and used for the communication." )
1815    protected List<DeviceDefinitionSpecializationComponent> specialization;
1816
1817    /**
1818     * The available versions of the device, e.g., software versions.
1819     */
1820    @Child(name = "version", type = {StringType.class}, order=7, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1821    @Description(shortDefinition="Available versions", formalDefinition="The available versions of the device, e.g., software versions." )
1822    protected List<StringType> version;
1823
1824    /**
1825     * Safety characteristics of the device.
1826     */
1827    @Child(name = "safety", type = {CodeableConcept.class}, order=8, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
1828    @Description(shortDefinition="Safety characteristics of the device", formalDefinition="Safety characteristics of the device." )
1829    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/device-safety")
1830    protected List<CodeableConcept> safety;
1831
1832    /**
1833     * Shelf Life and storage information.
1834     */
1835    @Child(name = "shelfLifeStorage", type = {ProductShelfLife.class}, order=9, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1836    @Description(shortDefinition="Shelf Life and storage information", formalDefinition="Shelf Life and storage information." )
1837    protected List<ProductShelfLife> shelfLifeStorage;
1838
1839    /**
1840     * Dimensions, color etc.
1841     */
1842    @Child(name = "physicalCharacteristics", type = {ProdCharacteristic.class}, order=10, min=0, max=1, modifier=false, summary=false)
1843    @Description(shortDefinition="Dimensions, color etc.", formalDefinition="Dimensions, color etc." )
1844    protected ProdCharacteristic physicalCharacteristics;
1845
1846    /**
1847     * Language code for the human-readable text strings produced by the device (all supported).
1848     */
1849    @Child(name = "languageCode", type = {CodeableConcept.class}, order=11, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1850    @Description(shortDefinition="Language code for the human-readable text strings produced by the device (all supported)", formalDefinition="Language code for the human-readable text strings produced by the device (all supported)." )
1851    protected List<CodeableConcept> languageCode;
1852
1853    /**
1854     * Device capabilities.
1855     */
1856    @Child(name = "capability", type = {}, order=12, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1857    @Description(shortDefinition="Device capabilities", formalDefinition="Device capabilities." )
1858    protected List<DeviceDefinitionCapabilityComponent> capability;
1859
1860    /**
1861     * The actual configuration settings of a device as it actually operates, e.g., regulation status, time properties.
1862     */
1863    @Child(name = "property", type = {}, order=13, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1864    @Description(shortDefinition="The actual configuration settings of a device as it actually operates, e.g., regulation status, time properties", formalDefinition="The actual configuration settings of a device as it actually operates, e.g., regulation status, time properties." )
1865    protected List<DeviceDefinitionPropertyComponent> property;
1866
1867    /**
1868     * An organization that is responsible for the provision and ongoing maintenance of the device.
1869     */
1870    @Child(name = "owner", type = {Organization.class}, order=14, min=0, max=1, modifier=false, summary=false)
1871    @Description(shortDefinition="Organization responsible for device", formalDefinition="An organization that is responsible for the provision and ongoing maintenance of the device." )
1872    protected Reference owner;
1873
1874    /**
1875     * Contact details for an organization or a particular human that is responsible for the device.
1876     */
1877    @Child(name = "contact", type = {ContactPoint.class}, order=15, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1878    @Description(shortDefinition="Details for human/organization for support", formalDefinition="Contact details for an organization or a particular human that is responsible for the device." )
1879    protected List<ContactPoint> contact;
1880
1881    /**
1882     * A network address on which the device may be contacted directly.
1883     */
1884    @Child(name = "url", type = {UriType.class}, order=16, min=0, max=1, modifier=false, summary=false)
1885    @Description(shortDefinition="Network address to contact device", formalDefinition="A network address on which the device may be contacted directly." )
1886    protected UriType url;
1887
1888    /**
1889     * Access to on-line information about the device.
1890     */
1891    @Child(name = "onlineInformation", type = {UriType.class}, order=17, min=0, max=1, modifier=false, summary=false)
1892    @Description(shortDefinition="Access to on-line information", formalDefinition="Access to on-line information about the device." )
1893    protected UriType onlineInformation;
1894
1895    /**
1896     * Descriptive information, usage information or implantation information that is not captured in an existing element.
1897     */
1898    @Child(name = "note", type = {Annotation.class}, order=18, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1899    @Description(shortDefinition="Device notes and comments", formalDefinition="Descriptive information, usage information or implantation information that is not captured in an existing element." )
1900    protected List<Annotation> note;
1901
1902    /**
1903     * The quantity of the device present in the packaging (e.g. the number of devices present in a pack, or the number of devices in the same package of the medicinal product).
1904     */
1905    @Child(name = "quantity", type = {Quantity.class}, order=19, min=0, max=1, modifier=false, summary=false)
1906    @Description(shortDefinition="The quantity of the device present in the packaging (e.g. the number of devices present in a pack, or the number of devices in the same package of the medicinal product)", formalDefinition="The quantity of the device present in the packaging (e.g. the number of devices present in a pack, or the number of devices in the same package of the medicinal product)." )
1907    protected Quantity quantity;
1908
1909    /**
1910     * The parent device it can be part of.
1911     */
1912    @Child(name = "parentDevice", type = {DeviceDefinition.class}, order=20, min=0, max=1, modifier=false, summary=true)
1913    @Description(shortDefinition="The parent device it can be part of", formalDefinition="The parent device it can be part of." )
1914    protected Reference parentDevice;
1915
1916    /**
1917     * A substance used to create the material(s) of which the device is made.
1918     */
1919    @Child(name = "material", type = {}, order=21, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1920    @Description(shortDefinition="A substance used to create the material(s) of which the device is made", formalDefinition="A substance used to create the material(s) of which the device is made." )
1921    protected List<DeviceDefinitionMaterialComponent> material;
1922
1923    private static final long serialVersionUID = 740460962L;
1924
1925  /**
1926   * Constructor
1927   */
1928    public DeviceDefinition() {
1929      super();
1930    }
1931
1932    /**
1933     * @return {@link #identifier} (Unique instance identifiers assigned to a device by the software, manufacturers, other organizations or owners. For example: handle ID.)
1934     */
1935    public List<Identifier> getIdentifier() { 
1936      if (this.identifier == null)
1937        this.identifier = new ArrayList<Identifier>();
1938      return this.identifier;
1939    }
1940
1941    /**
1942     * @return Returns a reference to <code>this</code> for easy method chaining
1943     */
1944    public DeviceDefinition setIdentifier(List<Identifier> theIdentifier) { 
1945      this.identifier = theIdentifier;
1946      return this;
1947    }
1948
1949    public boolean hasIdentifier() { 
1950      if (this.identifier == null)
1951        return false;
1952      for (Identifier item : this.identifier)
1953        if (!item.isEmpty())
1954          return true;
1955      return false;
1956    }
1957
1958    public Identifier addIdentifier() { //3
1959      Identifier t = new Identifier();
1960      if (this.identifier == null)
1961        this.identifier = new ArrayList<Identifier>();
1962      this.identifier.add(t);
1963      return t;
1964    }
1965
1966    public DeviceDefinition addIdentifier(Identifier t) { //3
1967      if (t == null)
1968        return this;
1969      if (this.identifier == null)
1970        this.identifier = new ArrayList<Identifier>();
1971      this.identifier.add(t);
1972      return this;
1973    }
1974
1975    /**
1976     * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist {3}
1977     */
1978    public Identifier getIdentifierFirstRep() { 
1979      if (getIdentifier().isEmpty()) {
1980        addIdentifier();
1981      }
1982      return getIdentifier().get(0);
1983    }
1984
1985    /**
1986     * @return {@link #udiDeviceIdentifier} (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.)
1987     */
1988    public List<DeviceDefinitionUdiDeviceIdentifierComponent> getUdiDeviceIdentifier() { 
1989      if (this.udiDeviceIdentifier == null)
1990        this.udiDeviceIdentifier = new ArrayList<DeviceDefinitionUdiDeviceIdentifierComponent>();
1991      return this.udiDeviceIdentifier;
1992    }
1993
1994    /**
1995     * @return Returns a reference to <code>this</code> for easy method chaining
1996     */
1997    public DeviceDefinition setUdiDeviceIdentifier(List<DeviceDefinitionUdiDeviceIdentifierComponent> theUdiDeviceIdentifier) { 
1998      this.udiDeviceIdentifier = theUdiDeviceIdentifier;
1999      return this;
2000    }
2001
2002    public boolean hasUdiDeviceIdentifier() { 
2003      if (this.udiDeviceIdentifier == null)
2004        return false;
2005      for (DeviceDefinitionUdiDeviceIdentifierComponent item : this.udiDeviceIdentifier)
2006        if (!item.isEmpty())
2007          return true;
2008      return false;
2009    }
2010
2011    public DeviceDefinitionUdiDeviceIdentifierComponent addUdiDeviceIdentifier() { //3
2012      DeviceDefinitionUdiDeviceIdentifierComponent t = new DeviceDefinitionUdiDeviceIdentifierComponent();
2013      if (this.udiDeviceIdentifier == null)
2014        this.udiDeviceIdentifier = new ArrayList<DeviceDefinitionUdiDeviceIdentifierComponent>();
2015      this.udiDeviceIdentifier.add(t);
2016      return t;
2017    }
2018
2019    public DeviceDefinition addUdiDeviceIdentifier(DeviceDefinitionUdiDeviceIdentifierComponent t) { //3
2020      if (t == null)
2021        return this;
2022      if (this.udiDeviceIdentifier == null)
2023        this.udiDeviceIdentifier = new ArrayList<DeviceDefinitionUdiDeviceIdentifierComponent>();
2024      this.udiDeviceIdentifier.add(t);
2025      return this;
2026    }
2027
2028    /**
2029     * @return The first repetition of repeating field {@link #udiDeviceIdentifier}, creating it if it does not already exist {3}
2030     */
2031    public DeviceDefinitionUdiDeviceIdentifierComponent getUdiDeviceIdentifierFirstRep() { 
2032      if (getUdiDeviceIdentifier().isEmpty()) {
2033        addUdiDeviceIdentifier();
2034      }
2035      return getUdiDeviceIdentifier().get(0);
2036    }
2037
2038    /**
2039     * @return {@link #manufacturer} (A name of the manufacturer.)
2040     */
2041    public DataType getManufacturer() { 
2042      return this.manufacturer;
2043    }
2044
2045    /**
2046     * @return {@link #manufacturer} (A name of the manufacturer.)
2047     */
2048    public StringType getManufacturerStringType() throws FHIRException { 
2049      if (this.manufacturer == null)
2050        this.manufacturer = new StringType();
2051      if (!(this.manufacturer instanceof StringType))
2052        throw new FHIRException("Type mismatch: the type StringType was expected, but "+this.manufacturer.getClass().getName()+" was encountered");
2053      return (StringType) this.manufacturer;
2054    }
2055
2056    public boolean hasManufacturerStringType() { 
2057      return this != null && this.manufacturer instanceof StringType;
2058    }
2059
2060    /**
2061     * @return {@link #manufacturer} (A name of the manufacturer.)
2062     */
2063    public Reference getManufacturerReference() throws FHIRException { 
2064      if (this.manufacturer == null)
2065        this.manufacturer = new Reference();
2066      if (!(this.manufacturer instanceof Reference))
2067        throw new FHIRException("Type mismatch: the type Reference was expected, but "+this.manufacturer.getClass().getName()+" was encountered");
2068      return (Reference) this.manufacturer;
2069    }
2070
2071    public boolean hasManufacturerReference() { 
2072      return this != null && this.manufacturer instanceof Reference;
2073    }
2074
2075    public boolean hasManufacturer() { 
2076      return this.manufacturer != null && !this.manufacturer.isEmpty();
2077    }
2078
2079    /**
2080     * @param value {@link #manufacturer} (A name of the manufacturer.)
2081     */
2082    public DeviceDefinition setManufacturer(DataType value) { 
2083      if (value != null && !(value instanceof StringType || value instanceof Reference))
2084        throw new Error("Not the right type for DeviceDefinition.manufacturer[x]: "+value.fhirType());
2085      this.manufacturer = value;
2086      return this;
2087    }
2088
2089    /**
2090     * @return {@link #deviceName} (A name given to the device to identify it.)
2091     */
2092    public List<DeviceDefinitionDeviceNameComponent> getDeviceName() { 
2093      if (this.deviceName == null)
2094        this.deviceName = new ArrayList<DeviceDefinitionDeviceNameComponent>();
2095      return this.deviceName;
2096    }
2097
2098    /**
2099     * @return Returns a reference to <code>this</code> for easy method chaining
2100     */
2101    public DeviceDefinition setDeviceName(List<DeviceDefinitionDeviceNameComponent> theDeviceName) { 
2102      this.deviceName = theDeviceName;
2103      return this;
2104    }
2105
2106    public boolean hasDeviceName() { 
2107      if (this.deviceName == null)
2108        return false;
2109      for (DeviceDefinitionDeviceNameComponent item : this.deviceName)
2110        if (!item.isEmpty())
2111          return true;
2112      return false;
2113    }
2114
2115    public DeviceDefinitionDeviceNameComponent addDeviceName() { //3
2116      DeviceDefinitionDeviceNameComponent t = new DeviceDefinitionDeviceNameComponent();
2117      if (this.deviceName == null)
2118        this.deviceName = new ArrayList<DeviceDefinitionDeviceNameComponent>();
2119      this.deviceName.add(t);
2120      return t;
2121    }
2122
2123    public DeviceDefinition addDeviceName(DeviceDefinitionDeviceNameComponent t) { //3
2124      if (t == null)
2125        return this;
2126      if (this.deviceName == null)
2127        this.deviceName = new ArrayList<DeviceDefinitionDeviceNameComponent>();
2128      this.deviceName.add(t);
2129      return this;
2130    }
2131
2132    /**
2133     * @return The first repetition of repeating field {@link #deviceName}, creating it if it does not already exist {3}
2134     */
2135    public DeviceDefinitionDeviceNameComponent getDeviceNameFirstRep() { 
2136      if (getDeviceName().isEmpty()) {
2137        addDeviceName();
2138      }
2139      return getDeviceName().get(0);
2140    }
2141
2142    /**
2143     * @return {@link #modelNumber} (The model number for the device.). This is the underlying object with id, value and extensions. The accessor "getModelNumber" gives direct access to the value
2144     */
2145    public StringType getModelNumberElement() { 
2146      if (this.modelNumber == null)
2147        if (Configuration.errorOnAutoCreate())
2148          throw new Error("Attempt to auto-create DeviceDefinition.modelNumber");
2149        else if (Configuration.doAutoCreate())
2150          this.modelNumber = new StringType(); // bb
2151      return this.modelNumber;
2152    }
2153
2154    public boolean hasModelNumberElement() { 
2155      return this.modelNumber != null && !this.modelNumber.isEmpty();
2156    }
2157
2158    public boolean hasModelNumber() { 
2159      return this.modelNumber != null && !this.modelNumber.isEmpty();
2160    }
2161
2162    /**
2163     * @param value {@link #modelNumber} (The model number for the device.). This is the underlying object with id, value and extensions. The accessor "getModelNumber" gives direct access to the value
2164     */
2165    public DeviceDefinition setModelNumberElement(StringType value) { 
2166      this.modelNumber = value;
2167      return this;
2168    }
2169
2170    /**
2171     * @return The model number for the device.
2172     */
2173    public String getModelNumber() { 
2174      return this.modelNumber == null ? null : this.modelNumber.getValue();
2175    }
2176
2177    /**
2178     * @param value The model number for the device.
2179     */
2180    public DeviceDefinition setModelNumber(String value) { 
2181      if (Utilities.noString(value))
2182        this.modelNumber = null;
2183      else {
2184        if (this.modelNumber == null)
2185          this.modelNumber = new StringType();
2186        this.modelNumber.setValue(value);
2187      }
2188      return this;
2189    }
2190
2191    /**
2192     * @return {@link #type} (What kind of device or device system this is.)
2193     */
2194    public CodeableConcept getType() { 
2195      if (this.type == null)
2196        if (Configuration.errorOnAutoCreate())
2197          throw new Error("Attempt to auto-create DeviceDefinition.type");
2198        else if (Configuration.doAutoCreate())
2199          this.type = new CodeableConcept(); // cc
2200      return this.type;
2201    }
2202
2203    public boolean hasType() { 
2204      return this.type != null && !this.type.isEmpty();
2205    }
2206
2207    /**
2208     * @param value {@link #type} (What kind of device or device system this is.)
2209     */
2210    public DeviceDefinition setType(CodeableConcept value) { 
2211      this.type = value;
2212      return this;
2213    }
2214
2215    /**
2216     * @return {@link #specialization} (The capabilities supported on a  device, the standards to which the device conforms for a particular purpose, and used for the communication.)
2217     */
2218    public List<DeviceDefinitionSpecializationComponent> getSpecialization() { 
2219      if (this.specialization == null)
2220        this.specialization = new ArrayList<DeviceDefinitionSpecializationComponent>();
2221      return this.specialization;
2222    }
2223
2224    /**
2225     * @return Returns a reference to <code>this</code> for easy method chaining
2226     */
2227    public DeviceDefinition setSpecialization(List<DeviceDefinitionSpecializationComponent> theSpecialization) { 
2228      this.specialization = theSpecialization;
2229      return this;
2230    }
2231
2232    public boolean hasSpecialization() { 
2233      if (this.specialization == null)
2234        return false;
2235      for (DeviceDefinitionSpecializationComponent item : this.specialization)
2236        if (!item.isEmpty())
2237          return true;
2238      return false;
2239    }
2240
2241    public DeviceDefinitionSpecializationComponent addSpecialization() { //3
2242      DeviceDefinitionSpecializationComponent t = new DeviceDefinitionSpecializationComponent();
2243      if (this.specialization == null)
2244        this.specialization = new ArrayList<DeviceDefinitionSpecializationComponent>();
2245      this.specialization.add(t);
2246      return t;
2247    }
2248
2249    public DeviceDefinition addSpecialization(DeviceDefinitionSpecializationComponent t) { //3
2250      if (t == null)
2251        return this;
2252      if (this.specialization == null)
2253        this.specialization = new ArrayList<DeviceDefinitionSpecializationComponent>();
2254      this.specialization.add(t);
2255      return this;
2256    }
2257
2258    /**
2259     * @return The first repetition of repeating field {@link #specialization}, creating it if it does not already exist {3}
2260     */
2261    public DeviceDefinitionSpecializationComponent getSpecializationFirstRep() { 
2262      if (getSpecialization().isEmpty()) {
2263        addSpecialization();
2264      }
2265      return getSpecialization().get(0);
2266    }
2267
2268    /**
2269     * @return {@link #version} (The available versions of the device, e.g., software versions.)
2270     */
2271    public List<StringType> getVersion() { 
2272      if (this.version == null)
2273        this.version = new ArrayList<StringType>();
2274      return this.version;
2275    }
2276
2277    /**
2278     * @return Returns a reference to <code>this</code> for easy method chaining
2279     */
2280    public DeviceDefinition setVersion(List<StringType> theVersion) { 
2281      this.version = theVersion;
2282      return this;
2283    }
2284
2285    public boolean hasVersion() { 
2286      if (this.version == null)
2287        return false;
2288      for (StringType item : this.version)
2289        if (!item.isEmpty())
2290          return true;
2291      return false;
2292    }
2293
2294    /**
2295     * @return {@link #version} (The available versions of the device, e.g., software versions.)
2296     */
2297    public StringType addVersionElement() {//2 
2298      StringType t = new StringType();
2299      if (this.version == null)
2300        this.version = new ArrayList<StringType>();
2301      this.version.add(t);
2302      return t;
2303    }
2304
2305    /**
2306     * @param value {@link #version} (The available versions of the device, e.g., software versions.)
2307     */
2308    public DeviceDefinition addVersion(String value) { //1
2309      StringType t = new StringType();
2310      t.setValue(value);
2311      if (this.version == null)
2312        this.version = new ArrayList<StringType>();
2313      this.version.add(t);
2314      return this;
2315    }
2316
2317    /**
2318     * @param value {@link #version} (The available versions of the device, e.g., software versions.)
2319     */
2320    public boolean hasVersion(String value) { 
2321      if (this.version == null)
2322        return false;
2323      for (StringType v : this.version)
2324        if (v.getValue().equals(value)) // string
2325          return true;
2326      return false;
2327    }
2328
2329    /**
2330     * @return {@link #safety} (Safety characteristics of the device.)
2331     */
2332    public List<CodeableConcept> getSafety() { 
2333      if (this.safety == null)
2334        this.safety = new ArrayList<CodeableConcept>();
2335      return this.safety;
2336    }
2337
2338    /**
2339     * @return Returns a reference to <code>this</code> for easy method chaining
2340     */
2341    public DeviceDefinition setSafety(List<CodeableConcept> theSafety) { 
2342      this.safety = theSafety;
2343      return this;
2344    }
2345
2346    public boolean hasSafety() { 
2347      if (this.safety == null)
2348        return false;
2349      for (CodeableConcept item : this.safety)
2350        if (!item.isEmpty())
2351          return true;
2352      return false;
2353    }
2354
2355    public CodeableConcept addSafety() { //3
2356      CodeableConcept t = new CodeableConcept();
2357      if (this.safety == null)
2358        this.safety = new ArrayList<CodeableConcept>();
2359      this.safety.add(t);
2360      return t;
2361    }
2362
2363    public DeviceDefinition addSafety(CodeableConcept t) { //3
2364      if (t == null)
2365        return this;
2366      if (this.safety == null)
2367        this.safety = new ArrayList<CodeableConcept>();
2368      this.safety.add(t);
2369      return this;
2370    }
2371
2372    /**
2373     * @return The first repetition of repeating field {@link #safety}, creating it if it does not already exist {3}
2374     */
2375    public CodeableConcept getSafetyFirstRep() { 
2376      if (getSafety().isEmpty()) {
2377        addSafety();
2378      }
2379      return getSafety().get(0);
2380    }
2381
2382    /**
2383     * @return {@link #shelfLifeStorage} (Shelf Life and storage information.)
2384     */
2385    public List<ProductShelfLife> getShelfLifeStorage() { 
2386      if (this.shelfLifeStorage == null)
2387        this.shelfLifeStorage = new ArrayList<ProductShelfLife>();
2388      return this.shelfLifeStorage;
2389    }
2390
2391    /**
2392     * @return Returns a reference to <code>this</code> for easy method chaining
2393     */
2394    public DeviceDefinition setShelfLifeStorage(List<ProductShelfLife> theShelfLifeStorage) { 
2395      this.shelfLifeStorage = theShelfLifeStorage;
2396      return this;
2397    }
2398
2399    public boolean hasShelfLifeStorage() { 
2400      if (this.shelfLifeStorage == null)
2401        return false;
2402      for (ProductShelfLife item : this.shelfLifeStorage)
2403        if (!item.isEmpty())
2404          return true;
2405      return false;
2406    }
2407
2408    public ProductShelfLife addShelfLifeStorage() { //3
2409      ProductShelfLife t = new ProductShelfLife();
2410      if (this.shelfLifeStorage == null)
2411        this.shelfLifeStorage = new ArrayList<ProductShelfLife>();
2412      this.shelfLifeStorage.add(t);
2413      return t;
2414    }
2415
2416    public DeviceDefinition addShelfLifeStorage(ProductShelfLife t) { //3
2417      if (t == null)
2418        return this;
2419      if (this.shelfLifeStorage == null)
2420        this.shelfLifeStorage = new ArrayList<ProductShelfLife>();
2421      this.shelfLifeStorage.add(t);
2422      return this;
2423    }
2424
2425    /**
2426     * @return The first repetition of repeating field {@link #shelfLifeStorage}, creating it if it does not already exist {3}
2427     */
2428    public ProductShelfLife getShelfLifeStorageFirstRep() { 
2429      if (getShelfLifeStorage().isEmpty()) {
2430        addShelfLifeStorage();
2431      }
2432      return getShelfLifeStorage().get(0);
2433    }
2434
2435    /**
2436     * @return {@link #physicalCharacteristics} (Dimensions, color etc.)
2437     */
2438    public ProdCharacteristic getPhysicalCharacteristics() { 
2439      if (this.physicalCharacteristics == null)
2440        if (Configuration.errorOnAutoCreate())
2441          throw new Error("Attempt to auto-create DeviceDefinition.physicalCharacteristics");
2442        else if (Configuration.doAutoCreate())
2443          this.physicalCharacteristics = new ProdCharacteristic(); // cc
2444      return this.physicalCharacteristics;
2445    }
2446
2447    public boolean hasPhysicalCharacteristics() { 
2448      return this.physicalCharacteristics != null && !this.physicalCharacteristics.isEmpty();
2449    }
2450
2451    /**
2452     * @param value {@link #physicalCharacteristics} (Dimensions, color etc.)
2453     */
2454    public DeviceDefinition setPhysicalCharacteristics(ProdCharacteristic value) { 
2455      this.physicalCharacteristics = value;
2456      return this;
2457    }
2458
2459    /**
2460     * @return {@link #languageCode} (Language code for the human-readable text strings produced by the device (all supported).)
2461     */
2462    public List<CodeableConcept> getLanguageCode() { 
2463      if (this.languageCode == null)
2464        this.languageCode = new ArrayList<CodeableConcept>();
2465      return this.languageCode;
2466    }
2467
2468    /**
2469     * @return Returns a reference to <code>this</code> for easy method chaining
2470     */
2471    public DeviceDefinition setLanguageCode(List<CodeableConcept> theLanguageCode) { 
2472      this.languageCode = theLanguageCode;
2473      return this;
2474    }
2475
2476    public boolean hasLanguageCode() { 
2477      if (this.languageCode == null)
2478        return false;
2479      for (CodeableConcept item : this.languageCode)
2480        if (!item.isEmpty())
2481          return true;
2482      return false;
2483    }
2484
2485    public CodeableConcept addLanguageCode() { //3
2486      CodeableConcept t = new CodeableConcept();
2487      if (this.languageCode == null)
2488        this.languageCode = new ArrayList<CodeableConcept>();
2489      this.languageCode.add(t);
2490      return t;
2491    }
2492
2493    public DeviceDefinition addLanguageCode(CodeableConcept t) { //3
2494      if (t == null)
2495        return this;
2496      if (this.languageCode == null)
2497        this.languageCode = new ArrayList<CodeableConcept>();
2498      this.languageCode.add(t);
2499      return this;
2500    }
2501
2502    /**
2503     * @return The first repetition of repeating field {@link #languageCode}, creating it if it does not already exist {3}
2504     */
2505    public CodeableConcept getLanguageCodeFirstRep() { 
2506      if (getLanguageCode().isEmpty()) {
2507        addLanguageCode();
2508      }
2509      return getLanguageCode().get(0);
2510    }
2511
2512    /**
2513     * @return {@link #capability} (Device capabilities.)
2514     */
2515    public List<DeviceDefinitionCapabilityComponent> getCapability() { 
2516      if (this.capability == null)
2517        this.capability = new ArrayList<DeviceDefinitionCapabilityComponent>();
2518      return this.capability;
2519    }
2520
2521    /**
2522     * @return Returns a reference to <code>this</code> for easy method chaining
2523     */
2524    public DeviceDefinition setCapability(List<DeviceDefinitionCapabilityComponent> theCapability) { 
2525      this.capability = theCapability;
2526      return this;
2527    }
2528
2529    public boolean hasCapability() { 
2530      if (this.capability == null)
2531        return false;
2532      for (DeviceDefinitionCapabilityComponent item : this.capability)
2533        if (!item.isEmpty())
2534          return true;
2535      return false;
2536    }
2537
2538    public DeviceDefinitionCapabilityComponent addCapability() { //3
2539      DeviceDefinitionCapabilityComponent t = new DeviceDefinitionCapabilityComponent();
2540      if (this.capability == null)
2541        this.capability = new ArrayList<DeviceDefinitionCapabilityComponent>();
2542      this.capability.add(t);
2543      return t;
2544    }
2545
2546    public DeviceDefinition addCapability(DeviceDefinitionCapabilityComponent t) { //3
2547      if (t == null)
2548        return this;
2549      if (this.capability == null)
2550        this.capability = new ArrayList<DeviceDefinitionCapabilityComponent>();
2551      this.capability.add(t);
2552      return this;
2553    }
2554
2555    /**
2556     * @return The first repetition of repeating field {@link #capability}, creating it if it does not already exist {3}
2557     */
2558    public DeviceDefinitionCapabilityComponent getCapabilityFirstRep() { 
2559      if (getCapability().isEmpty()) {
2560        addCapability();
2561      }
2562      return getCapability().get(0);
2563    }
2564
2565    /**
2566     * @return {@link #property} (The actual configuration settings of a device as it actually operates, e.g., regulation status, time properties.)
2567     */
2568    public List<DeviceDefinitionPropertyComponent> getProperty() { 
2569      if (this.property == null)
2570        this.property = new ArrayList<DeviceDefinitionPropertyComponent>();
2571      return this.property;
2572    }
2573
2574    /**
2575     * @return Returns a reference to <code>this</code> for easy method chaining
2576     */
2577    public DeviceDefinition setProperty(List<DeviceDefinitionPropertyComponent> theProperty) { 
2578      this.property = theProperty;
2579      return this;
2580    }
2581
2582    public boolean hasProperty() { 
2583      if (this.property == null)
2584        return false;
2585      for (DeviceDefinitionPropertyComponent item : this.property)
2586        if (!item.isEmpty())
2587          return true;
2588      return false;
2589    }
2590
2591    public DeviceDefinitionPropertyComponent addProperty() { //3
2592      DeviceDefinitionPropertyComponent t = new DeviceDefinitionPropertyComponent();
2593      if (this.property == null)
2594        this.property = new ArrayList<DeviceDefinitionPropertyComponent>();
2595      this.property.add(t);
2596      return t;
2597    }
2598
2599    public DeviceDefinition addProperty(DeviceDefinitionPropertyComponent t) { //3
2600      if (t == null)
2601        return this;
2602      if (this.property == null)
2603        this.property = new ArrayList<DeviceDefinitionPropertyComponent>();
2604      this.property.add(t);
2605      return this;
2606    }
2607
2608    /**
2609     * @return The first repetition of repeating field {@link #property}, creating it if it does not already exist {3}
2610     */
2611    public DeviceDefinitionPropertyComponent getPropertyFirstRep() { 
2612      if (getProperty().isEmpty()) {
2613        addProperty();
2614      }
2615      return getProperty().get(0);
2616    }
2617
2618    /**
2619     * @return {@link #owner} (An organization that is responsible for the provision and ongoing maintenance of the device.)
2620     */
2621    public Reference getOwner() { 
2622      if (this.owner == null)
2623        if (Configuration.errorOnAutoCreate())
2624          throw new Error("Attempt to auto-create DeviceDefinition.owner");
2625        else if (Configuration.doAutoCreate())
2626          this.owner = new Reference(); // cc
2627      return this.owner;
2628    }
2629
2630    public boolean hasOwner() { 
2631      return this.owner != null && !this.owner.isEmpty();
2632    }
2633
2634    /**
2635     * @param value {@link #owner} (An organization that is responsible for the provision and ongoing maintenance of the device.)
2636     */
2637    public DeviceDefinition setOwner(Reference value) { 
2638      this.owner = value;
2639      return this;
2640    }
2641
2642    /**
2643     * @return {@link #contact} (Contact details for an organization or a particular human that is responsible for the device.)
2644     */
2645    public List<ContactPoint> getContact() { 
2646      if (this.contact == null)
2647        this.contact = new ArrayList<ContactPoint>();
2648      return this.contact;
2649    }
2650
2651    /**
2652     * @return Returns a reference to <code>this</code> for easy method chaining
2653     */
2654    public DeviceDefinition setContact(List<ContactPoint> theContact) { 
2655      this.contact = theContact;
2656      return this;
2657    }
2658
2659    public boolean hasContact() { 
2660      if (this.contact == null)
2661        return false;
2662      for (ContactPoint item : this.contact)
2663        if (!item.isEmpty())
2664          return true;
2665      return false;
2666    }
2667
2668    public ContactPoint addContact() { //3
2669      ContactPoint t = new ContactPoint();
2670      if (this.contact == null)
2671        this.contact = new ArrayList<ContactPoint>();
2672      this.contact.add(t);
2673      return t;
2674    }
2675
2676    public DeviceDefinition addContact(ContactPoint t) { //3
2677      if (t == null)
2678        return this;
2679      if (this.contact == null)
2680        this.contact = new ArrayList<ContactPoint>();
2681      this.contact.add(t);
2682      return this;
2683    }
2684
2685    /**
2686     * @return The first repetition of repeating field {@link #contact}, creating it if it does not already exist {3}
2687     */
2688    public ContactPoint getContactFirstRep() { 
2689      if (getContact().isEmpty()) {
2690        addContact();
2691      }
2692      return getContact().get(0);
2693    }
2694
2695    /**
2696     * @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
2697     */
2698    public UriType getUrlElement() { 
2699      if (this.url == null)
2700        if (Configuration.errorOnAutoCreate())
2701          throw new Error("Attempt to auto-create DeviceDefinition.url");
2702        else if (Configuration.doAutoCreate())
2703          this.url = new UriType(); // bb
2704      return this.url;
2705    }
2706
2707    public boolean hasUrlElement() { 
2708      return this.url != null && !this.url.isEmpty();
2709    }
2710
2711    public boolean hasUrl() { 
2712      return this.url != null && !this.url.isEmpty();
2713    }
2714
2715    /**
2716     * @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
2717     */
2718    public DeviceDefinition setUrlElement(UriType value) { 
2719      this.url = value;
2720      return this;
2721    }
2722
2723    /**
2724     * @return A network address on which the device may be contacted directly.
2725     */
2726    public String getUrl() { 
2727      return this.url == null ? null : this.url.getValue();
2728    }
2729
2730    /**
2731     * @param value A network address on which the device may be contacted directly.
2732     */
2733    public DeviceDefinition setUrl(String value) { 
2734      if (Utilities.noString(value))
2735        this.url = null;
2736      else {
2737        if (this.url == null)
2738          this.url = new UriType();
2739        this.url.setValue(value);
2740      }
2741      return this;
2742    }
2743
2744    /**
2745     * @return {@link #onlineInformation} (Access to on-line information about the device.). This is the underlying object with id, value and extensions. The accessor "getOnlineInformation" gives direct access to the value
2746     */
2747    public UriType getOnlineInformationElement() { 
2748      if (this.onlineInformation == null)
2749        if (Configuration.errorOnAutoCreate())
2750          throw new Error("Attempt to auto-create DeviceDefinition.onlineInformation");
2751        else if (Configuration.doAutoCreate())
2752          this.onlineInformation = new UriType(); // bb
2753      return this.onlineInformation;
2754    }
2755
2756    public boolean hasOnlineInformationElement() { 
2757      return this.onlineInformation != null && !this.onlineInformation.isEmpty();
2758    }
2759
2760    public boolean hasOnlineInformation() { 
2761      return this.onlineInformation != null && !this.onlineInformation.isEmpty();
2762    }
2763
2764    /**
2765     * @param value {@link #onlineInformation} (Access to on-line information about the device.). This is the underlying object with id, value and extensions. The accessor "getOnlineInformation" gives direct access to the value
2766     */
2767    public DeviceDefinition setOnlineInformationElement(UriType value) { 
2768      this.onlineInformation = value;
2769      return this;
2770    }
2771
2772    /**
2773     * @return Access to on-line information about the device.
2774     */
2775    public String getOnlineInformation() { 
2776      return this.onlineInformation == null ? null : this.onlineInformation.getValue();
2777    }
2778
2779    /**
2780     * @param value Access to on-line information about the device.
2781     */
2782    public DeviceDefinition setOnlineInformation(String value) { 
2783      if (Utilities.noString(value))
2784        this.onlineInformation = null;
2785      else {
2786        if (this.onlineInformation == null)
2787          this.onlineInformation = new UriType();
2788        this.onlineInformation.setValue(value);
2789      }
2790      return this;
2791    }
2792
2793    /**
2794     * @return {@link #note} (Descriptive information, usage information or implantation information that is not captured in an existing element.)
2795     */
2796    public List<Annotation> getNote() { 
2797      if (this.note == null)
2798        this.note = new ArrayList<Annotation>();
2799      return this.note;
2800    }
2801
2802    /**
2803     * @return Returns a reference to <code>this</code> for easy method chaining
2804     */
2805    public DeviceDefinition setNote(List<Annotation> theNote) { 
2806      this.note = theNote;
2807      return this;
2808    }
2809
2810    public boolean hasNote() { 
2811      if (this.note == null)
2812        return false;
2813      for (Annotation item : this.note)
2814        if (!item.isEmpty())
2815          return true;
2816      return false;
2817    }
2818
2819    public Annotation addNote() { //3
2820      Annotation t = new Annotation();
2821      if (this.note == null)
2822        this.note = new ArrayList<Annotation>();
2823      this.note.add(t);
2824      return t;
2825    }
2826
2827    public DeviceDefinition addNote(Annotation t) { //3
2828      if (t == null)
2829        return this;
2830      if (this.note == null)
2831        this.note = new ArrayList<Annotation>();
2832      this.note.add(t);
2833      return this;
2834    }
2835
2836    /**
2837     * @return The first repetition of repeating field {@link #note}, creating it if it does not already exist {3}
2838     */
2839    public Annotation getNoteFirstRep() { 
2840      if (getNote().isEmpty()) {
2841        addNote();
2842      }
2843      return getNote().get(0);
2844    }
2845
2846    /**
2847     * @return {@link #quantity} (The quantity of the device present in the packaging (e.g. the number of devices present in a pack, or the number of devices in the same package of the medicinal product).)
2848     */
2849    public Quantity getQuantity() { 
2850      if (this.quantity == null)
2851        if (Configuration.errorOnAutoCreate())
2852          throw new Error("Attempt to auto-create DeviceDefinition.quantity");
2853        else if (Configuration.doAutoCreate())
2854          this.quantity = new Quantity(); // cc
2855      return this.quantity;
2856    }
2857
2858    public boolean hasQuantity() { 
2859      return this.quantity != null && !this.quantity.isEmpty();
2860    }
2861
2862    /**
2863     * @param value {@link #quantity} (The quantity of the device present in the packaging (e.g. the number of devices present in a pack, or the number of devices in the same package of the medicinal product).)
2864     */
2865    public DeviceDefinition setQuantity(Quantity value) { 
2866      this.quantity = value;
2867      return this;
2868    }
2869
2870    /**
2871     * @return {@link #parentDevice} (The parent device it can be part of.)
2872     */
2873    public Reference getParentDevice() { 
2874      if (this.parentDevice == null)
2875        if (Configuration.errorOnAutoCreate())
2876          throw new Error("Attempt to auto-create DeviceDefinition.parentDevice");
2877        else if (Configuration.doAutoCreate())
2878          this.parentDevice = new Reference(); // cc
2879      return this.parentDevice;
2880    }
2881
2882    public boolean hasParentDevice() { 
2883      return this.parentDevice != null && !this.parentDevice.isEmpty();
2884    }
2885
2886    /**
2887     * @param value {@link #parentDevice} (The parent device it can be part of.)
2888     */
2889    public DeviceDefinition setParentDevice(Reference value) { 
2890      this.parentDevice = value;
2891      return this;
2892    }
2893
2894    /**
2895     * @return {@link #material} (A substance used to create the material(s) of which the device is made.)
2896     */
2897    public List<DeviceDefinitionMaterialComponent> getMaterial() { 
2898      if (this.material == null)
2899        this.material = new ArrayList<DeviceDefinitionMaterialComponent>();
2900      return this.material;
2901    }
2902
2903    /**
2904     * @return Returns a reference to <code>this</code> for easy method chaining
2905     */
2906    public DeviceDefinition setMaterial(List<DeviceDefinitionMaterialComponent> theMaterial) { 
2907      this.material = theMaterial;
2908      return this;
2909    }
2910
2911    public boolean hasMaterial() { 
2912      if (this.material == null)
2913        return false;
2914      for (DeviceDefinitionMaterialComponent item : this.material)
2915        if (!item.isEmpty())
2916          return true;
2917      return false;
2918    }
2919
2920    public DeviceDefinitionMaterialComponent addMaterial() { //3
2921      DeviceDefinitionMaterialComponent t = new DeviceDefinitionMaterialComponent();
2922      if (this.material == null)
2923        this.material = new ArrayList<DeviceDefinitionMaterialComponent>();
2924      this.material.add(t);
2925      return t;
2926    }
2927
2928    public DeviceDefinition addMaterial(DeviceDefinitionMaterialComponent t) { //3
2929      if (t == null)
2930        return this;
2931      if (this.material == null)
2932        this.material = new ArrayList<DeviceDefinitionMaterialComponent>();
2933      this.material.add(t);
2934      return this;
2935    }
2936
2937    /**
2938     * @return The first repetition of repeating field {@link #material}, creating it if it does not already exist {3}
2939     */
2940    public DeviceDefinitionMaterialComponent getMaterialFirstRep() { 
2941      if (getMaterial().isEmpty()) {
2942        addMaterial();
2943      }
2944      return getMaterial().get(0);
2945    }
2946
2947      protected void listChildren(List<Property> children) {
2948        super.listChildren(children);
2949        children.add(new Property("identifier", "Identifier", "Unique instance identifiers assigned to a device by the software, manufacturers, other organizations or owners. For example: handle ID.", 0, java.lang.Integer.MAX_VALUE, identifier));
2950        children.add(new Property("udiDeviceIdentifier", "", "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, udiDeviceIdentifier));
2951        children.add(new Property("manufacturer[x]", "string|Reference(Organization)", "A name of the manufacturer.", 0, 1, manufacturer));
2952        children.add(new Property("deviceName", "", "A name given to the device to identify it.", 0, java.lang.Integer.MAX_VALUE, deviceName));
2953        children.add(new Property("modelNumber", "string", "The model number for the device.", 0, 1, modelNumber));
2954        children.add(new Property("type", "CodeableConcept", "What kind of device or device system this is.", 0, 1, type));
2955        children.add(new Property("specialization", "", "The capabilities supported on a  device, the standards to which the device conforms for a particular purpose, and used for the communication.", 0, java.lang.Integer.MAX_VALUE, specialization));
2956        children.add(new Property("version", "string", "The available versions of the device, e.g., software versions.", 0, java.lang.Integer.MAX_VALUE, version));
2957        children.add(new Property("safety", "CodeableConcept", "Safety characteristics of the device.", 0, java.lang.Integer.MAX_VALUE, safety));
2958        children.add(new Property("shelfLifeStorage", "ProductShelfLife", "Shelf Life and storage information.", 0, java.lang.Integer.MAX_VALUE, shelfLifeStorage));
2959        children.add(new Property("physicalCharacteristics", "ProdCharacteristic", "Dimensions, color etc.", 0, 1, physicalCharacteristics));
2960        children.add(new Property("languageCode", "CodeableConcept", "Language code for the human-readable text strings produced by the device (all supported).", 0, java.lang.Integer.MAX_VALUE, languageCode));
2961        children.add(new Property("capability", "", "Device capabilities.", 0, java.lang.Integer.MAX_VALUE, capability));
2962        children.add(new Property("property", "", "The actual configuration settings of a device as it actually operates, e.g., regulation status, time properties.", 0, java.lang.Integer.MAX_VALUE, property));
2963        children.add(new Property("owner", "Reference(Organization)", "An organization that is responsible for the provision and ongoing maintenance of the device.", 0, 1, owner));
2964        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));
2965        children.add(new Property("url", "uri", "A network address on which the device may be contacted directly.", 0, 1, url));
2966        children.add(new Property("onlineInformation", "uri", "Access to on-line information about the device.", 0, 1, onlineInformation));
2967        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));
2968        children.add(new Property("quantity", "Quantity", "The quantity of the device present in the packaging (e.g. the number of devices present in a pack, or the number of devices in the same package of the medicinal product).", 0, 1, quantity));
2969        children.add(new Property("parentDevice", "Reference(DeviceDefinition)", "The parent device it can be part of.", 0, 1, parentDevice));
2970        children.add(new Property("material", "", "A substance used to create the material(s) of which the device is made.", 0, java.lang.Integer.MAX_VALUE, material));
2971      }
2972
2973      @Override
2974      public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2975        switch (_hash) {
2976        case -1618432855: /*identifier*/  return new Property("identifier", "Identifier", "Unique instance identifiers assigned to a device by the software, manufacturers, other organizations or owners. For example: handle ID.", 0, java.lang.Integer.MAX_VALUE, identifier);
2977        case -99121287: /*udiDeviceIdentifier*/  return new Property("udiDeviceIdentifier", "", "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, udiDeviceIdentifier);
2978        case 418079503: /*manufacturer[x]*/  return new Property("manufacturer[x]", "string|Reference(Organization)", "A name of the manufacturer.", 0, 1, manufacturer);
2979        case -1969347631: /*manufacturer*/  return new Property("manufacturer[x]", "string|Reference(Organization)", "A name of the manufacturer.", 0, 1, manufacturer);
2980        case -630681790: /*manufacturerString*/  return new Property("manufacturer[x]", "string", "A name of the manufacturer.", 0, 1, manufacturer);
2981        case 1104934522: /*manufacturerReference*/  return new Property("manufacturer[x]", "Reference(Organization)", "A name of the manufacturer.", 0, 1, manufacturer);
2982        case 780988929: /*deviceName*/  return new Property("deviceName", "", "A name given to the device to identify it.", 0, java.lang.Integer.MAX_VALUE, deviceName);
2983        case 346619858: /*modelNumber*/  return new Property("modelNumber", "string", "The model number for the device.", 0, 1, modelNumber);
2984        case 3575610: /*type*/  return new Property("type", "CodeableConcept", "What kind of device or device system this is.", 0, 1, type);
2985        case 682815883: /*specialization*/  return new Property("specialization", "", "The capabilities supported on a  device, the standards to which the device conforms for a particular purpose, and used for the communication.", 0, java.lang.Integer.MAX_VALUE, specialization);
2986        case 351608024: /*version*/  return new Property("version", "string", "The available versions of the device, e.g., software versions.", 0, java.lang.Integer.MAX_VALUE, version);
2987        case -909893934: /*safety*/  return new Property("safety", "CodeableConcept", "Safety characteristics of the device.", 0, java.lang.Integer.MAX_VALUE, safety);
2988        case 172049237: /*shelfLifeStorage*/  return new Property("shelfLifeStorage", "ProductShelfLife", "Shelf Life and storage information.", 0, java.lang.Integer.MAX_VALUE, shelfLifeStorage);
2989        case -1599676319: /*physicalCharacteristics*/  return new Property("physicalCharacteristics", "ProdCharacteristic", "Dimensions, color etc.", 0, 1, physicalCharacteristics);
2990        case -2092349083: /*languageCode*/  return new Property("languageCode", "CodeableConcept", "Language code for the human-readable text strings produced by the device (all supported).", 0, java.lang.Integer.MAX_VALUE, languageCode);
2991        case -783669992: /*capability*/  return new Property("capability", "", "Device capabilities.", 0, java.lang.Integer.MAX_VALUE, capability);
2992        case -993141291: /*property*/  return new Property("property", "", "The actual configuration settings of a device as it actually operates, e.g., regulation status, time properties.", 0, java.lang.Integer.MAX_VALUE, property);
2993        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);
2994        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);
2995        case 116079: /*url*/  return new Property("url", "uri", "A network address on which the device may be contacted directly.", 0, 1, url);
2996        case -788511527: /*onlineInformation*/  return new Property("onlineInformation", "uri", "Access to on-line information about the device.", 0, 1, onlineInformation);
2997        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);
2998        case -1285004149: /*quantity*/  return new Property("quantity", "Quantity", "The quantity of the device present in the packaging (e.g. the number of devices present in a pack, or the number of devices in the same package of the medicinal product).", 0, 1, quantity);
2999        case 620260256: /*parentDevice*/  return new Property("parentDevice", "Reference(DeviceDefinition)", "The parent device it can be part of.", 0, 1, parentDevice);
3000        case 299066663: /*material*/  return new Property("material", "", "A substance used to create the material(s) of which the device is made.", 0, java.lang.Integer.MAX_VALUE, material);
3001        default: return super.getNamedProperty(_hash, _name, _checkValid);
3002        }
3003
3004      }
3005
3006      @Override
3007      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3008        switch (hash) {
3009        case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier
3010        case -99121287: /*udiDeviceIdentifier*/ return this.udiDeviceIdentifier == null ? new Base[0] : this.udiDeviceIdentifier.toArray(new Base[this.udiDeviceIdentifier.size()]); // DeviceDefinitionUdiDeviceIdentifierComponent
3011        case -1969347631: /*manufacturer*/ return this.manufacturer == null ? new Base[0] : new Base[] {this.manufacturer}; // DataType
3012        case 780988929: /*deviceName*/ return this.deviceName == null ? new Base[0] : this.deviceName.toArray(new Base[this.deviceName.size()]); // DeviceDefinitionDeviceNameComponent
3013        case 346619858: /*modelNumber*/ return this.modelNumber == null ? new Base[0] : new Base[] {this.modelNumber}; // StringType
3014        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // CodeableConcept
3015        case 682815883: /*specialization*/ return this.specialization == null ? new Base[0] : this.specialization.toArray(new Base[this.specialization.size()]); // DeviceDefinitionSpecializationComponent
3016        case 351608024: /*version*/ return this.version == null ? new Base[0] : this.version.toArray(new Base[this.version.size()]); // StringType
3017        case -909893934: /*safety*/ return this.safety == null ? new Base[0] : this.safety.toArray(new Base[this.safety.size()]); // CodeableConcept
3018        case 172049237: /*shelfLifeStorage*/ return this.shelfLifeStorage == null ? new Base[0] : this.shelfLifeStorage.toArray(new Base[this.shelfLifeStorage.size()]); // ProductShelfLife
3019        case -1599676319: /*physicalCharacteristics*/ return this.physicalCharacteristics == null ? new Base[0] : new Base[] {this.physicalCharacteristics}; // ProdCharacteristic
3020        case -2092349083: /*languageCode*/ return this.languageCode == null ? new Base[0] : this.languageCode.toArray(new Base[this.languageCode.size()]); // CodeableConcept
3021        case -783669992: /*capability*/ return this.capability == null ? new Base[0] : this.capability.toArray(new Base[this.capability.size()]); // DeviceDefinitionCapabilityComponent
3022        case -993141291: /*property*/ return this.property == null ? new Base[0] : this.property.toArray(new Base[this.property.size()]); // DeviceDefinitionPropertyComponent
3023        case 106164915: /*owner*/ return this.owner == null ? new Base[0] : new Base[] {this.owner}; // Reference
3024        case 951526432: /*contact*/ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactPoint
3025        case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType
3026        case -788511527: /*onlineInformation*/ return this.onlineInformation == null ? new Base[0] : new Base[] {this.onlineInformation}; // UriType
3027        case 3387378: /*note*/ return this.note == null ? new Base[0] : this.note.toArray(new Base[this.note.size()]); // Annotation
3028        case -1285004149: /*quantity*/ return this.quantity == null ? new Base[0] : new Base[] {this.quantity}; // Quantity
3029        case 620260256: /*parentDevice*/ return this.parentDevice == null ? new Base[0] : new Base[] {this.parentDevice}; // Reference
3030        case 299066663: /*material*/ return this.material == null ? new Base[0] : this.material.toArray(new Base[this.material.size()]); // DeviceDefinitionMaterialComponent
3031        default: return super.getProperty(hash, name, checkValid);
3032        }
3033
3034      }
3035
3036      @Override
3037      public Base setProperty(int hash, String name, Base value) throws FHIRException {
3038        switch (hash) {
3039        case -1618432855: // identifier
3040          this.getIdentifier().add(TypeConvertor.castToIdentifier(value)); // Identifier
3041          return value;
3042        case -99121287: // udiDeviceIdentifier
3043          this.getUdiDeviceIdentifier().add((DeviceDefinitionUdiDeviceIdentifierComponent) value); // DeviceDefinitionUdiDeviceIdentifierComponent
3044          return value;
3045        case -1969347631: // manufacturer
3046          this.manufacturer = TypeConvertor.castToType(value); // DataType
3047          return value;
3048        case 780988929: // deviceName
3049          this.getDeviceName().add((DeviceDefinitionDeviceNameComponent) value); // DeviceDefinitionDeviceNameComponent
3050          return value;
3051        case 346619858: // modelNumber
3052          this.modelNumber = TypeConvertor.castToString(value); // StringType
3053          return value;
3054        case 3575610: // type
3055          this.type = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
3056          return value;
3057        case 682815883: // specialization
3058          this.getSpecialization().add((DeviceDefinitionSpecializationComponent) value); // DeviceDefinitionSpecializationComponent
3059          return value;
3060        case 351608024: // version
3061          this.getVersion().add(TypeConvertor.castToString(value)); // StringType
3062          return value;
3063        case -909893934: // safety
3064          this.getSafety().add(TypeConvertor.castToCodeableConcept(value)); // CodeableConcept
3065          return value;
3066        case 172049237: // shelfLifeStorage
3067          this.getShelfLifeStorage().add(TypeConvertor.castToProductShelfLife(value)); // ProductShelfLife
3068          return value;
3069        case -1599676319: // physicalCharacteristics
3070          this.physicalCharacteristics = TypeConvertor.castToProdCharacteristic(value); // ProdCharacteristic
3071          return value;
3072        case -2092349083: // languageCode
3073          this.getLanguageCode().add(TypeConvertor.castToCodeableConcept(value)); // CodeableConcept
3074          return value;
3075        case -783669992: // capability
3076          this.getCapability().add((DeviceDefinitionCapabilityComponent) value); // DeviceDefinitionCapabilityComponent
3077          return value;
3078        case -993141291: // property
3079          this.getProperty().add((DeviceDefinitionPropertyComponent) value); // DeviceDefinitionPropertyComponent
3080          return value;
3081        case 106164915: // owner
3082          this.owner = TypeConvertor.castToReference(value); // Reference
3083          return value;
3084        case 951526432: // contact
3085          this.getContact().add(TypeConvertor.castToContactPoint(value)); // ContactPoint
3086          return value;
3087        case 116079: // url
3088          this.url = TypeConvertor.castToUri(value); // UriType
3089          return value;
3090        case -788511527: // onlineInformation
3091          this.onlineInformation = TypeConvertor.castToUri(value); // UriType
3092          return value;
3093        case 3387378: // note
3094          this.getNote().add(TypeConvertor.castToAnnotation(value)); // Annotation
3095          return value;
3096        case -1285004149: // quantity
3097          this.quantity = TypeConvertor.castToQuantity(value); // Quantity
3098          return value;
3099        case 620260256: // parentDevice
3100          this.parentDevice = TypeConvertor.castToReference(value); // Reference
3101          return value;
3102        case 299066663: // material
3103          this.getMaterial().add((DeviceDefinitionMaterialComponent) value); // DeviceDefinitionMaterialComponent
3104          return value;
3105        default: return super.setProperty(hash, name, value);
3106        }
3107
3108      }
3109
3110      @Override
3111      public Base setProperty(String name, Base value) throws FHIRException {
3112        if (name.equals("identifier")) {
3113          this.getIdentifier().add(TypeConvertor.castToIdentifier(value));
3114        } else if (name.equals("udiDeviceIdentifier")) {
3115          this.getUdiDeviceIdentifier().add((DeviceDefinitionUdiDeviceIdentifierComponent) value);
3116        } else if (name.equals("manufacturer[x]")) {
3117          this.manufacturer = TypeConvertor.castToType(value); // DataType
3118        } else if (name.equals("deviceName")) {
3119          this.getDeviceName().add((DeviceDefinitionDeviceNameComponent) value);
3120        } else if (name.equals("modelNumber")) {
3121          this.modelNumber = TypeConvertor.castToString(value); // StringType
3122        } else if (name.equals("type")) {
3123          this.type = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
3124        } else if (name.equals("specialization")) {
3125          this.getSpecialization().add((DeviceDefinitionSpecializationComponent) value);
3126        } else if (name.equals("version")) {
3127          this.getVersion().add(TypeConvertor.castToString(value));
3128        } else if (name.equals("safety")) {
3129          this.getSafety().add(TypeConvertor.castToCodeableConcept(value));
3130        } else if (name.equals("shelfLifeStorage")) {
3131          this.getShelfLifeStorage().add(TypeConvertor.castToProductShelfLife(value));
3132        } else if (name.equals("physicalCharacteristics")) {
3133          this.physicalCharacteristics = TypeConvertor.castToProdCharacteristic(value); // ProdCharacteristic
3134        } else if (name.equals("languageCode")) {
3135          this.getLanguageCode().add(TypeConvertor.castToCodeableConcept(value));
3136        } else if (name.equals("capability")) {
3137          this.getCapability().add((DeviceDefinitionCapabilityComponent) value);
3138        } else if (name.equals("property")) {
3139          this.getProperty().add((DeviceDefinitionPropertyComponent) value);
3140        } else if (name.equals("owner")) {
3141          this.owner = TypeConvertor.castToReference(value); // Reference
3142        } else if (name.equals("contact")) {
3143          this.getContact().add(TypeConvertor.castToContactPoint(value));
3144        } else if (name.equals("url")) {
3145          this.url = TypeConvertor.castToUri(value); // UriType
3146        } else if (name.equals("onlineInformation")) {
3147          this.onlineInformation = TypeConvertor.castToUri(value); // UriType
3148        } else if (name.equals("note")) {
3149          this.getNote().add(TypeConvertor.castToAnnotation(value));
3150        } else if (name.equals("quantity")) {
3151          this.quantity = TypeConvertor.castToQuantity(value); // Quantity
3152        } else if (name.equals("parentDevice")) {
3153          this.parentDevice = TypeConvertor.castToReference(value); // Reference
3154        } else if (name.equals("material")) {
3155          this.getMaterial().add((DeviceDefinitionMaterialComponent) value);
3156        } else
3157          return super.setProperty(name, value);
3158        return value;
3159      }
3160
3161      @Override
3162      public Base makeProperty(int hash, String name) throws FHIRException {
3163        switch (hash) {
3164        case -1618432855:  return addIdentifier(); 
3165        case -99121287:  return addUdiDeviceIdentifier(); 
3166        case 418079503:  return getManufacturer();
3167        case -1969347631:  return getManufacturer();
3168        case 780988929:  return addDeviceName(); 
3169        case 346619858:  return getModelNumberElement();
3170        case 3575610:  return getType();
3171        case 682815883:  return addSpecialization(); 
3172        case 351608024:  return addVersionElement();
3173        case -909893934:  return addSafety(); 
3174        case 172049237:  return addShelfLifeStorage(); 
3175        case -1599676319:  return getPhysicalCharacteristics();
3176        case -2092349083:  return addLanguageCode(); 
3177        case -783669992:  return addCapability(); 
3178        case -993141291:  return addProperty(); 
3179        case 106164915:  return getOwner();
3180        case 951526432:  return addContact(); 
3181        case 116079:  return getUrlElement();
3182        case -788511527:  return getOnlineInformationElement();
3183        case 3387378:  return addNote(); 
3184        case -1285004149:  return getQuantity();
3185        case 620260256:  return getParentDevice();
3186        case 299066663:  return addMaterial(); 
3187        default: return super.makeProperty(hash, name);
3188        }
3189
3190      }
3191
3192      @Override
3193      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
3194        switch (hash) {
3195        case -1618432855: /*identifier*/ return new String[] {"Identifier"};
3196        case -99121287: /*udiDeviceIdentifier*/ return new String[] {};
3197        case -1969347631: /*manufacturer*/ return new String[] {"string", "Reference"};
3198        case 780988929: /*deviceName*/ return new String[] {};
3199        case 346619858: /*modelNumber*/ return new String[] {"string"};
3200        case 3575610: /*type*/ return new String[] {"CodeableConcept"};
3201        case 682815883: /*specialization*/ return new String[] {};
3202        case 351608024: /*version*/ return new String[] {"string"};
3203        case -909893934: /*safety*/ return new String[] {"CodeableConcept"};
3204        case 172049237: /*shelfLifeStorage*/ return new String[] {"ProductShelfLife"};
3205        case -1599676319: /*physicalCharacteristics*/ return new String[] {"ProdCharacteristic"};
3206        case -2092349083: /*languageCode*/ return new String[] {"CodeableConcept"};
3207        case -783669992: /*capability*/ return new String[] {};
3208        case -993141291: /*property*/ return new String[] {};
3209        case 106164915: /*owner*/ return new String[] {"Reference"};
3210        case 951526432: /*contact*/ return new String[] {"ContactPoint"};
3211        case 116079: /*url*/ return new String[] {"uri"};
3212        case -788511527: /*onlineInformation*/ return new String[] {"uri"};
3213        case 3387378: /*note*/ return new String[] {"Annotation"};
3214        case -1285004149: /*quantity*/ return new String[] {"Quantity"};
3215        case 620260256: /*parentDevice*/ return new String[] {"Reference"};
3216        case 299066663: /*material*/ return new String[] {};
3217        default: return super.getTypesForProperty(hash, name);
3218        }
3219
3220      }
3221
3222      @Override
3223      public Base addChild(String name) throws FHIRException {
3224        if (name.equals("identifier")) {
3225          return addIdentifier();
3226        }
3227        else if (name.equals("udiDeviceIdentifier")) {
3228          return addUdiDeviceIdentifier();
3229        }
3230        else if (name.equals("manufacturerString")) {
3231          this.manufacturer = new StringType();
3232          return this.manufacturer;
3233        }
3234        else if (name.equals("manufacturerReference")) {
3235          this.manufacturer = new Reference();
3236          return this.manufacturer;
3237        }
3238        else if (name.equals("deviceName")) {
3239          return addDeviceName();
3240        }
3241        else if (name.equals("modelNumber")) {
3242          throw new FHIRException("Cannot call addChild on a primitive type DeviceDefinition.modelNumber");
3243        }
3244        else if (name.equals("type")) {
3245          this.type = new CodeableConcept();
3246          return this.type;
3247        }
3248        else if (name.equals("specialization")) {
3249          return addSpecialization();
3250        }
3251        else if (name.equals("version")) {
3252          throw new FHIRException("Cannot call addChild on a primitive type DeviceDefinition.version");
3253        }
3254        else if (name.equals("safety")) {
3255          return addSafety();
3256        }
3257        else if (name.equals("shelfLifeStorage")) {
3258          return addShelfLifeStorage();
3259        }
3260        else if (name.equals("physicalCharacteristics")) {
3261          this.physicalCharacteristics = new ProdCharacteristic();
3262          return this.physicalCharacteristics;
3263        }
3264        else if (name.equals("languageCode")) {
3265          return addLanguageCode();
3266        }
3267        else if (name.equals("capability")) {
3268          return addCapability();
3269        }
3270        else if (name.equals("property")) {
3271          return addProperty();
3272        }
3273        else if (name.equals("owner")) {
3274          this.owner = new Reference();
3275          return this.owner;
3276        }
3277        else if (name.equals("contact")) {
3278          return addContact();
3279        }
3280        else if (name.equals("url")) {
3281          throw new FHIRException("Cannot call addChild on a primitive type DeviceDefinition.url");
3282        }
3283        else if (name.equals("onlineInformation")) {
3284          throw new FHIRException("Cannot call addChild on a primitive type DeviceDefinition.onlineInformation");
3285        }
3286        else if (name.equals("note")) {
3287          return addNote();
3288        }
3289        else if (name.equals("quantity")) {
3290          this.quantity = new Quantity();
3291          return this.quantity;
3292        }
3293        else if (name.equals("parentDevice")) {
3294          this.parentDevice = new Reference();
3295          return this.parentDevice;
3296        }
3297        else if (name.equals("material")) {
3298          return addMaterial();
3299        }
3300        else
3301          return super.addChild(name);
3302      }
3303
3304  public String fhirType() {
3305    return "DeviceDefinition";
3306
3307  }
3308
3309      public DeviceDefinition copy() {
3310        DeviceDefinition dst = new DeviceDefinition();
3311        copyValues(dst);
3312        return dst;
3313      }
3314
3315      public void copyValues(DeviceDefinition dst) {
3316        super.copyValues(dst);
3317        if (identifier != null) {
3318          dst.identifier = new ArrayList<Identifier>();
3319          for (Identifier i : identifier)
3320            dst.identifier.add(i.copy());
3321        };
3322        if (udiDeviceIdentifier != null) {
3323          dst.udiDeviceIdentifier = new ArrayList<DeviceDefinitionUdiDeviceIdentifierComponent>();
3324          for (DeviceDefinitionUdiDeviceIdentifierComponent i : udiDeviceIdentifier)
3325            dst.udiDeviceIdentifier.add(i.copy());
3326        };
3327        dst.manufacturer = manufacturer == null ? null : manufacturer.copy();
3328        if (deviceName != null) {
3329          dst.deviceName = new ArrayList<DeviceDefinitionDeviceNameComponent>();
3330          for (DeviceDefinitionDeviceNameComponent i : deviceName)
3331            dst.deviceName.add(i.copy());
3332        };
3333        dst.modelNumber = modelNumber == null ? null : modelNumber.copy();
3334        dst.type = type == null ? null : type.copy();
3335        if (specialization != null) {
3336          dst.specialization = new ArrayList<DeviceDefinitionSpecializationComponent>();
3337          for (DeviceDefinitionSpecializationComponent i : specialization)
3338            dst.specialization.add(i.copy());
3339        };
3340        if (version != null) {
3341          dst.version = new ArrayList<StringType>();
3342          for (StringType i : version)
3343            dst.version.add(i.copy());
3344        };
3345        if (safety != null) {
3346          dst.safety = new ArrayList<CodeableConcept>();
3347          for (CodeableConcept i : safety)
3348            dst.safety.add(i.copy());
3349        };
3350        if (shelfLifeStorage != null) {
3351          dst.shelfLifeStorage = new ArrayList<ProductShelfLife>();
3352          for (ProductShelfLife i : shelfLifeStorage)
3353            dst.shelfLifeStorage.add(i.copy());
3354        };
3355        dst.physicalCharacteristics = physicalCharacteristics == null ? null : physicalCharacteristics.copy();
3356        if (languageCode != null) {
3357          dst.languageCode = new ArrayList<CodeableConcept>();
3358          for (CodeableConcept i : languageCode)
3359            dst.languageCode.add(i.copy());
3360        };
3361        if (capability != null) {
3362          dst.capability = new ArrayList<DeviceDefinitionCapabilityComponent>();
3363          for (DeviceDefinitionCapabilityComponent i : capability)
3364            dst.capability.add(i.copy());
3365        };
3366        if (property != null) {
3367          dst.property = new ArrayList<DeviceDefinitionPropertyComponent>();
3368          for (DeviceDefinitionPropertyComponent i : property)
3369            dst.property.add(i.copy());
3370        };
3371        dst.owner = owner == null ? null : owner.copy();
3372        if (contact != null) {
3373          dst.contact = new ArrayList<ContactPoint>();
3374          for (ContactPoint i : contact)
3375            dst.contact.add(i.copy());
3376        };
3377        dst.url = url == null ? null : url.copy();
3378        dst.onlineInformation = onlineInformation == null ? null : onlineInformation.copy();
3379        if (note != null) {
3380          dst.note = new ArrayList<Annotation>();
3381          for (Annotation i : note)
3382            dst.note.add(i.copy());
3383        };
3384        dst.quantity = quantity == null ? null : quantity.copy();
3385        dst.parentDevice = parentDevice == null ? null : parentDevice.copy();
3386        if (material != null) {
3387          dst.material = new ArrayList<DeviceDefinitionMaterialComponent>();
3388          for (DeviceDefinitionMaterialComponent i : material)
3389            dst.material.add(i.copy());
3390        };
3391      }
3392
3393      protected DeviceDefinition typedCopy() {
3394        return copy();
3395      }
3396
3397      @Override
3398      public boolean equalsDeep(Base other_) {
3399        if (!super.equalsDeep(other_))
3400          return false;
3401        if (!(other_ instanceof DeviceDefinition))
3402          return false;
3403        DeviceDefinition o = (DeviceDefinition) other_;
3404        return compareDeep(identifier, o.identifier, true) && compareDeep(udiDeviceIdentifier, o.udiDeviceIdentifier, true)
3405           && compareDeep(manufacturer, o.manufacturer, true) && compareDeep(deviceName, o.deviceName, true)
3406           && compareDeep(modelNumber, o.modelNumber, true) && compareDeep(type, o.type, true) && compareDeep(specialization, o.specialization, true)
3407           && compareDeep(version, o.version, true) && compareDeep(safety, o.safety, true) && compareDeep(shelfLifeStorage, o.shelfLifeStorage, true)
3408           && compareDeep(physicalCharacteristics, o.physicalCharacteristics, true) && compareDeep(languageCode, o.languageCode, true)
3409           && compareDeep(capability, o.capability, true) && compareDeep(property, o.property, true) && compareDeep(owner, o.owner, true)
3410           && compareDeep(contact, o.contact, true) && compareDeep(url, o.url, true) && compareDeep(onlineInformation, o.onlineInformation, true)
3411           && compareDeep(note, o.note, true) && compareDeep(quantity, o.quantity, true) && compareDeep(parentDevice, o.parentDevice, true)
3412           && compareDeep(material, o.material, true);
3413      }
3414
3415      @Override
3416      public boolean equalsShallow(Base other_) {
3417        if (!super.equalsShallow(other_))
3418          return false;
3419        if (!(other_ instanceof DeviceDefinition))
3420          return false;
3421        DeviceDefinition o = (DeviceDefinition) other_;
3422        return compareValues(modelNumber, o.modelNumber, true) && compareValues(version, o.version, true) && compareValues(url, o.url, true)
3423           && compareValues(onlineInformation, o.onlineInformation, true);
3424      }
3425
3426      public boolean isEmpty() {
3427        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identifier, udiDeviceIdentifier
3428          , manufacturer, deviceName, modelNumber, type, specialization, version, safety
3429          , shelfLifeStorage, physicalCharacteristics, languageCode, capability, property, owner
3430          , contact, url, onlineInformation, note, quantity, parentDevice, material);
3431      }
3432
3433  @Override
3434  public ResourceType getResourceType() {
3435    return ResourceType.DeviceDefinition;
3436   }
3437
3438 /**
3439   * Search parameter: <b>identifier</b>
3440   * <p>
3441   * Description: <b>The identifier of the component</b><br>
3442   * Type: <b>token</b><br>
3443   * Path: <b>DeviceDefinition.identifier</b><br>
3444   * </p>
3445   */
3446  @SearchParamDefinition(name="identifier", path="DeviceDefinition.identifier", description="The identifier of the component", type="token" )
3447  public static final String SP_IDENTIFIER = "identifier";
3448 /**
3449   * <b>Fluent Client</b> search parameter constant for <b>identifier</b>
3450   * <p>
3451   * Description: <b>The identifier of the component</b><br>
3452   * Type: <b>token</b><br>
3453   * Path: <b>DeviceDefinition.identifier</b><br>
3454   * </p>
3455   */
3456  public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER);
3457
3458 /**
3459   * Search parameter: <b>parent</b>
3460   * <p>
3461   * Description: <b>The parent DeviceDefinition resource</b><br>
3462   * Type: <b>reference</b><br>
3463   * Path: <b>DeviceDefinition.parentDevice</b><br>
3464   * </p>
3465   */
3466  @SearchParamDefinition(name="parent", path="DeviceDefinition.parentDevice", description="The parent DeviceDefinition resource", type="reference", target={DeviceDefinition.class } )
3467  public static final String SP_PARENT = "parent";
3468 /**
3469   * <b>Fluent Client</b> search parameter constant for <b>parent</b>
3470   * <p>
3471   * Description: <b>The parent DeviceDefinition resource</b><br>
3472   * Type: <b>reference</b><br>
3473   * Path: <b>DeviceDefinition.parentDevice</b><br>
3474   * </p>
3475   */
3476  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PARENT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_PARENT);
3477
3478/**
3479   * Constant for fluent queries to be used to add include statements. Specifies
3480   * the path value of "<b>DeviceDefinition:parent</b>".
3481   */
3482  public static final ca.uhn.fhir.model.api.Include INCLUDE_PARENT = new ca.uhn.fhir.model.api.Include("DeviceDefinition:parent").toLocked();
3483
3484 /**
3485   * Search parameter: <b>type</b>
3486   * <p>
3487   * Description: <b>The device component type</b><br>
3488   * Type: <b>token</b><br>
3489   * Path: <b>DeviceDefinition.type</b><br>
3490   * </p>
3491   */
3492  @SearchParamDefinition(name="type", path="DeviceDefinition.type", description="The device component type", type="token" )
3493  public static final String SP_TYPE = "type";
3494 /**
3495   * <b>Fluent Client</b> search parameter constant for <b>type</b>
3496   * <p>
3497   * Description: <b>The device component type</b><br>
3498   * Type: <b>token</b><br>
3499   * Path: <b>DeviceDefinition.type</b><br>
3500   * </p>
3501   */
3502  public static final ca.uhn.fhir.rest.gclient.TokenClientParam TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_TYPE);
3503
3504
3505}
3506