001package org.hl7.fhir.dstu2016may.model;
002
003
004
005
006/*
007  Copyright (c) 2011+, HL7, Inc.
008  All rights reserved.
009  
010  Redistribution and use in source and binary forms, with or without modification, 
011  are permitted provided that the following conditions are met:
012  
013   * Redistributions of source code must retain the above copyright notice, this 
014     list of conditions and the following disclaimer.
015   * Redistributions in binary form must reproduce the above copyright notice, 
016     this list of conditions and the following disclaimer in the documentation 
017     and/or other materials provided with the distribution.
018   * Neither the name of HL7 nor the names of its contributors may be used to 
019     endorse or promote products derived from this software without specific 
020     prior written permission.
021  
022  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
023  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
024  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
025  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
026  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
027  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
028  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
029  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
030  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
031  POSSIBILITY OF SUCH DAMAGE.
032  
033*/
034
035// Generated on Sun, May 8, 2016 03:05+1000 for FHIR v1.4.0
036import java.util.ArrayList;
037import java.util.List;
038
039import org.hl7.fhir.exceptions.FHIRException;
040import org.hl7.fhir.instance.model.api.IBaseBackboneElement;
041
042import ca.uhn.fhir.model.api.annotation.Block;
043import ca.uhn.fhir.model.api.annotation.Child;
044import ca.uhn.fhir.model.api.annotation.Description;
045import ca.uhn.fhir.model.api.annotation.ResourceDef;
046import ca.uhn.fhir.model.api.annotation.SearchParamDefinition;
047/**
048 * Identifies two or more records (resource instances) that are referring to the same real-world "occurrence".
049 */
050@ResourceDef(name="Linkage", profile="http://hl7.org/fhir/Profile/Linkage")
051public class Linkage extends DomainResource {
052
053    public enum LinkageType {
054        /**
055         * The record represents the "source of truth" (from the perspective of this Linkage resource) for the underlying event/condition/etc.
056         */
057        SOURCE, 
058        /**
059         * The record represents the alternative view of the underlying event/condition/etc.  The record may still be actively maintained, even though it is not considered to be the source of truth.
060         */
061        ALTERNATE, 
062        /**
063         * The record represents an obsolete record of the underlyng event/condition/etc.  It is not expected to be actively maintained.
064         */
065        HISTORICAL, 
066        /**
067         * added to help the parsers
068         */
069        NULL;
070        public static LinkageType fromCode(String codeString) throws FHIRException {
071            if (codeString == null || "".equals(codeString))
072                return null;
073        if ("source".equals(codeString))
074          return SOURCE;
075        if ("alternate".equals(codeString))
076          return ALTERNATE;
077        if ("historical".equals(codeString))
078          return HISTORICAL;
079        throw new FHIRException("Unknown LinkageType code '"+codeString+"'");
080        }
081        public String toCode() {
082          switch (this) {
083            case SOURCE: return "source";
084            case ALTERNATE: return "alternate";
085            case HISTORICAL: return "historical";
086            case NULL: return null;
087            default: return "?";
088          }
089        }
090        public String getSystem() {
091          switch (this) {
092            case SOURCE: return "http://hl7.org/fhir/linkage-type";
093            case ALTERNATE: return "http://hl7.org/fhir/linkage-type";
094            case HISTORICAL: return "http://hl7.org/fhir/linkage-type";
095            case NULL: return null;
096            default: return "?";
097          }
098        }
099        public String getDefinition() {
100          switch (this) {
101            case SOURCE: return "The record represents the \"source of truth\" (from the perspective of this Linkage resource) for the underlying event/condition/etc.";
102            case ALTERNATE: return "The record represents the alternative view of the underlying event/condition/etc.  The record may still be actively maintained, even though it is not considered to be the source of truth.";
103            case HISTORICAL: return "The record represents an obsolete record of the underlyng event/condition/etc.  It is not expected to be actively maintained.";
104            case NULL: return null;
105            default: return "?";
106          }
107        }
108        public String getDisplay() {
109          switch (this) {
110            case SOURCE: return "Source of truth";
111            case ALTERNATE: return "Alternate record";
112            case HISTORICAL: return "Historical/obsolete record";
113            case NULL: return null;
114            default: return "?";
115          }
116        }
117    }
118
119  public static class LinkageTypeEnumFactory implements EnumFactory<LinkageType> {
120    public LinkageType fromCode(String codeString) throws IllegalArgumentException {
121      if (codeString == null || "".equals(codeString))
122            if (codeString == null || "".equals(codeString))
123                return null;
124        if ("source".equals(codeString))
125          return LinkageType.SOURCE;
126        if ("alternate".equals(codeString))
127          return LinkageType.ALTERNATE;
128        if ("historical".equals(codeString))
129          return LinkageType.HISTORICAL;
130        throw new IllegalArgumentException("Unknown LinkageType code '"+codeString+"'");
131        }
132        public Enumeration<LinkageType> fromType(Base code) throws FHIRException {
133          if (code == null || code.isEmpty())
134            return null;
135          String codeString = ((PrimitiveType) code).asStringValue();
136          if (codeString == null || "".equals(codeString))
137            return null;
138        if ("source".equals(codeString))
139          return new Enumeration<LinkageType>(this, LinkageType.SOURCE);
140        if ("alternate".equals(codeString))
141          return new Enumeration<LinkageType>(this, LinkageType.ALTERNATE);
142        if ("historical".equals(codeString))
143          return new Enumeration<LinkageType>(this, LinkageType.HISTORICAL);
144        throw new FHIRException("Unknown LinkageType code '"+codeString+"'");
145        }
146    public String toCode(LinkageType code) {
147      if (code == LinkageType.SOURCE)
148        return "source";
149      if (code == LinkageType.ALTERNATE)
150        return "alternate";
151      if (code == LinkageType.HISTORICAL)
152        return "historical";
153      return "?";
154      }
155    public String toSystem(LinkageType code) {
156      return code.getSystem();
157      }
158    }
159
160    @Block()
161    public static class LinkageItemComponent extends BackboneElement implements IBaseBackboneElement {
162        /**
163         * Distinguishes which item is "source of truth" (if any) and which items are no longer considered to be current representations.
164         */
165        @Child(name = "type", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true)
166        @Description(shortDefinition="source | alternate | historical", formalDefinition="Distinguishes which item is \"source of truth\" (if any) and which items are no longer considered to be current representations." )
167        protected Enumeration<LinkageType> type;
168
169        /**
170         * The resource instance being linked as part of the group.
171         */
172        @Child(name = "resource", type = {Reference.class}, order=2, min=1, max=1, modifier=false, summary=true)
173        @Description(shortDefinition="Resource being linked", formalDefinition="The resource instance being linked as part of the group." )
174        protected Reference resource;
175
176        private static final long serialVersionUID = 527428511L;
177
178    /**
179     * Constructor
180     */
181      public LinkageItemComponent() {
182        super();
183      }
184
185    /**
186     * Constructor
187     */
188      public LinkageItemComponent(Enumeration<LinkageType> type, Reference resource) {
189        super();
190        this.type = type;
191        this.resource = resource;
192      }
193
194        /**
195         * @return {@link #type} (Distinguishes which item is "source of truth" (if any) and which items are no longer considered to be current representations.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
196         */
197        public Enumeration<LinkageType> getTypeElement() { 
198          if (this.type == null)
199            if (Configuration.errorOnAutoCreate())
200              throw new Error("Attempt to auto-create LinkageItemComponent.type");
201            else if (Configuration.doAutoCreate())
202              this.type = new Enumeration<LinkageType>(new LinkageTypeEnumFactory()); // bb
203          return this.type;
204        }
205
206        public boolean hasTypeElement() { 
207          return this.type != null && !this.type.isEmpty();
208        }
209
210        public boolean hasType() { 
211          return this.type != null && !this.type.isEmpty();
212        }
213
214        /**
215         * @param value {@link #type} (Distinguishes which item is "source of truth" (if any) and which items are no longer considered to be current representations.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
216         */
217        public LinkageItemComponent setTypeElement(Enumeration<LinkageType> value) { 
218          this.type = value;
219          return this;
220        }
221
222        /**
223         * @return Distinguishes which item is "source of truth" (if any) and which items are no longer considered to be current representations.
224         */
225        public LinkageType getType() { 
226          return this.type == null ? null : this.type.getValue();
227        }
228
229        /**
230         * @param value Distinguishes which item is "source of truth" (if any) and which items are no longer considered to be current representations.
231         */
232        public LinkageItemComponent setType(LinkageType value) { 
233            if (this.type == null)
234              this.type = new Enumeration<LinkageType>(new LinkageTypeEnumFactory());
235            this.type.setValue(value);
236          return this;
237        }
238
239        /**
240         * @return {@link #resource} (The resource instance being linked as part of the group.)
241         */
242        public Reference getResource() { 
243          if (this.resource == null)
244            if (Configuration.errorOnAutoCreate())
245              throw new Error("Attempt to auto-create LinkageItemComponent.resource");
246            else if (Configuration.doAutoCreate())
247              this.resource = new Reference(); // cc
248          return this.resource;
249        }
250
251        public boolean hasResource() { 
252          return this.resource != null && !this.resource.isEmpty();
253        }
254
255        /**
256         * @param value {@link #resource} (The resource instance being linked as part of the group.)
257         */
258        public LinkageItemComponent setResource(Reference value) { 
259          this.resource = value;
260          return this;
261        }
262
263        protected void listChildren(List<Property> childrenList) {
264          super.listChildren(childrenList);
265          childrenList.add(new Property("type", "code", "Distinguishes which item is \"source of truth\" (if any) and which items are no longer considered to be current representations.", 0, java.lang.Integer.MAX_VALUE, type));
266          childrenList.add(new Property("resource", "Reference", "The resource instance being linked as part of the group.", 0, java.lang.Integer.MAX_VALUE, resource));
267        }
268
269      @Override
270      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
271        switch (hash) {
272        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<LinkageType>
273        case -341064690: /*resource*/ return this.resource == null ? new Base[0] : new Base[] {this.resource}; // Reference
274        default: return super.getProperty(hash, name, checkValid);
275        }
276
277      }
278
279      @Override
280      public void setProperty(int hash, String name, Base value) throws FHIRException {
281        switch (hash) {
282        case 3575610: // type
283          this.type = new LinkageTypeEnumFactory().fromType(value); // Enumeration<LinkageType>
284          break;
285        case -341064690: // resource
286          this.resource = castToReference(value); // Reference
287          break;
288        default: super.setProperty(hash, name, value);
289        }
290
291      }
292
293      @Override
294      public void setProperty(String name, Base value) throws FHIRException {
295        if (name.equals("type"))
296          this.type = new LinkageTypeEnumFactory().fromType(value); // Enumeration<LinkageType>
297        else if (name.equals("resource"))
298          this.resource = castToReference(value); // Reference
299        else
300          super.setProperty(name, value);
301      }
302
303      @Override
304      public Base makeProperty(int hash, String name) throws FHIRException {
305        switch (hash) {
306        case 3575610: throw new FHIRException("Cannot make property type as it is not a complex type"); // Enumeration<LinkageType>
307        case -341064690:  return getResource(); // Reference
308        default: return super.makeProperty(hash, name);
309        }
310
311      }
312
313      @Override
314      public Base addChild(String name) throws FHIRException {
315        if (name.equals("type")) {
316          throw new FHIRException("Cannot call addChild on a primitive type Linkage.type");
317        }
318        else if (name.equals("resource")) {
319          this.resource = new Reference();
320          return this.resource;
321        }
322        else
323          return super.addChild(name);
324      }
325
326      public LinkageItemComponent copy() {
327        LinkageItemComponent dst = new LinkageItemComponent();
328        copyValues(dst);
329        dst.type = type == null ? null : type.copy();
330        dst.resource = resource == null ? null : resource.copy();
331        return dst;
332      }
333
334      @Override
335      public boolean equalsDeep(Base other) {
336        if (!super.equalsDeep(other))
337          return false;
338        if (!(other instanceof LinkageItemComponent))
339          return false;
340        LinkageItemComponent o = (LinkageItemComponent) other;
341        return compareDeep(type, o.type, true) && compareDeep(resource, o.resource, true);
342      }
343
344      @Override
345      public boolean equalsShallow(Base other) {
346        if (!super.equalsShallow(other))
347          return false;
348        if (!(other instanceof LinkageItemComponent))
349          return false;
350        LinkageItemComponent o = (LinkageItemComponent) other;
351        return compareValues(type, o.type, true);
352      }
353
354      public boolean isEmpty() {
355        return super.isEmpty() && (type == null || type.isEmpty()) && (resource == null || resource.isEmpty())
356          ;
357      }
358
359  public String fhirType() {
360    return "Linkage.item";
361
362  }
363
364  }
365
366    /**
367     * Identifies the user or organization responsible for asserting the linkages and who establishes the context for evaluating the nature of each linkage.
368     */
369    @Child(name = "author", type = {Practitioner.class, Organization.class}, order=0, min=0, max=1, modifier=false, summary=true)
370    @Description(shortDefinition="Who is responsible for linkages", formalDefinition="Identifies the user or organization responsible for asserting the linkages and who establishes the context for evaluating the nature of each linkage." )
371    protected Reference author;
372
373    /**
374     * The actual object that is the target of the reference (Identifies the user or organization responsible for asserting the linkages and who establishes the context for evaluating the nature of each linkage.)
375     */
376    protected Resource authorTarget;
377
378    /**
379     * Identifies one of the records that is considered to refer to the same real-world occurrence as well as how the items hould be evaluated within the collection of linked items.
380     */
381    @Child(name = "item", type = {}, order=1, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
382    @Description(shortDefinition="Item to be linked", formalDefinition="Identifies one of the records that is considered to refer to the same real-world occurrence as well as how the items hould be evaluated within the collection of linked items." )
383    protected List<LinkageItemComponent> item;
384
385    private static final long serialVersionUID = 371266420L;
386
387  /**
388   * Constructor
389   */
390    public Linkage() {
391      super();
392    }
393
394    /**
395     * @return {@link #author} (Identifies the user or organization responsible for asserting the linkages and who establishes the context for evaluating the nature of each linkage.)
396     */
397    public Reference getAuthor() { 
398      if (this.author == null)
399        if (Configuration.errorOnAutoCreate())
400          throw new Error("Attempt to auto-create Linkage.author");
401        else if (Configuration.doAutoCreate())
402          this.author = new Reference(); // cc
403      return this.author;
404    }
405
406    public boolean hasAuthor() { 
407      return this.author != null && !this.author.isEmpty();
408    }
409
410    /**
411     * @param value {@link #author} (Identifies the user or organization responsible for asserting the linkages and who establishes the context for evaluating the nature of each linkage.)
412     */
413    public Linkage setAuthor(Reference value) { 
414      this.author = value;
415      return this;
416    }
417
418    /**
419     * @return {@link #author} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (Identifies the user or organization responsible for asserting the linkages and who establishes the context for evaluating the nature of each linkage.)
420     */
421    public Resource getAuthorTarget() { 
422      return this.authorTarget;
423    }
424
425    /**
426     * @param value {@link #author} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (Identifies the user or organization responsible for asserting the linkages and who establishes the context for evaluating the nature of each linkage.)
427     */
428    public Linkage setAuthorTarget(Resource value) { 
429      this.authorTarget = value;
430      return this;
431    }
432
433    /**
434     * @return {@link #item} (Identifies one of the records that is considered to refer to the same real-world occurrence as well as how the items hould be evaluated within the collection of linked items.)
435     */
436    public List<LinkageItemComponent> getItem() { 
437      if (this.item == null)
438        this.item = new ArrayList<LinkageItemComponent>();
439      return this.item;
440    }
441
442    public boolean hasItem() { 
443      if (this.item == null)
444        return false;
445      for (LinkageItemComponent item : this.item)
446        if (!item.isEmpty())
447          return true;
448      return false;
449    }
450
451    /**
452     * @return {@link #item} (Identifies one of the records that is considered to refer to the same real-world occurrence as well as how the items hould be evaluated within the collection of linked items.)
453     */
454    // syntactic sugar
455    public LinkageItemComponent addItem() { //3
456      LinkageItemComponent t = new LinkageItemComponent();
457      if (this.item == null)
458        this.item = new ArrayList<LinkageItemComponent>();
459      this.item.add(t);
460      return t;
461    }
462
463    // syntactic sugar
464    public Linkage addItem(LinkageItemComponent t) { //3
465      if (t == null)
466        return this;
467      if (this.item == null)
468        this.item = new ArrayList<LinkageItemComponent>();
469      this.item.add(t);
470      return this;
471    }
472
473      protected void listChildren(List<Property> childrenList) {
474        super.listChildren(childrenList);
475        childrenList.add(new Property("author", "Reference(Practitioner|Organization)", "Identifies the user or organization responsible for asserting the linkages and who establishes the context for evaluating the nature of each linkage.", 0, java.lang.Integer.MAX_VALUE, author));
476        childrenList.add(new Property("item", "", "Identifies one of the records that is considered to refer to the same real-world occurrence as well as how the items hould be evaluated within the collection of linked items.", 0, java.lang.Integer.MAX_VALUE, item));
477      }
478
479      @Override
480      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
481        switch (hash) {
482        case -1406328437: /*author*/ return this.author == null ? new Base[0] : new Base[] {this.author}; // Reference
483        case 3242771: /*item*/ return this.item == null ? new Base[0] : this.item.toArray(new Base[this.item.size()]); // LinkageItemComponent
484        default: return super.getProperty(hash, name, checkValid);
485        }
486
487      }
488
489      @Override
490      public void setProperty(int hash, String name, Base value) throws FHIRException {
491        switch (hash) {
492        case -1406328437: // author
493          this.author = castToReference(value); // Reference
494          break;
495        case 3242771: // item
496          this.getItem().add((LinkageItemComponent) value); // LinkageItemComponent
497          break;
498        default: super.setProperty(hash, name, value);
499        }
500
501      }
502
503      @Override
504      public void setProperty(String name, Base value) throws FHIRException {
505        if (name.equals("author"))
506          this.author = castToReference(value); // Reference
507        else if (name.equals("item"))
508          this.getItem().add((LinkageItemComponent) value);
509        else
510          super.setProperty(name, value);
511      }
512
513      @Override
514      public Base makeProperty(int hash, String name) throws FHIRException {
515        switch (hash) {
516        case -1406328437:  return getAuthor(); // Reference
517        case 3242771:  return addItem(); // LinkageItemComponent
518        default: return super.makeProperty(hash, name);
519        }
520
521      }
522
523      @Override
524      public Base addChild(String name) throws FHIRException {
525        if (name.equals("author")) {
526          this.author = new Reference();
527          return this.author;
528        }
529        else if (name.equals("item")) {
530          return addItem();
531        }
532        else
533          return super.addChild(name);
534      }
535
536  public String fhirType() {
537    return "Linkage";
538
539  }
540
541      public Linkage copy() {
542        Linkage dst = new Linkage();
543        copyValues(dst);
544        dst.author = author == null ? null : author.copy();
545        if (item != null) {
546          dst.item = new ArrayList<LinkageItemComponent>();
547          for (LinkageItemComponent i : item)
548            dst.item.add(i.copy());
549        };
550        return dst;
551      }
552
553      protected Linkage typedCopy() {
554        return copy();
555      }
556
557      @Override
558      public boolean equalsDeep(Base other) {
559        if (!super.equalsDeep(other))
560          return false;
561        if (!(other instanceof Linkage))
562          return false;
563        Linkage o = (Linkage) other;
564        return compareDeep(author, o.author, true) && compareDeep(item, o.item, true);
565      }
566
567      @Override
568      public boolean equalsShallow(Base other) {
569        if (!super.equalsShallow(other))
570          return false;
571        if (!(other instanceof Linkage))
572          return false;
573        Linkage o = (Linkage) other;
574        return true;
575      }
576
577      public boolean isEmpty() {
578        return super.isEmpty() && (author == null || author.isEmpty()) && (item == null || item.isEmpty())
579          ;
580      }
581
582  @Override
583  public ResourceType getResourceType() {
584    return ResourceType.Linkage;
585   }
586
587 /**
588   * Search parameter: <b>author</b>
589   * <p>
590   * Description: <b>Author of the Linkage</b><br>
591   * Type: <b>reference</b><br>
592   * Path: <b>Linkage.author</b><br>
593   * </p>
594   */
595  @SearchParamDefinition(name="author", path="Linkage.author", description="Author of the Linkage", type="reference" )
596  public static final String SP_AUTHOR = "author";
597 /**
598   * <b>Fluent Client</b> search parameter constant for <b>author</b>
599   * <p>
600   * Description: <b>Author of the Linkage</b><br>
601   * Type: <b>reference</b><br>
602   * Path: <b>Linkage.author</b><br>
603   * </p>
604   */
605  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam AUTHOR = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_AUTHOR);
606
607/**
608   * Constant for fluent queries to be used to add include statements. Specifies
609   * the path value of "<b>Linkage:author</b>".
610   */
611  public static final ca.uhn.fhir.model.api.Include INCLUDE_AUTHOR = new ca.uhn.fhir.model.api.Include("Linkage:author").toLocked();
612
613 /**
614   * Search parameter: <b>source</b>
615   * <p>
616   * Description: <b>Matches on any item in the Linkage with a type of 'source'</b><br>
617   * Type: <b>reference</b><br>
618   * Path: <b>Linkage.item.resource</b><br>
619   * </p>
620   */
621  @SearchParamDefinition(name="source", path="Linkage.item.resource", description="Matches on any item in the Linkage with a type of 'source'", type="reference" )
622  public static final String SP_SOURCE = "source";
623 /**
624   * <b>Fluent Client</b> search parameter constant for <b>source</b>
625   * <p>
626   * Description: <b>Matches on any item in the Linkage with a type of 'source'</b><br>
627   * Type: <b>reference</b><br>
628   * Path: <b>Linkage.item.resource</b><br>
629   * </p>
630   */
631  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam SOURCE = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_SOURCE);
632
633/**
634   * Constant for fluent queries to be used to add include statements. Specifies
635   * the path value of "<b>Linkage:source</b>".
636   */
637  public static final ca.uhn.fhir.model.api.Include INCLUDE_SOURCE = new ca.uhn.fhir.model.api.Include("Linkage:source").toLocked();
638
639 /**
640   * Search parameter: <b>item</b>
641   * <p>
642   * Description: <b>Matches on any item in the Linkage</b><br>
643   * Type: <b>reference</b><br>
644   * Path: <b>Linkage.item.resource</b><br>
645   * </p>
646   */
647  @SearchParamDefinition(name="item", path="Linkage.item.resource", description="Matches on any item in the Linkage", type="reference" )
648  public static final String SP_ITEM = "item";
649 /**
650   * <b>Fluent Client</b> search parameter constant for <b>item</b>
651   * <p>
652   * Description: <b>Matches on any item in the Linkage</b><br>
653   * Type: <b>reference</b><br>
654   * Path: <b>Linkage.item.resource</b><br>
655   * </p>
656   */
657  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam ITEM = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_ITEM);
658
659/**
660   * Constant for fluent queries to be used to add include statements. Specifies
661   * the path value of "<b>Linkage:item</b>".
662   */
663  public static final ca.uhn.fhir.model.api.Include INCLUDE_ITEM = new ca.uhn.fhir.model.api.Include("Linkage:item").toLocked();
664
665
666}