001package org.hl7.fhir.dstu3.model;
002
003
004
005/*
006  Copyright (c) 2011+, HL7, Inc.
007  All rights reserved.
008  
009  Redistribution and use in source and binary forms, with or without modification, 
010  are permitted provided that the following conditions are met:
011  
012   * Redistributions of source code must retain the above copyright notice, this 
013     list of conditions and the following disclaimer.
014   * Redistributions in binary form must reproduce the above copyright notice, 
015     this list of conditions and the following disclaimer in the documentation 
016     and/or other materials provided with the distribution.
017   * Neither the name of HL7 nor the names of its contributors may be used to 
018     endorse or promote products derived from this software without specific 
019     prior written permission.
020  
021  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
022  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
023  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
024  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
025  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
026  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
027  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
028  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
029  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
030  POSSIBILITY OF SUCH DAMAGE.
031  
032*/
033
034// Generated on Fri, Mar 16, 2018 15:21+1100 for FHIR v3.0.x
035import java.util.ArrayList;
036import java.util.Date;
037import java.util.List;
038
039import org.hl7.fhir.dstu3.model.Enumerations.PublicationStatus;
040import org.hl7.fhir.dstu3.model.Enumerations.PublicationStatusEnumFactory;
041import org.hl7.fhir.dstu3.model.Enumerations.SearchParamType;
042import org.hl7.fhir.dstu3.model.Enumerations.SearchParamTypeEnumFactory;
043import org.hl7.fhir.exceptions.FHIRException;
044import org.hl7.fhir.instance.model.api.IBaseBackboneElement;
045import org.hl7.fhir.utilities.Utilities;
046
047import ca.uhn.fhir.model.api.annotation.Block;
048import ca.uhn.fhir.model.api.annotation.Child;
049import ca.uhn.fhir.model.api.annotation.ChildOrder;
050import ca.uhn.fhir.model.api.annotation.Description;
051import ca.uhn.fhir.model.api.annotation.ResourceDef;
052import ca.uhn.fhir.model.api.annotation.SearchParamDefinition;
053/**
054 * A search parameter that defines a named search item that can be used to search/filter on a resource.
055 */
056@ResourceDef(name="SearchParameter", profile="http://hl7.org/fhir/Profile/SearchParameter")
057@ChildOrder(names={"url", "version", "name", "status", "experimental", "date", "publisher", "contact", "useContext", "jurisdiction", "purpose", "code", "base", "type", "derivedFrom", "description", "expression", "xpath", "xpathUsage", "target", "comparator", "modifier", "chain", "component"})
058public class SearchParameter extends MetadataResource {
059
060    public enum XPathUsageType {
061        /**
062         * The search parameter is derived directly from the selected nodes based on the type definitions.
063         */
064        NORMAL, 
065        /**
066         * The search parameter is derived by a phonetic transform from the selected nodes.
067         */
068        PHONETIC, 
069        /**
070         * The search parameter is based on a spatial transform of the selected nodes.
071         */
072        NEARBY, 
073        /**
074         * The search parameter is based on a spatial transform of the selected nodes, using physical distance from the middle.
075         */
076        DISTANCE, 
077        /**
078         * The interpretation of the xpath statement is unknown (and can't be automated).
079         */
080        OTHER, 
081        /**
082         * added to help the parsers with the generic types
083         */
084        NULL;
085        public static XPathUsageType fromCode(String codeString) throws FHIRException {
086            if (codeString == null || "".equals(codeString))
087                return null;
088        if ("normal".equals(codeString))
089          return NORMAL;
090        if ("phonetic".equals(codeString))
091          return PHONETIC;
092        if ("nearby".equals(codeString))
093          return NEARBY;
094        if ("distance".equals(codeString))
095          return DISTANCE;
096        if ("other".equals(codeString))
097          return OTHER;
098        if (Configuration.isAcceptInvalidEnums())
099          return null;
100        else
101          throw new FHIRException("Unknown XPathUsageType code '"+codeString+"'");
102        }
103        public String toCode() {
104          switch (this) {
105            case NORMAL: return "normal";
106            case PHONETIC: return "phonetic";
107            case NEARBY: return "nearby";
108            case DISTANCE: return "distance";
109            case OTHER: return "other";
110            case NULL: return null;
111            default: return "?";
112          }
113        }
114        public String getSystem() {
115          switch (this) {
116            case NORMAL: return "http://hl7.org/fhir/search-xpath-usage";
117            case PHONETIC: return "http://hl7.org/fhir/search-xpath-usage";
118            case NEARBY: return "http://hl7.org/fhir/search-xpath-usage";
119            case DISTANCE: return "http://hl7.org/fhir/search-xpath-usage";
120            case OTHER: return "http://hl7.org/fhir/search-xpath-usage";
121            case NULL: return null;
122            default: return "?";
123          }
124        }
125        public String getDefinition() {
126          switch (this) {
127            case NORMAL: return "The search parameter is derived directly from the selected nodes based on the type definitions.";
128            case PHONETIC: return "The search parameter is derived by a phonetic transform from the selected nodes.";
129            case NEARBY: return "The search parameter is based on a spatial transform of the selected nodes.";
130            case DISTANCE: return "The search parameter is based on a spatial transform of the selected nodes, using physical distance from the middle.";
131            case OTHER: return "The interpretation of the xpath statement is unknown (and can't be automated).";
132            case NULL: return null;
133            default: return "?";
134          }
135        }
136        public String getDisplay() {
137          switch (this) {
138            case NORMAL: return "Normal";
139            case PHONETIC: return "Phonetic";
140            case NEARBY: return "Nearby";
141            case DISTANCE: return "Distance";
142            case OTHER: return "Other";
143            case NULL: return null;
144            default: return "?";
145          }
146        }
147    }
148
149  public static class XPathUsageTypeEnumFactory implements EnumFactory<XPathUsageType> {
150    public XPathUsageType fromCode(String codeString) throws IllegalArgumentException {
151      if (codeString == null || "".equals(codeString))
152            if (codeString == null || "".equals(codeString))
153                return null;
154        if ("normal".equals(codeString))
155          return XPathUsageType.NORMAL;
156        if ("phonetic".equals(codeString))
157          return XPathUsageType.PHONETIC;
158        if ("nearby".equals(codeString))
159          return XPathUsageType.NEARBY;
160        if ("distance".equals(codeString))
161          return XPathUsageType.DISTANCE;
162        if ("other".equals(codeString))
163          return XPathUsageType.OTHER;
164        throw new IllegalArgumentException("Unknown XPathUsageType code '"+codeString+"'");
165        }
166        public Enumeration<XPathUsageType> fromType(Base code) throws FHIRException {
167          if (code == null)
168            return null;
169          if (code.isEmpty())
170            return new Enumeration<XPathUsageType>(this);
171          String codeString = ((PrimitiveType) code).asStringValue();
172          if (codeString == null || "".equals(codeString))
173            return null;
174        if ("normal".equals(codeString))
175          return new Enumeration<XPathUsageType>(this, XPathUsageType.NORMAL);
176        if ("phonetic".equals(codeString))
177          return new Enumeration<XPathUsageType>(this, XPathUsageType.PHONETIC);
178        if ("nearby".equals(codeString))
179          return new Enumeration<XPathUsageType>(this, XPathUsageType.NEARBY);
180        if ("distance".equals(codeString))
181          return new Enumeration<XPathUsageType>(this, XPathUsageType.DISTANCE);
182        if ("other".equals(codeString))
183          return new Enumeration<XPathUsageType>(this, XPathUsageType.OTHER);
184        throw new FHIRException("Unknown XPathUsageType code '"+codeString+"'");
185        }
186    public String toCode(XPathUsageType code) {
187      if (code == XPathUsageType.NORMAL)
188        return "normal";
189      if (code == XPathUsageType.PHONETIC)
190        return "phonetic";
191      if (code == XPathUsageType.NEARBY)
192        return "nearby";
193      if (code == XPathUsageType.DISTANCE)
194        return "distance";
195      if (code == XPathUsageType.OTHER)
196        return "other";
197      return "?";
198      }
199    public String toSystem(XPathUsageType code) {
200      return code.getSystem();
201      }
202    }
203
204    public enum SearchComparator {
205        /**
206         * the value for the parameter in the resource is equal to the provided value
207         */
208        EQ, 
209        /**
210         * the value for the parameter in the resource is not equal to the provided value
211         */
212        NE, 
213        /**
214         * the value for the parameter in the resource is greater than the provided value
215         */
216        GT, 
217        /**
218         * the value for the parameter in the resource is less than the provided value
219         */
220        LT, 
221        /**
222         * the value for the parameter in the resource is greater or equal to the provided value
223         */
224        GE, 
225        /**
226         * the value for the parameter in the resource is less or equal to the provided value
227         */
228        LE, 
229        /**
230         * the value for the parameter in the resource starts after the provided value
231         */
232        SA, 
233        /**
234         * the value for the parameter in the resource ends before the provided value
235         */
236        EB, 
237        /**
238         * the value for the parameter in the resource is approximately the same to the provided value.
239         */
240        AP, 
241        /**
242         * added to help the parsers with the generic types
243         */
244        NULL;
245        public static SearchComparator fromCode(String codeString) throws FHIRException {
246            if (codeString == null || "".equals(codeString))
247                return null;
248        if ("eq".equals(codeString))
249          return EQ;
250        if ("ne".equals(codeString))
251          return NE;
252        if ("gt".equals(codeString))
253          return GT;
254        if ("lt".equals(codeString))
255          return LT;
256        if ("ge".equals(codeString))
257          return GE;
258        if ("le".equals(codeString))
259          return LE;
260        if ("sa".equals(codeString))
261          return SA;
262        if ("eb".equals(codeString))
263          return EB;
264        if ("ap".equals(codeString))
265          return AP;
266        if (Configuration.isAcceptInvalidEnums())
267          return null;
268        else
269          throw new FHIRException("Unknown SearchComparator code '"+codeString+"'");
270        }
271        public String toCode() {
272          switch (this) {
273            case EQ: return "eq";
274            case NE: return "ne";
275            case GT: return "gt";
276            case LT: return "lt";
277            case GE: return "ge";
278            case LE: return "le";
279            case SA: return "sa";
280            case EB: return "eb";
281            case AP: return "ap";
282            case NULL: return null;
283            default: return "?";
284          }
285        }
286        public String getSystem() {
287          switch (this) {
288            case EQ: return "http://hl7.org/fhir/search-comparator";
289            case NE: return "http://hl7.org/fhir/search-comparator";
290            case GT: return "http://hl7.org/fhir/search-comparator";
291            case LT: return "http://hl7.org/fhir/search-comparator";
292            case GE: return "http://hl7.org/fhir/search-comparator";
293            case LE: return "http://hl7.org/fhir/search-comparator";
294            case SA: return "http://hl7.org/fhir/search-comparator";
295            case EB: return "http://hl7.org/fhir/search-comparator";
296            case AP: return "http://hl7.org/fhir/search-comparator";
297            case NULL: return null;
298            default: return "?";
299          }
300        }
301        public String getDefinition() {
302          switch (this) {
303            case EQ: return "the value for the parameter in the resource is equal to the provided value";
304            case NE: return "the value for the parameter in the resource is not equal to the provided value";
305            case GT: return "the value for the parameter in the resource is greater than the provided value";
306            case LT: return "the value for the parameter in the resource is less than the provided value";
307            case GE: return "the value for the parameter in the resource is greater or equal to the provided value";
308            case LE: return "the value for the parameter in the resource is less or equal to the provided value";
309            case SA: return "the value for the parameter in the resource starts after the provided value";
310            case EB: return "the value for the parameter in the resource ends before the provided value";
311            case AP: return "the value for the parameter in the resource is approximately the same to the provided value.";
312            case NULL: return null;
313            default: return "?";
314          }
315        }
316        public String getDisplay() {
317          switch (this) {
318            case EQ: return "Equals";
319            case NE: return "Not Equals";
320            case GT: return "Greater Than";
321            case LT: return "Less Then";
322            case GE: return "Greater or Equals";
323            case LE: return "Less of Equal";
324            case SA: return "Starts After";
325            case EB: return "Ends Before";
326            case AP: return "Approximately";
327            case NULL: return null;
328            default: return "?";
329          }
330        }
331    }
332
333  public static class SearchComparatorEnumFactory implements EnumFactory<SearchComparator> {
334    public SearchComparator fromCode(String codeString) throws IllegalArgumentException {
335      if (codeString == null || "".equals(codeString))
336            if (codeString == null || "".equals(codeString))
337                return null;
338        if ("eq".equals(codeString))
339          return SearchComparator.EQ;
340        if ("ne".equals(codeString))
341          return SearchComparator.NE;
342        if ("gt".equals(codeString))
343          return SearchComparator.GT;
344        if ("lt".equals(codeString))
345          return SearchComparator.LT;
346        if ("ge".equals(codeString))
347          return SearchComparator.GE;
348        if ("le".equals(codeString))
349          return SearchComparator.LE;
350        if ("sa".equals(codeString))
351          return SearchComparator.SA;
352        if ("eb".equals(codeString))
353          return SearchComparator.EB;
354        if ("ap".equals(codeString))
355          return SearchComparator.AP;
356        throw new IllegalArgumentException("Unknown SearchComparator code '"+codeString+"'");
357        }
358        public Enumeration<SearchComparator> fromType(Base code) throws FHIRException {
359          if (code == null)
360            return null;
361          if (code.isEmpty())
362            return new Enumeration<SearchComparator>(this);
363          String codeString = ((PrimitiveType) code).asStringValue();
364          if (codeString == null || "".equals(codeString))
365            return null;
366        if ("eq".equals(codeString))
367          return new Enumeration<SearchComparator>(this, SearchComparator.EQ);
368        if ("ne".equals(codeString))
369          return new Enumeration<SearchComparator>(this, SearchComparator.NE);
370        if ("gt".equals(codeString))
371          return new Enumeration<SearchComparator>(this, SearchComparator.GT);
372        if ("lt".equals(codeString))
373          return new Enumeration<SearchComparator>(this, SearchComparator.LT);
374        if ("ge".equals(codeString))
375          return new Enumeration<SearchComparator>(this, SearchComparator.GE);
376        if ("le".equals(codeString))
377          return new Enumeration<SearchComparator>(this, SearchComparator.LE);
378        if ("sa".equals(codeString))
379          return new Enumeration<SearchComparator>(this, SearchComparator.SA);
380        if ("eb".equals(codeString))
381          return new Enumeration<SearchComparator>(this, SearchComparator.EB);
382        if ("ap".equals(codeString))
383          return new Enumeration<SearchComparator>(this, SearchComparator.AP);
384        throw new FHIRException("Unknown SearchComparator code '"+codeString+"'");
385        }
386    public String toCode(SearchComparator code) {
387      if (code == SearchComparator.EQ)
388        return "eq";
389      if (code == SearchComparator.NE)
390        return "ne";
391      if (code == SearchComparator.GT)
392        return "gt";
393      if (code == SearchComparator.LT)
394        return "lt";
395      if (code == SearchComparator.GE)
396        return "ge";
397      if (code == SearchComparator.LE)
398        return "le";
399      if (code == SearchComparator.SA)
400        return "sa";
401      if (code == SearchComparator.EB)
402        return "eb";
403      if (code == SearchComparator.AP)
404        return "ap";
405      return "?";
406      }
407    public String toSystem(SearchComparator code) {
408      return code.getSystem();
409      }
410    }
411
412    public enum SearchModifierCode {
413        /**
414         * The search parameter returns resources that have a value or not.
415         */
416        MISSING, 
417        /**
418         * The search parameter returns resources that have a value that exactly matches the supplied parameter (the whole string, including casing and accents).
419         */
420        EXACT, 
421        /**
422         * The search parameter returns resources that include the supplied parameter value anywhere within the field being searched.
423         */
424        CONTAINS, 
425        /**
426         * The search parameter returns resources that do not contain a match.
427         */
428        NOT, 
429        /**
430         * The search parameter is processed as a string that searches text associated with the code/value - either CodeableConcept.text, Coding.display, or Identifier.type.text.
431         */
432        TEXT, 
433        /**
434         * The search parameter is a URI (relative or absolute) that identifies a value set, and the search parameter tests whether the coding is in the specified value set.
435         */
436        IN, 
437        /**
438         * The search parameter is a URI (relative or absolute) that identifies a value set, and the search parameter tests whether the coding is not in the specified value set.
439         */
440        NOTIN, 
441        /**
442         * The search parameter tests whether the value in a resource is subsumed by the specified value (is-a, or hierarchical relationships).
443         */
444        BELOW, 
445        /**
446         * The search parameter tests whether the value in a resource subsumes the specified value (is-a, or hierarchical relationships).
447         */
448        ABOVE, 
449        /**
450         * The search parameter only applies to the Resource Type specified as a modifier (e.g. the modifier is not actually :type, but :Patient etc.).
451         */
452        TYPE, 
453        /**
454         * added to help the parsers with the generic types
455         */
456        NULL;
457        public static SearchModifierCode fromCode(String codeString) throws FHIRException {
458            if (codeString == null || "".equals(codeString))
459                return null;
460        if ("missing".equals(codeString))
461          return MISSING;
462        if ("exact".equals(codeString))
463          return EXACT;
464        if ("contains".equals(codeString))
465          return CONTAINS;
466        if ("not".equals(codeString))
467          return NOT;
468        if ("text".equals(codeString))
469          return TEXT;
470        if ("in".equals(codeString))
471          return IN;
472        if ("not-in".equals(codeString))
473          return NOTIN;
474        if ("below".equals(codeString))
475          return BELOW;
476        if ("above".equals(codeString))
477          return ABOVE;
478        if ("type".equals(codeString))
479          return TYPE;
480        if (Configuration.isAcceptInvalidEnums())
481          return null;
482        else
483          throw new FHIRException("Unknown SearchModifierCode code '"+codeString+"'");
484        }
485        public String toCode() {
486          switch (this) {
487            case MISSING: return "missing";
488            case EXACT: return "exact";
489            case CONTAINS: return "contains";
490            case NOT: return "not";
491            case TEXT: return "text";
492            case IN: return "in";
493            case NOTIN: return "not-in";
494            case BELOW: return "below";
495            case ABOVE: return "above";
496            case TYPE: return "type";
497            case NULL: return null;
498            default: return "?";
499          }
500        }
501        public String getSystem() {
502          switch (this) {
503            case MISSING: return "http://hl7.org/fhir/search-modifier-code";
504            case EXACT: return "http://hl7.org/fhir/search-modifier-code";
505            case CONTAINS: return "http://hl7.org/fhir/search-modifier-code";
506            case NOT: return "http://hl7.org/fhir/search-modifier-code";
507            case TEXT: return "http://hl7.org/fhir/search-modifier-code";
508            case IN: return "http://hl7.org/fhir/search-modifier-code";
509            case NOTIN: return "http://hl7.org/fhir/search-modifier-code";
510            case BELOW: return "http://hl7.org/fhir/search-modifier-code";
511            case ABOVE: return "http://hl7.org/fhir/search-modifier-code";
512            case TYPE: return "http://hl7.org/fhir/search-modifier-code";
513            case NULL: return null;
514            default: return "?";
515          }
516        }
517        public String getDefinition() {
518          switch (this) {
519            case MISSING: return "The search parameter returns resources that have a value or not.";
520            case EXACT: return "The search parameter returns resources that have a value that exactly matches the supplied parameter (the whole string, including casing and accents).";
521            case CONTAINS: return "The search parameter returns resources that include the supplied parameter value anywhere within the field being searched.";
522            case NOT: return "The search parameter returns resources that do not contain a match.";
523            case TEXT: return "The search parameter is processed as a string that searches text associated with the code/value - either CodeableConcept.text, Coding.display, or Identifier.type.text.";
524            case IN: return "The search parameter is a URI (relative or absolute) that identifies a value set, and the search parameter tests whether the coding is in the specified value set.";
525            case NOTIN: return "The search parameter is a URI (relative or absolute) that identifies a value set, and the search parameter tests whether the coding is not in the specified value set.";
526            case BELOW: return "The search parameter tests whether the value in a resource is subsumed by the specified value (is-a, or hierarchical relationships).";
527            case ABOVE: return "The search parameter tests whether the value in a resource subsumes the specified value (is-a, or hierarchical relationships).";
528            case TYPE: return "The search parameter only applies to the Resource Type specified as a modifier (e.g. the modifier is not actually :type, but :Patient etc.).";
529            case NULL: return null;
530            default: return "?";
531          }
532        }
533        public String getDisplay() {
534          switch (this) {
535            case MISSING: return "Missing";
536            case EXACT: return "Exact";
537            case CONTAINS: return "Contains";
538            case NOT: return "Not";
539            case TEXT: return "Text";
540            case IN: return "In";
541            case NOTIN: return "Not In";
542            case BELOW: return "Below";
543            case ABOVE: return "Above";
544            case TYPE: return "Type";
545            case NULL: return null;
546            default: return "?";
547          }
548        }
549    }
550
551  public static class SearchModifierCodeEnumFactory implements EnumFactory<SearchModifierCode> {
552    public SearchModifierCode fromCode(String codeString) throws IllegalArgumentException {
553      if (codeString == null || "".equals(codeString))
554            if (codeString == null || "".equals(codeString))
555                return null;
556        if ("missing".equals(codeString))
557          return SearchModifierCode.MISSING;
558        if ("exact".equals(codeString))
559          return SearchModifierCode.EXACT;
560        if ("contains".equals(codeString))
561          return SearchModifierCode.CONTAINS;
562        if ("not".equals(codeString))
563          return SearchModifierCode.NOT;
564        if ("text".equals(codeString))
565          return SearchModifierCode.TEXT;
566        if ("in".equals(codeString))
567          return SearchModifierCode.IN;
568        if ("not-in".equals(codeString))
569          return SearchModifierCode.NOTIN;
570        if ("below".equals(codeString))
571          return SearchModifierCode.BELOW;
572        if ("above".equals(codeString))
573          return SearchModifierCode.ABOVE;
574        if ("type".equals(codeString))
575          return SearchModifierCode.TYPE;
576        throw new IllegalArgumentException("Unknown SearchModifierCode code '"+codeString+"'");
577        }
578        public Enumeration<SearchModifierCode> fromType(Base code) throws FHIRException {
579          if (code == null)
580            return null;
581          if (code.isEmpty())
582            return new Enumeration<SearchModifierCode>(this);
583          String codeString = ((PrimitiveType) code).asStringValue();
584          if (codeString == null || "".equals(codeString))
585            return null;
586        if ("missing".equals(codeString))
587          return new Enumeration<SearchModifierCode>(this, SearchModifierCode.MISSING);
588        if ("exact".equals(codeString))
589          return new Enumeration<SearchModifierCode>(this, SearchModifierCode.EXACT);
590        if ("contains".equals(codeString))
591          return new Enumeration<SearchModifierCode>(this, SearchModifierCode.CONTAINS);
592        if ("not".equals(codeString))
593          return new Enumeration<SearchModifierCode>(this, SearchModifierCode.NOT);
594        if ("text".equals(codeString))
595          return new Enumeration<SearchModifierCode>(this, SearchModifierCode.TEXT);
596        if ("in".equals(codeString))
597          return new Enumeration<SearchModifierCode>(this, SearchModifierCode.IN);
598        if ("not-in".equals(codeString))
599          return new Enumeration<SearchModifierCode>(this, SearchModifierCode.NOTIN);
600        if ("below".equals(codeString))
601          return new Enumeration<SearchModifierCode>(this, SearchModifierCode.BELOW);
602        if ("above".equals(codeString))
603          return new Enumeration<SearchModifierCode>(this, SearchModifierCode.ABOVE);
604        if ("type".equals(codeString))
605          return new Enumeration<SearchModifierCode>(this, SearchModifierCode.TYPE);
606        throw new FHIRException("Unknown SearchModifierCode code '"+codeString+"'");
607        }
608    public String toCode(SearchModifierCode code) {
609      if (code == SearchModifierCode.MISSING)
610        return "missing";
611      if (code == SearchModifierCode.EXACT)
612        return "exact";
613      if (code == SearchModifierCode.CONTAINS)
614        return "contains";
615      if (code == SearchModifierCode.NOT)
616        return "not";
617      if (code == SearchModifierCode.TEXT)
618        return "text";
619      if (code == SearchModifierCode.IN)
620        return "in";
621      if (code == SearchModifierCode.NOTIN)
622        return "not-in";
623      if (code == SearchModifierCode.BELOW)
624        return "below";
625      if (code == SearchModifierCode.ABOVE)
626        return "above";
627      if (code == SearchModifierCode.TYPE)
628        return "type";
629      return "?";
630      }
631    public String toSystem(SearchModifierCode code) {
632      return code.getSystem();
633      }
634    }
635
636    @Block()
637    public static class SearchParameterComponentComponent extends BackboneElement implements IBaseBackboneElement {
638        /**
639         * The definition of the search parameter that describes this part.
640         */
641        @Child(name = "definition", type = {SearchParameter.class}, order=1, min=1, max=1, modifier=false, summary=false)
642        @Description(shortDefinition="Defines how the part works", formalDefinition="The definition of the search parameter that describes this part." )
643        protected Reference definition;
644
645        /**
646         * The actual object that is the target of the reference (The definition of the search parameter that describes this part.)
647         */
648        protected SearchParameter definitionTarget;
649
650        /**
651         * A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression.
652         */
653        @Child(name = "expression", type = {StringType.class}, order=2, min=1, max=1, modifier=false, summary=false)
654        @Description(shortDefinition="Subexpression relative to main expression", formalDefinition="A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression." )
655        protected StringType expression;
656
657        private static final long serialVersionUID = -1105563614L;
658
659    /**
660     * Constructor
661     */
662      public SearchParameterComponentComponent() {
663        super();
664      }
665
666    /**
667     * Constructor
668     */
669      public SearchParameterComponentComponent(Reference definition, StringType expression) {
670        super();
671        this.definition = definition;
672        this.expression = expression;
673      }
674
675        /**
676         * @return {@link #definition} (The definition of the search parameter that describes this part.)
677         */
678        public Reference getDefinition() { 
679          if (this.definition == null)
680            if (Configuration.errorOnAutoCreate())
681              throw new Error("Attempt to auto-create SearchParameterComponentComponent.definition");
682            else if (Configuration.doAutoCreate())
683              this.definition = new Reference(); // cc
684          return this.definition;
685        }
686
687        public boolean hasDefinition() { 
688          return this.definition != null && !this.definition.isEmpty();
689        }
690
691        /**
692         * @param value {@link #definition} (The definition of the search parameter that describes this part.)
693         */
694        public SearchParameterComponentComponent setDefinition(Reference value)  { 
695          this.definition = value;
696          return this;
697        }
698
699        /**
700         * @return {@link #definition} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The definition of the search parameter that describes this part.)
701         */
702        public SearchParameter getDefinitionTarget() { 
703          if (this.definitionTarget == null)
704            if (Configuration.errorOnAutoCreate())
705              throw new Error("Attempt to auto-create SearchParameterComponentComponent.definition");
706            else if (Configuration.doAutoCreate())
707              this.definitionTarget = new SearchParameter(); // aa
708          return this.definitionTarget;
709        }
710
711        /**
712         * @param value {@link #definition} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The definition of the search parameter that describes this part.)
713         */
714        public SearchParameterComponentComponent setDefinitionTarget(SearchParameter value) { 
715          this.definitionTarget = value;
716          return this;
717        }
718
719        /**
720         * @return {@link #expression} (A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value
721         */
722        public StringType getExpressionElement() { 
723          if (this.expression == null)
724            if (Configuration.errorOnAutoCreate())
725              throw new Error("Attempt to auto-create SearchParameterComponentComponent.expression");
726            else if (Configuration.doAutoCreate())
727              this.expression = new StringType(); // bb
728          return this.expression;
729        }
730
731        public boolean hasExpressionElement() { 
732          return this.expression != null && !this.expression.isEmpty();
733        }
734
735        public boolean hasExpression() { 
736          return this.expression != null && !this.expression.isEmpty();
737        }
738
739        /**
740         * @param value {@link #expression} (A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value
741         */
742        public SearchParameterComponentComponent setExpressionElement(StringType value) { 
743          this.expression = value;
744          return this;
745        }
746
747        /**
748         * @return A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression.
749         */
750        public String getExpression() { 
751          return this.expression == null ? null : this.expression.getValue();
752        }
753
754        /**
755         * @param value A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression.
756         */
757        public SearchParameterComponentComponent setExpression(String value) { 
758            if (this.expression == null)
759              this.expression = new StringType();
760            this.expression.setValue(value);
761          return this;
762        }
763
764        protected void listChildren(List<Property> children) {
765          super.listChildren(children);
766          children.add(new Property("definition", "Reference(SearchParameter)", "The definition of the search parameter that describes this part.", 0, 1, definition));
767          children.add(new Property("expression", "string", "A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression.", 0, 1, expression));
768        }
769
770        @Override
771        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
772          switch (_hash) {
773          case -1014418093: /*definition*/  return new Property("definition", "Reference(SearchParameter)", "The definition of the search parameter that describes this part.", 0, 1, definition);
774          case -1795452264: /*expression*/  return new Property("expression", "string", "A sub-expression that defines how to extract values for this component from the output of the main SearchParameter.expression.", 0, 1, expression);
775          default: return super.getNamedProperty(_hash, _name, _checkValid);
776          }
777
778        }
779
780      @Override
781      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
782        switch (hash) {
783        case -1014418093: /*definition*/ return this.definition == null ? new Base[0] : new Base[] {this.definition}; // Reference
784        case -1795452264: /*expression*/ return this.expression == null ? new Base[0] : new Base[] {this.expression}; // StringType
785        default: return super.getProperty(hash, name, checkValid);
786        }
787
788      }
789
790      @Override
791      public Base setProperty(int hash, String name, Base value) throws FHIRException {
792        switch (hash) {
793        case -1014418093: // definition
794          this.definition = castToReference(value); // Reference
795          return value;
796        case -1795452264: // expression
797          this.expression = castToString(value); // StringType
798          return value;
799        default: return super.setProperty(hash, name, value);
800        }
801
802      }
803
804      @Override
805      public Base setProperty(String name, Base value) throws FHIRException {
806        if (name.equals("definition")) {
807          this.definition = castToReference(value); // Reference
808        } else if (name.equals("expression")) {
809          this.expression = castToString(value); // StringType
810        } else
811          return super.setProperty(name, value);
812        return value;
813      }
814
815      @Override
816      public Base makeProperty(int hash, String name) throws FHIRException {
817        switch (hash) {
818        case -1014418093:  return getDefinition(); 
819        case -1795452264:  return getExpressionElement();
820        default: return super.makeProperty(hash, name);
821        }
822
823      }
824
825      @Override
826      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
827        switch (hash) {
828        case -1014418093: /*definition*/ return new String[] {"Reference"};
829        case -1795452264: /*expression*/ return new String[] {"string"};
830        default: return super.getTypesForProperty(hash, name);
831        }
832
833      }
834
835      @Override
836      public Base addChild(String name) throws FHIRException {
837        if (name.equals("definition")) {
838          this.definition = new Reference();
839          return this.definition;
840        }
841        else if (name.equals("expression")) {
842          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.expression");
843        }
844        else
845          return super.addChild(name);
846      }
847
848      public SearchParameterComponentComponent copy() {
849        SearchParameterComponentComponent dst = new SearchParameterComponentComponent();
850        copyValues(dst);
851        dst.definition = definition == null ? null : definition.copy();
852        dst.expression = expression == null ? null : expression.copy();
853        return dst;
854      }
855
856      @Override
857      public boolean equalsDeep(Base other_) {
858        if (!super.equalsDeep(other_))
859          return false;
860        if (!(other_ instanceof SearchParameterComponentComponent))
861          return false;
862        SearchParameterComponentComponent o = (SearchParameterComponentComponent) other_;
863        return compareDeep(definition, o.definition, true) && compareDeep(expression, o.expression, true)
864          ;
865      }
866
867      @Override
868      public boolean equalsShallow(Base other_) {
869        if (!super.equalsShallow(other_))
870          return false;
871        if (!(other_ instanceof SearchParameterComponentComponent))
872          return false;
873        SearchParameterComponentComponent o = (SearchParameterComponentComponent) other_;
874        return compareValues(expression, o.expression, true);
875      }
876
877      public boolean isEmpty() {
878        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(definition, expression);
879      }
880
881  public String fhirType() {
882    return "SearchParameter.component";
883
884  }
885
886  }
887
888    /**
889     * Explaination of why this search parameter is needed and why it has been designed as it has.
890     */
891    @Child(name = "purpose", type = {MarkdownType.class}, order=0, min=0, max=1, modifier=false, summary=false)
892    @Description(shortDefinition="Why this search parameter is defined", formalDefinition="Explaination of why this search parameter is needed and why it has been designed as it has." )
893    protected MarkdownType purpose;
894
895    /**
896     * The code used in the URL or the parameter name in a parameters resource for this search parameter.
897     */
898    @Child(name = "code", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true)
899    @Description(shortDefinition="Code used in URL", formalDefinition="The code used in the URL or the parameter name in a parameters resource for this search parameter." )
900    protected CodeType code;
901
902    /**
903     * The base resource type(s) that this search parameter can be used against.
904     */
905    @Child(name = "base", type = {CodeType.class}, order=2, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
906    @Description(shortDefinition="The resource type(s) this search parameter applies to", formalDefinition="The base resource type(s) that this search parameter can be used against." )
907    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/resource-types")
908    protected List<CodeType> base;
909
910    /**
911     * The type of value a search parameter refers to, and how the content is interpreted.
912     */
913    @Child(name = "type", type = {CodeType.class}, order=3, min=1, max=1, modifier=false, summary=true)
914    @Description(shortDefinition="number | date | string | token | reference | composite | quantity | uri", formalDefinition="The type of value a search parameter refers to, and how the content is interpreted." )
915    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/search-param-type")
916    protected Enumeration<SearchParamType> type;
917
918    /**
919     * Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter.
920     */
921    @Child(name = "derivedFrom", type = {UriType.class}, order=4, min=0, max=1, modifier=false, summary=false)
922    @Description(shortDefinition="Original Definition for the search parameter", formalDefinition="Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter." )
923    protected UriType derivedFrom;
924
925    /**
926     * A FHIRPath expression that returns a set of elements for the search parameter.
927     */
928    @Child(name = "expression", type = {StringType.class}, order=5, min=0, max=1, modifier=false, summary=false)
929    @Description(shortDefinition="FHIRPath expression that extracts the values", formalDefinition="A FHIRPath expression that returns a set of elements for the search parameter." )
930    protected StringType expression;
931
932    /**
933     * An XPath expression that returns a set of elements for the search parameter.
934     */
935    @Child(name = "xpath", type = {StringType.class}, order=6, min=0, max=1, modifier=false, summary=false)
936    @Description(shortDefinition="XPath that extracts the values", formalDefinition="An XPath expression that returns a set of elements for the search parameter." )
937    protected StringType xpath;
938
939    /**
940     * How the search parameter relates to the set of elements returned by evaluating the xpath query.
941     */
942    @Child(name = "xpathUsage", type = {CodeType.class}, order=7, min=0, max=1, modifier=false, summary=false)
943    @Description(shortDefinition="normal | phonetic | nearby | distance | other", formalDefinition="How the search parameter relates to the set of elements returned by evaluating the xpath query." )
944    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/search-xpath-usage")
945    protected Enumeration<XPathUsageType> xpathUsage;
946
947    /**
948     * Types of resource (if a resource is referenced).
949     */
950    @Child(name = "target", type = {CodeType.class}, order=8, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
951    @Description(shortDefinition="Types of resource (if a resource reference)", formalDefinition="Types of resource (if a resource is referenced)." )
952    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/resource-types")
953    protected List<CodeType> target;
954
955    /**
956     * Comparators supported for the search parameter.
957     */
958    @Child(name = "comparator", type = {CodeType.class}, order=9, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
959    @Description(shortDefinition="eq | ne | gt | lt | ge | le | sa | eb | ap", formalDefinition="Comparators supported for the search parameter." )
960    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/search-comparator")
961    protected List<Enumeration<SearchComparator>> comparator;
962
963    /**
964     * A modifier supported for the search parameter.
965     */
966    @Child(name = "modifier", type = {CodeType.class}, order=10, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
967    @Description(shortDefinition="missing | exact | contains | not | text | in | not-in | below | above | type", formalDefinition="A modifier supported for the search parameter." )
968    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/search-modifier-code")
969    protected List<Enumeration<SearchModifierCode>> modifier;
970
971    /**
972     * Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.
973     */
974    @Child(name = "chain", type = {StringType.class}, order=11, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
975    @Description(shortDefinition="Chained names supported", formalDefinition="Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type." )
976    protected List<StringType> chain;
977
978    /**
979     * Used to define the parts of a composite search parameter.
980     */
981    @Child(name = "component", type = {}, order=12, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
982    @Description(shortDefinition="For Composite resources to define the parts", formalDefinition="Used to define the parts of a composite search parameter." )
983    protected List<SearchParameterComponentComponent> component;
984
985    private static final long serialVersionUID = -769368159L;
986
987  /**
988   * Constructor
989   */
990    public SearchParameter() {
991      super();
992    }
993
994  /**
995   * Constructor
996   */
997    public SearchParameter(UriType url, StringType name, Enumeration<PublicationStatus> status, CodeType code, Enumeration<SearchParamType> type, MarkdownType description) {
998      super();
999      this.url = url;
1000      this.name = name;
1001      this.status = status;
1002      this.code = code;
1003      this.type = type;
1004      this.description = description;
1005    }
1006
1007    /**
1008     * @return {@link #url} (An absolute URI that is used to identify this search parameter when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this search parameter is (or will be) published. The URL SHOULD include the major version of the search parameter. For more information see [Technical and Business Versions](resource.html#versions).). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
1009     */
1010    public UriType getUrlElement() { 
1011      if (this.url == null)
1012        if (Configuration.errorOnAutoCreate())
1013          throw new Error("Attempt to auto-create SearchParameter.url");
1014        else if (Configuration.doAutoCreate())
1015          this.url = new UriType(); // bb
1016      return this.url;
1017    }
1018
1019    public boolean hasUrlElement() { 
1020      return this.url != null && !this.url.isEmpty();
1021    }
1022
1023    public boolean hasUrl() { 
1024      return this.url != null && !this.url.isEmpty();
1025    }
1026
1027    /**
1028     * @param value {@link #url} (An absolute URI that is used to identify this search parameter when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this search parameter is (or will be) published. The URL SHOULD include the major version of the search parameter. For more information see [Technical and Business Versions](resource.html#versions).). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
1029     */
1030    public SearchParameter setUrlElement(UriType value) { 
1031      this.url = value;
1032      return this;
1033    }
1034
1035    /**
1036     * @return An absolute URI that is used to identify this search parameter when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this search parameter is (or will be) published. The URL SHOULD include the major version of the search parameter. For more information see [Technical and Business Versions](resource.html#versions).
1037     */
1038    public String getUrl() { 
1039      return this.url == null ? null : this.url.getValue();
1040    }
1041
1042    /**
1043     * @param value An absolute URI that is used to identify this search parameter when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this search parameter is (or will be) published. The URL SHOULD include the major version of the search parameter. For more information see [Technical and Business Versions](resource.html#versions).
1044     */
1045    public SearchParameter setUrl(String value) { 
1046        if (this.url == null)
1047          this.url = new UriType();
1048        this.url.setValue(value);
1049      return this;
1050    }
1051
1052    /**
1053     * @return {@link #version} (The identifier that is used to identify this version of the search parameter when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the search parameter author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value
1054     */
1055    public StringType getVersionElement() { 
1056      if (this.version == null)
1057        if (Configuration.errorOnAutoCreate())
1058          throw new Error("Attempt to auto-create SearchParameter.version");
1059        else if (Configuration.doAutoCreate())
1060          this.version = new StringType(); // bb
1061      return this.version;
1062    }
1063
1064    public boolean hasVersionElement() { 
1065      return this.version != null && !this.version.isEmpty();
1066    }
1067
1068    public boolean hasVersion() { 
1069      return this.version != null && !this.version.isEmpty();
1070    }
1071
1072    /**
1073     * @param value {@link #version} (The identifier that is used to identify this version of the search parameter when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the search parameter author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value
1074     */
1075    public SearchParameter setVersionElement(StringType value) { 
1076      this.version = value;
1077      return this;
1078    }
1079
1080    /**
1081     * @return The identifier that is used to identify this version of the search parameter when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the search parameter author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.
1082     */
1083    public String getVersion() { 
1084      return this.version == null ? null : this.version.getValue();
1085    }
1086
1087    /**
1088     * @param value The identifier that is used to identify this version of the search parameter when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the search parameter author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.
1089     */
1090    public SearchParameter setVersion(String value) { 
1091      if (Utilities.noString(value))
1092        this.version = null;
1093      else {
1094        if (this.version == null)
1095          this.version = new StringType();
1096        this.version.setValue(value);
1097      }
1098      return this;
1099    }
1100
1101    /**
1102     * @return {@link #name} (A natural language name identifying the search parameter. This name should be usable as an identifier for the module by machine processing applications such as code generation.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
1103     */
1104    public StringType getNameElement() { 
1105      if (this.name == null)
1106        if (Configuration.errorOnAutoCreate())
1107          throw new Error("Attempt to auto-create SearchParameter.name");
1108        else if (Configuration.doAutoCreate())
1109          this.name = new StringType(); // bb
1110      return this.name;
1111    }
1112
1113    public boolean hasNameElement() { 
1114      return this.name != null && !this.name.isEmpty();
1115    }
1116
1117    public boolean hasName() { 
1118      return this.name != null && !this.name.isEmpty();
1119    }
1120
1121    /**
1122     * @param value {@link #name} (A natural language name identifying the search parameter. This name should be usable as an identifier for the module by machine processing applications such as code generation.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
1123     */
1124    public SearchParameter setNameElement(StringType value) { 
1125      this.name = value;
1126      return this;
1127    }
1128
1129    /**
1130     * @return A natural language name identifying the search parameter. This name should be usable as an identifier for the module by machine processing applications such as code generation.
1131     */
1132    public String getName() { 
1133      return this.name == null ? null : this.name.getValue();
1134    }
1135
1136    /**
1137     * @param value A natural language name identifying the search parameter. This name should be usable as an identifier for the module by machine processing applications such as code generation.
1138     */
1139    public SearchParameter setName(String value) { 
1140        if (this.name == null)
1141          this.name = new StringType();
1142        this.name.setValue(value);
1143      return this;
1144    }
1145
1146    /**
1147     * @return {@link #status} (The status of this search parameter. Enables tracking the life-cycle of the content.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value
1148     */
1149    public Enumeration<PublicationStatus> getStatusElement() { 
1150      if (this.status == null)
1151        if (Configuration.errorOnAutoCreate())
1152          throw new Error("Attempt to auto-create SearchParameter.status");
1153        else if (Configuration.doAutoCreate())
1154          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb
1155      return this.status;
1156    }
1157
1158    public boolean hasStatusElement() { 
1159      return this.status != null && !this.status.isEmpty();
1160    }
1161
1162    public boolean hasStatus() { 
1163      return this.status != null && !this.status.isEmpty();
1164    }
1165
1166    /**
1167     * @param value {@link #status} (The status of this search parameter. Enables tracking the life-cycle of the content.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value
1168     */
1169    public SearchParameter setStatusElement(Enumeration<PublicationStatus> value) { 
1170      this.status = value;
1171      return this;
1172    }
1173
1174    /**
1175     * @return The status of this search parameter. Enables tracking the life-cycle of the content.
1176     */
1177    public PublicationStatus getStatus() { 
1178      return this.status == null ? null : this.status.getValue();
1179    }
1180
1181    /**
1182     * @param value The status of this search parameter. Enables tracking the life-cycle of the content.
1183     */
1184    public SearchParameter setStatus(PublicationStatus value) { 
1185        if (this.status == null)
1186          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory());
1187        this.status.setValue(value);
1188      return this;
1189    }
1190
1191    /**
1192     * @return {@link #experimental} (A boolean value to indicate that this search parameter is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.). This is the underlying object with id, value and extensions. The accessor "getExperimental" gives direct access to the value
1193     */
1194    public BooleanType getExperimentalElement() { 
1195      if (this.experimental == null)
1196        if (Configuration.errorOnAutoCreate())
1197          throw new Error("Attempt to auto-create SearchParameter.experimental");
1198        else if (Configuration.doAutoCreate())
1199          this.experimental = new BooleanType(); // bb
1200      return this.experimental;
1201    }
1202
1203    public boolean hasExperimentalElement() { 
1204      return this.experimental != null && !this.experimental.isEmpty();
1205    }
1206
1207    public boolean hasExperimental() { 
1208      return this.experimental != null && !this.experimental.isEmpty();
1209    }
1210
1211    /**
1212     * @param value {@link #experimental} (A boolean value to indicate that this search parameter is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.). This is the underlying object with id, value and extensions. The accessor "getExperimental" gives direct access to the value
1213     */
1214    public SearchParameter setExperimentalElement(BooleanType value) { 
1215      this.experimental = value;
1216      return this;
1217    }
1218
1219    /**
1220     * @return A boolean value to indicate that this search parameter is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.
1221     */
1222    public boolean getExperimental() { 
1223      return this.experimental == null || this.experimental.isEmpty() ? false : this.experimental.getValue();
1224    }
1225
1226    /**
1227     * @param value A boolean value to indicate that this search parameter is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.
1228     */
1229    public SearchParameter setExperimental(boolean value) { 
1230        if (this.experimental == null)
1231          this.experimental = new BooleanType();
1232        this.experimental.setValue(value);
1233      return this;
1234    }
1235
1236    /**
1237     * @return {@link #date} (The date  (and optionally time) when the search parameter was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the search parameter changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
1238     */
1239    public DateTimeType getDateElement() { 
1240      if (this.date == null)
1241        if (Configuration.errorOnAutoCreate())
1242          throw new Error("Attempt to auto-create SearchParameter.date");
1243        else if (Configuration.doAutoCreate())
1244          this.date = new DateTimeType(); // bb
1245      return this.date;
1246    }
1247
1248    public boolean hasDateElement() { 
1249      return this.date != null && !this.date.isEmpty();
1250    }
1251
1252    public boolean hasDate() { 
1253      return this.date != null && !this.date.isEmpty();
1254    }
1255
1256    /**
1257     * @param value {@link #date} (The date  (and optionally time) when the search parameter was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the search parameter changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
1258     */
1259    public SearchParameter setDateElement(DateTimeType value) { 
1260      this.date = value;
1261      return this;
1262    }
1263
1264    /**
1265     * @return The date  (and optionally time) when the search parameter was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the search parameter changes.
1266     */
1267    public Date getDate() { 
1268      return this.date == null ? null : this.date.getValue();
1269    }
1270
1271    /**
1272     * @param value The date  (and optionally time) when the search parameter was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the search parameter changes.
1273     */
1274    public SearchParameter setDate(Date value) { 
1275      if (value == null)
1276        this.date = null;
1277      else {
1278        if (this.date == null)
1279          this.date = new DateTimeType();
1280        this.date.setValue(value);
1281      }
1282      return this;
1283    }
1284
1285    /**
1286     * @return {@link #publisher} (The name of the individual or organization that published the search parameter.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
1287     */
1288    public StringType getPublisherElement() { 
1289      if (this.publisher == null)
1290        if (Configuration.errorOnAutoCreate())
1291          throw new Error("Attempt to auto-create SearchParameter.publisher");
1292        else if (Configuration.doAutoCreate())
1293          this.publisher = new StringType(); // bb
1294      return this.publisher;
1295    }
1296
1297    public boolean hasPublisherElement() { 
1298      return this.publisher != null && !this.publisher.isEmpty();
1299    }
1300
1301    public boolean hasPublisher() { 
1302      return this.publisher != null && !this.publisher.isEmpty();
1303    }
1304
1305    /**
1306     * @param value {@link #publisher} (The name of the individual or organization that published the search parameter.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
1307     */
1308    public SearchParameter setPublisherElement(StringType value) { 
1309      this.publisher = value;
1310      return this;
1311    }
1312
1313    /**
1314     * @return The name of the individual or organization that published the search parameter.
1315     */
1316    public String getPublisher() { 
1317      return this.publisher == null ? null : this.publisher.getValue();
1318    }
1319
1320    /**
1321     * @param value The name of the individual or organization that published the search parameter.
1322     */
1323    public SearchParameter setPublisher(String value) { 
1324      if (Utilities.noString(value))
1325        this.publisher = null;
1326      else {
1327        if (this.publisher == null)
1328          this.publisher = new StringType();
1329        this.publisher.setValue(value);
1330      }
1331      return this;
1332    }
1333
1334    /**
1335     * @return {@link #contact} (Contact details to assist a user in finding and communicating with the publisher.)
1336     */
1337    public List<ContactDetail> getContact() { 
1338      if (this.contact == null)
1339        this.contact = new ArrayList<ContactDetail>();
1340      return this.contact;
1341    }
1342
1343    /**
1344     * @return Returns a reference to <code>this</code> for easy method chaining
1345     */
1346    public SearchParameter setContact(List<ContactDetail> theContact) { 
1347      this.contact = theContact;
1348      return this;
1349    }
1350
1351    public boolean hasContact() { 
1352      if (this.contact == null)
1353        return false;
1354      for (ContactDetail item : this.contact)
1355        if (!item.isEmpty())
1356          return true;
1357      return false;
1358    }
1359
1360    public ContactDetail addContact() { //3
1361      ContactDetail t = new ContactDetail();
1362      if (this.contact == null)
1363        this.contact = new ArrayList<ContactDetail>();
1364      this.contact.add(t);
1365      return t;
1366    }
1367
1368    public SearchParameter addContact(ContactDetail t) { //3
1369      if (t == null)
1370        return this;
1371      if (this.contact == null)
1372        this.contact = new ArrayList<ContactDetail>();
1373      this.contact.add(t);
1374      return this;
1375    }
1376
1377    /**
1378     * @return The first repetition of repeating field {@link #contact}, creating it if it does not already exist
1379     */
1380    public ContactDetail getContactFirstRep() { 
1381      if (getContact().isEmpty()) {
1382        addContact();
1383      }
1384      return getContact().get(0);
1385    }
1386
1387    /**
1388     * @return {@link #useContext} (The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate search parameter instances.)
1389     */
1390    public List<UsageContext> getUseContext() { 
1391      if (this.useContext == null)
1392        this.useContext = new ArrayList<UsageContext>();
1393      return this.useContext;
1394    }
1395
1396    /**
1397     * @return Returns a reference to <code>this</code> for easy method chaining
1398     */
1399    public SearchParameter setUseContext(List<UsageContext> theUseContext) { 
1400      this.useContext = theUseContext;
1401      return this;
1402    }
1403
1404    public boolean hasUseContext() { 
1405      if (this.useContext == null)
1406        return false;
1407      for (UsageContext item : this.useContext)
1408        if (!item.isEmpty())
1409          return true;
1410      return false;
1411    }
1412
1413    public UsageContext addUseContext() { //3
1414      UsageContext t = new UsageContext();
1415      if (this.useContext == null)
1416        this.useContext = new ArrayList<UsageContext>();
1417      this.useContext.add(t);
1418      return t;
1419    }
1420
1421    public SearchParameter addUseContext(UsageContext t) { //3
1422      if (t == null)
1423        return this;
1424      if (this.useContext == null)
1425        this.useContext = new ArrayList<UsageContext>();
1426      this.useContext.add(t);
1427      return this;
1428    }
1429
1430    /**
1431     * @return The first repetition of repeating field {@link #useContext}, creating it if it does not already exist
1432     */
1433    public UsageContext getUseContextFirstRep() { 
1434      if (getUseContext().isEmpty()) {
1435        addUseContext();
1436      }
1437      return getUseContext().get(0);
1438    }
1439
1440    /**
1441     * @return {@link #jurisdiction} (A legal or geographic region in which the search parameter is intended to be used.)
1442     */
1443    public List<CodeableConcept> getJurisdiction() { 
1444      if (this.jurisdiction == null)
1445        this.jurisdiction = new ArrayList<CodeableConcept>();
1446      return this.jurisdiction;
1447    }
1448
1449    /**
1450     * @return Returns a reference to <code>this</code> for easy method chaining
1451     */
1452    public SearchParameter setJurisdiction(List<CodeableConcept> theJurisdiction) { 
1453      this.jurisdiction = theJurisdiction;
1454      return this;
1455    }
1456
1457    public boolean hasJurisdiction() { 
1458      if (this.jurisdiction == null)
1459        return false;
1460      for (CodeableConcept item : this.jurisdiction)
1461        if (!item.isEmpty())
1462          return true;
1463      return false;
1464    }
1465
1466    public CodeableConcept addJurisdiction() { //3
1467      CodeableConcept t = new CodeableConcept();
1468      if (this.jurisdiction == null)
1469        this.jurisdiction = new ArrayList<CodeableConcept>();
1470      this.jurisdiction.add(t);
1471      return t;
1472    }
1473
1474    public SearchParameter addJurisdiction(CodeableConcept t) { //3
1475      if (t == null)
1476        return this;
1477      if (this.jurisdiction == null)
1478        this.jurisdiction = new ArrayList<CodeableConcept>();
1479      this.jurisdiction.add(t);
1480      return this;
1481    }
1482
1483    /**
1484     * @return The first repetition of repeating field {@link #jurisdiction}, creating it if it does not already exist
1485     */
1486    public CodeableConcept getJurisdictionFirstRep() { 
1487      if (getJurisdiction().isEmpty()) {
1488        addJurisdiction();
1489      }
1490      return getJurisdiction().get(0);
1491    }
1492
1493    /**
1494     * @return {@link #purpose} (Explaination of why this search parameter is needed and why it has been designed as it has.). This is the underlying object with id, value and extensions. The accessor "getPurpose" gives direct access to the value
1495     */
1496    public MarkdownType getPurposeElement() { 
1497      if (this.purpose == null)
1498        if (Configuration.errorOnAutoCreate())
1499          throw new Error("Attempt to auto-create SearchParameter.purpose");
1500        else if (Configuration.doAutoCreate())
1501          this.purpose = new MarkdownType(); // bb
1502      return this.purpose;
1503    }
1504
1505    public boolean hasPurposeElement() { 
1506      return this.purpose != null && !this.purpose.isEmpty();
1507    }
1508
1509    public boolean hasPurpose() { 
1510      return this.purpose != null && !this.purpose.isEmpty();
1511    }
1512
1513    /**
1514     * @param value {@link #purpose} (Explaination of why this search parameter is needed and why it has been designed as it has.). This is the underlying object with id, value and extensions. The accessor "getPurpose" gives direct access to the value
1515     */
1516    public SearchParameter setPurposeElement(MarkdownType value) { 
1517      this.purpose = value;
1518      return this;
1519    }
1520
1521    /**
1522     * @return Explaination of why this search parameter is needed and why it has been designed as it has.
1523     */
1524    public String getPurpose() { 
1525      return this.purpose == null ? null : this.purpose.getValue();
1526    }
1527
1528    /**
1529     * @param value Explaination of why this search parameter is needed and why it has been designed as it has.
1530     */
1531    public SearchParameter setPurpose(String value) { 
1532      if (value == null)
1533        this.purpose = null;
1534      else {
1535        if (this.purpose == null)
1536          this.purpose = new MarkdownType();
1537        this.purpose.setValue(value);
1538      }
1539      return this;
1540    }
1541
1542    /**
1543     * @return {@link #code} (The code used in the URL or the parameter name in a parameters resource for this search parameter.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value
1544     */
1545    public CodeType getCodeElement() { 
1546      if (this.code == null)
1547        if (Configuration.errorOnAutoCreate())
1548          throw new Error("Attempt to auto-create SearchParameter.code");
1549        else if (Configuration.doAutoCreate())
1550          this.code = new CodeType(); // bb
1551      return this.code;
1552    }
1553
1554    public boolean hasCodeElement() { 
1555      return this.code != null && !this.code.isEmpty();
1556    }
1557
1558    public boolean hasCode() { 
1559      return this.code != null && !this.code.isEmpty();
1560    }
1561
1562    /**
1563     * @param value {@link #code} (The code used in the URL or the parameter name in a parameters resource for this search parameter.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value
1564     */
1565    public SearchParameter setCodeElement(CodeType value) { 
1566      this.code = value;
1567      return this;
1568    }
1569
1570    /**
1571     * @return The code used in the URL or the parameter name in a parameters resource for this search parameter.
1572     */
1573    public String getCode() { 
1574      return this.code == null ? null : this.code.getValue();
1575    }
1576
1577    /**
1578     * @param value The code used in the URL or the parameter name in a parameters resource for this search parameter.
1579     */
1580    public SearchParameter setCode(String value) { 
1581        if (this.code == null)
1582          this.code = new CodeType();
1583        this.code.setValue(value);
1584      return this;
1585    }
1586
1587    /**
1588     * @return {@link #base} (The base resource type(s) that this search parameter can be used against.)
1589     */
1590    public List<CodeType> getBase() { 
1591      if (this.base == null)
1592        this.base = new ArrayList<CodeType>();
1593      return this.base;
1594    }
1595
1596    /**
1597     * @return Returns a reference to <code>this</code> for easy method chaining
1598     */
1599    public SearchParameter setBase(List<CodeType> theBase) { 
1600      this.base = theBase;
1601      return this;
1602    }
1603
1604    public boolean hasBase() { 
1605      if (this.base == null)
1606        return false;
1607      for (CodeType item : this.base)
1608        if (!item.isEmpty())
1609          return true;
1610      return false;
1611    }
1612
1613    /**
1614     * @return {@link #base} (The base resource type(s) that this search parameter can be used against.)
1615     */
1616    public CodeType addBaseElement() {//2 
1617      CodeType t = new CodeType();
1618      if (this.base == null)
1619        this.base = new ArrayList<CodeType>();
1620      this.base.add(t);
1621      return t;
1622    }
1623
1624    /**
1625     * @param value {@link #base} (The base resource type(s) that this search parameter can be used against.)
1626     */
1627    public SearchParameter addBase(String value) { //1
1628      CodeType t = new CodeType();
1629      t.setValue(value);
1630      if (this.base == null)
1631        this.base = new ArrayList<CodeType>();
1632      this.base.add(t);
1633      return this;
1634    }
1635
1636    /**
1637     * @param value {@link #base} (The base resource type(s) that this search parameter can be used against.)
1638     */
1639    public boolean hasBase(String value) { 
1640      if (this.base == null)
1641        return false;
1642      for (CodeType v : this.base)
1643        if (v.getValue().equals(value)) // code
1644          return true;
1645      return false;
1646    }
1647
1648    /**
1649     * @return {@link #type} (The type of value a search parameter refers to, and how the content is interpreted.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
1650     */
1651    public Enumeration<SearchParamType> getTypeElement() { 
1652      if (this.type == null)
1653        if (Configuration.errorOnAutoCreate())
1654          throw new Error("Attempt to auto-create SearchParameter.type");
1655        else if (Configuration.doAutoCreate())
1656          this.type = new Enumeration<SearchParamType>(new SearchParamTypeEnumFactory()); // bb
1657      return this.type;
1658    }
1659
1660    public boolean hasTypeElement() { 
1661      return this.type != null && !this.type.isEmpty();
1662    }
1663
1664    public boolean hasType() { 
1665      return this.type != null && !this.type.isEmpty();
1666    }
1667
1668    /**
1669     * @param value {@link #type} (The type of value a search parameter refers to, and how the content is interpreted.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
1670     */
1671    public SearchParameter setTypeElement(Enumeration<SearchParamType> value) { 
1672      this.type = value;
1673      return this;
1674    }
1675
1676    /**
1677     * @return The type of value a search parameter refers to, and how the content is interpreted.
1678     */
1679    public SearchParamType getType() { 
1680      return this.type == null ? null : this.type.getValue();
1681    }
1682
1683    /**
1684     * @param value The type of value a search parameter refers to, and how the content is interpreted.
1685     */
1686    public SearchParameter setType(SearchParamType value) { 
1687        if (this.type == null)
1688          this.type = new Enumeration<SearchParamType>(new SearchParamTypeEnumFactory());
1689        this.type.setValue(value);
1690      return this;
1691    }
1692
1693    /**
1694     * @return {@link #derivedFrom} (Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter.). This is the underlying object with id, value and extensions. The accessor "getDerivedFrom" gives direct access to the value
1695     */
1696    public UriType getDerivedFromElement() { 
1697      if (this.derivedFrom == null)
1698        if (Configuration.errorOnAutoCreate())
1699          throw new Error("Attempt to auto-create SearchParameter.derivedFrom");
1700        else if (Configuration.doAutoCreate())
1701          this.derivedFrom = new UriType(); // bb
1702      return this.derivedFrom;
1703    }
1704
1705    public boolean hasDerivedFromElement() { 
1706      return this.derivedFrom != null && !this.derivedFrom.isEmpty();
1707    }
1708
1709    public boolean hasDerivedFrom() { 
1710      return this.derivedFrom != null && !this.derivedFrom.isEmpty();
1711    }
1712
1713    /**
1714     * @param value {@link #derivedFrom} (Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter.). This is the underlying object with id, value and extensions. The accessor "getDerivedFrom" gives direct access to the value
1715     */
1716    public SearchParameter setDerivedFromElement(UriType value) { 
1717      this.derivedFrom = value;
1718      return this;
1719    }
1720
1721    /**
1722     * @return Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter.
1723     */
1724    public String getDerivedFrom() { 
1725      return this.derivedFrom == null ? null : this.derivedFrom.getValue();
1726    }
1727
1728    /**
1729     * @param value Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter.
1730     */
1731    public SearchParameter setDerivedFrom(String value) { 
1732      if (Utilities.noString(value))
1733        this.derivedFrom = null;
1734      else {
1735        if (this.derivedFrom == null)
1736          this.derivedFrom = new UriType();
1737        this.derivedFrom.setValue(value);
1738      }
1739      return this;
1740    }
1741
1742    /**
1743     * @return {@link #description} (A free text natural language description of the search parameter from a consumer's perspective. and how it used.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
1744     */
1745    public MarkdownType getDescriptionElement() { 
1746      if (this.description == null)
1747        if (Configuration.errorOnAutoCreate())
1748          throw new Error("Attempt to auto-create SearchParameter.description");
1749        else if (Configuration.doAutoCreate())
1750          this.description = new MarkdownType(); // bb
1751      return this.description;
1752    }
1753
1754    public boolean hasDescriptionElement() { 
1755      return this.description != null && !this.description.isEmpty();
1756    }
1757
1758    public boolean hasDescription() { 
1759      return this.description != null && !this.description.isEmpty();
1760    }
1761
1762    /**
1763     * @param value {@link #description} (A free text natural language description of the search parameter from a consumer's perspective. and how it used.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
1764     */
1765    public SearchParameter setDescriptionElement(MarkdownType value) { 
1766      this.description = value;
1767      return this;
1768    }
1769
1770    /**
1771     * @return A free text natural language description of the search parameter from a consumer's perspective. and how it used.
1772     */
1773    public String getDescription() { 
1774      return this.description == null ? null : this.description.getValue();
1775    }
1776
1777    /**
1778     * @param value A free text natural language description of the search parameter from a consumer's perspective. and how it used.
1779     */
1780    public SearchParameter setDescription(String value) { 
1781        if (this.description == null)
1782          this.description = new MarkdownType();
1783        this.description.setValue(value);
1784      return this;
1785    }
1786
1787    /**
1788     * @return {@link #expression} (A FHIRPath expression that returns a set of elements for the search parameter.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value
1789     */
1790    public StringType getExpressionElement() { 
1791      if (this.expression == null)
1792        if (Configuration.errorOnAutoCreate())
1793          throw new Error("Attempt to auto-create SearchParameter.expression");
1794        else if (Configuration.doAutoCreate())
1795          this.expression = new StringType(); // bb
1796      return this.expression;
1797    }
1798
1799    public boolean hasExpressionElement() { 
1800      return this.expression != null && !this.expression.isEmpty();
1801    }
1802
1803    public boolean hasExpression() { 
1804      return this.expression != null && !this.expression.isEmpty();
1805    }
1806
1807    /**
1808     * @param value {@link #expression} (A FHIRPath expression that returns a set of elements for the search parameter.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value
1809     */
1810    public SearchParameter setExpressionElement(StringType value) { 
1811      this.expression = value;
1812      return this;
1813    }
1814
1815    /**
1816     * @return A FHIRPath expression that returns a set of elements for the search parameter.
1817     */
1818    public String getExpression() { 
1819      return this.expression == null ? null : this.expression.getValue();
1820    }
1821
1822    /**
1823     * @param value A FHIRPath expression that returns a set of elements for the search parameter.
1824     */
1825    public SearchParameter setExpression(String value) { 
1826      if (Utilities.noString(value))
1827        this.expression = null;
1828      else {
1829        if (this.expression == null)
1830          this.expression = new StringType();
1831        this.expression.setValue(value);
1832      }
1833      return this;
1834    }
1835
1836    /**
1837     * @return {@link #xpath} (An XPath expression that returns a set of elements for the search parameter.). This is the underlying object with id, value and extensions. The accessor "getXpath" gives direct access to the value
1838     */
1839    public StringType getXpathElement() { 
1840      if (this.xpath == null)
1841        if (Configuration.errorOnAutoCreate())
1842          throw new Error("Attempt to auto-create SearchParameter.xpath");
1843        else if (Configuration.doAutoCreate())
1844          this.xpath = new StringType(); // bb
1845      return this.xpath;
1846    }
1847
1848    public boolean hasXpathElement() { 
1849      return this.xpath != null && !this.xpath.isEmpty();
1850    }
1851
1852    public boolean hasXpath() { 
1853      return this.xpath != null && !this.xpath.isEmpty();
1854    }
1855
1856    /**
1857     * @param value {@link #xpath} (An XPath expression that returns a set of elements for the search parameter.). This is the underlying object with id, value and extensions. The accessor "getXpath" gives direct access to the value
1858     */
1859    public SearchParameter setXpathElement(StringType value) { 
1860      this.xpath = value;
1861      return this;
1862    }
1863
1864    /**
1865     * @return An XPath expression that returns a set of elements for the search parameter.
1866     */
1867    public String getXpath() { 
1868      return this.xpath == null ? null : this.xpath.getValue();
1869    }
1870
1871    /**
1872     * @param value An XPath expression that returns a set of elements for the search parameter.
1873     */
1874    public SearchParameter setXpath(String value) { 
1875      if (Utilities.noString(value))
1876        this.xpath = null;
1877      else {
1878        if (this.xpath == null)
1879          this.xpath = new StringType();
1880        this.xpath.setValue(value);
1881      }
1882      return this;
1883    }
1884
1885    /**
1886     * @return {@link #xpathUsage} (How the search parameter relates to the set of elements returned by evaluating the xpath query.). This is the underlying object with id, value and extensions. The accessor "getXpathUsage" gives direct access to the value
1887     */
1888    public Enumeration<XPathUsageType> getXpathUsageElement() { 
1889      if (this.xpathUsage == null)
1890        if (Configuration.errorOnAutoCreate())
1891          throw new Error("Attempt to auto-create SearchParameter.xpathUsage");
1892        else if (Configuration.doAutoCreate())
1893          this.xpathUsage = new Enumeration<XPathUsageType>(new XPathUsageTypeEnumFactory()); // bb
1894      return this.xpathUsage;
1895    }
1896
1897    public boolean hasXpathUsageElement() { 
1898      return this.xpathUsage != null && !this.xpathUsage.isEmpty();
1899    }
1900
1901    public boolean hasXpathUsage() { 
1902      return this.xpathUsage != null && !this.xpathUsage.isEmpty();
1903    }
1904
1905    /**
1906     * @param value {@link #xpathUsage} (How the search parameter relates to the set of elements returned by evaluating the xpath query.). This is the underlying object with id, value and extensions. The accessor "getXpathUsage" gives direct access to the value
1907     */
1908    public SearchParameter setXpathUsageElement(Enumeration<XPathUsageType> value) { 
1909      this.xpathUsage = value;
1910      return this;
1911    }
1912
1913    /**
1914     * @return How the search parameter relates to the set of elements returned by evaluating the xpath query.
1915     */
1916    public XPathUsageType getXpathUsage() { 
1917      return this.xpathUsage == null ? null : this.xpathUsage.getValue();
1918    }
1919
1920    /**
1921     * @param value How the search parameter relates to the set of elements returned by evaluating the xpath query.
1922     */
1923    public SearchParameter setXpathUsage(XPathUsageType value) { 
1924      if (value == null)
1925        this.xpathUsage = null;
1926      else {
1927        if (this.xpathUsage == null)
1928          this.xpathUsage = new Enumeration<XPathUsageType>(new XPathUsageTypeEnumFactory());
1929        this.xpathUsage.setValue(value);
1930      }
1931      return this;
1932    }
1933
1934    /**
1935     * @return {@link #target} (Types of resource (if a resource is referenced).)
1936     */
1937    public List<CodeType> getTarget() { 
1938      if (this.target == null)
1939        this.target = new ArrayList<CodeType>();
1940      return this.target;
1941    }
1942
1943    /**
1944     * @return Returns a reference to <code>this</code> for easy method chaining
1945     */
1946    public SearchParameter setTarget(List<CodeType> theTarget) { 
1947      this.target = theTarget;
1948      return this;
1949    }
1950
1951    public boolean hasTarget() { 
1952      if (this.target == null)
1953        return false;
1954      for (CodeType item : this.target)
1955        if (!item.isEmpty())
1956          return true;
1957      return false;
1958    }
1959
1960    /**
1961     * @return {@link #target} (Types of resource (if a resource is referenced).)
1962     */
1963    public CodeType addTargetElement() {//2 
1964      CodeType t = new CodeType();
1965      if (this.target == null)
1966        this.target = new ArrayList<CodeType>();
1967      this.target.add(t);
1968      return t;
1969    }
1970
1971    /**
1972     * @param value {@link #target} (Types of resource (if a resource is referenced).)
1973     */
1974    public SearchParameter addTarget(String value) { //1
1975      CodeType t = new CodeType();
1976      t.setValue(value);
1977      if (this.target == null)
1978        this.target = new ArrayList<CodeType>();
1979      this.target.add(t);
1980      return this;
1981    }
1982
1983    /**
1984     * @param value {@link #target} (Types of resource (if a resource is referenced).)
1985     */
1986    public boolean hasTarget(String value) { 
1987      if (this.target == null)
1988        return false;
1989      for (CodeType v : this.target)
1990        if (v.getValue().equals(value)) // code
1991          return true;
1992      return false;
1993    }
1994
1995    /**
1996     * @return {@link #comparator} (Comparators supported for the search parameter.)
1997     */
1998    public List<Enumeration<SearchComparator>> getComparator() { 
1999      if (this.comparator == null)
2000        this.comparator = new ArrayList<Enumeration<SearchComparator>>();
2001      return this.comparator;
2002    }
2003
2004    /**
2005     * @return Returns a reference to <code>this</code> for easy method chaining
2006     */
2007    public SearchParameter setComparator(List<Enumeration<SearchComparator>> theComparator) { 
2008      this.comparator = theComparator;
2009      return this;
2010    }
2011
2012    public boolean hasComparator() { 
2013      if (this.comparator == null)
2014        return false;
2015      for (Enumeration<SearchComparator> item : this.comparator)
2016        if (!item.isEmpty())
2017          return true;
2018      return false;
2019    }
2020
2021    /**
2022     * @return {@link #comparator} (Comparators supported for the search parameter.)
2023     */
2024    public Enumeration<SearchComparator> addComparatorElement() {//2 
2025      Enumeration<SearchComparator> t = new Enumeration<SearchComparator>(new SearchComparatorEnumFactory());
2026      if (this.comparator == null)
2027        this.comparator = new ArrayList<Enumeration<SearchComparator>>();
2028      this.comparator.add(t);
2029      return t;
2030    }
2031
2032    /**
2033     * @param value {@link #comparator} (Comparators supported for the search parameter.)
2034     */
2035    public SearchParameter addComparator(SearchComparator value) { //1
2036      Enumeration<SearchComparator> t = new Enumeration<SearchComparator>(new SearchComparatorEnumFactory());
2037      t.setValue(value);
2038      if (this.comparator == null)
2039        this.comparator = new ArrayList<Enumeration<SearchComparator>>();
2040      this.comparator.add(t);
2041      return this;
2042    }
2043
2044    /**
2045     * @param value {@link #comparator} (Comparators supported for the search parameter.)
2046     */
2047    public boolean hasComparator(SearchComparator value) { 
2048      if (this.comparator == null)
2049        return false;
2050      for (Enumeration<SearchComparator> v : this.comparator)
2051        if (v.getValue().equals(value)) // code
2052          return true;
2053      return false;
2054    }
2055
2056    /**
2057     * @return {@link #modifier} (A modifier supported for the search parameter.)
2058     */
2059    public List<Enumeration<SearchModifierCode>> getModifier() { 
2060      if (this.modifier == null)
2061        this.modifier = new ArrayList<Enumeration<SearchModifierCode>>();
2062      return this.modifier;
2063    }
2064
2065    /**
2066     * @return Returns a reference to <code>this</code> for easy method chaining
2067     */
2068    public SearchParameter setModifier(List<Enumeration<SearchModifierCode>> theModifier) { 
2069      this.modifier = theModifier;
2070      return this;
2071    }
2072
2073    public boolean hasModifier() { 
2074      if (this.modifier == null)
2075        return false;
2076      for (Enumeration<SearchModifierCode> item : this.modifier)
2077        if (!item.isEmpty())
2078          return true;
2079      return false;
2080    }
2081
2082    /**
2083     * @return {@link #modifier} (A modifier supported for the search parameter.)
2084     */
2085    public Enumeration<SearchModifierCode> addModifierElement() {//2 
2086      Enumeration<SearchModifierCode> t = new Enumeration<SearchModifierCode>(new SearchModifierCodeEnumFactory());
2087      if (this.modifier == null)
2088        this.modifier = new ArrayList<Enumeration<SearchModifierCode>>();
2089      this.modifier.add(t);
2090      return t;
2091    }
2092
2093    /**
2094     * @param value {@link #modifier} (A modifier supported for the search parameter.)
2095     */
2096    public SearchParameter addModifier(SearchModifierCode value) { //1
2097      Enumeration<SearchModifierCode> t = new Enumeration<SearchModifierCode>(new SearchModifierCodeEnumFactory());
2098      t.setValue(value);
2099      if (this.modifier == null)
2100        this.modifier = new ArrayList<Enumeration<SearchModifierCode>>();
2101      this.modifier.add(t);
2102      return this;
2103    }
2104
2105    /**
2106     * @param value {@link #modifier} (A modifier supported for the search parameter.)
2107     */
2108    public boolean hasModifier(SearchModifierCode value) { 
2109      if (this.modifier == null)
2110        return false;
2111      for (Enumeration<SearchModifierCode> v : this.modifier)
2112        if (v.getValue().equals(value)) // code
2113          return true;
2114      return false;
2115    }
2116
2117    /**
2118     * @return {@link #chain} (Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.)
2119     */
2120    public List<StringType> getChain() { 
2121      if (this.chain == null)
2122        this.chain = new ArrayList<StringType>();
2123      return this.chain;
2124    }
2125
2126    /**
2127     * @return Returns a reference to <code>this</code> for easy method chaining
2128     */
2129    public SearchParameter setChain(List<StringType> theChain) { 
2130      this.chain = theChain;
2131      return this;
2132    }
2133
2134    public boolean hasChain() { 
2135      if (this.chain == null)
2136        return false;
2137      for (StringType item : this.chain)
2138        if (!item.isEmpty())
2139          return true;
2140      return false;
2141    }
2142
2143    /**
2144     * @return {@link #chain} (Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.)
2145     */
2146    public StringType addChainElement() {//2 
2147      StringType t = new StringType();
2148      if (this.chain == null)
2149        this.chain = new ArrayList<StringType>();
2150      this.chain.add(t);
2151      return t;
2152    }
2153
2154    /**
2155     * @param value {@link #chain} (Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.)
2156     */
2157    public SearchParameter addChain(String value) { //1
2158      StringType t = new StringType();
2159      t.setValue(value);
2160      if (this.chain == null)
2161        this.chain = new ArrayList<StringType>();
2162      this.chain.add(t);
2163      return this;
2164    }
2165
2166    /**
2167     * @param value {@link #chain} (Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.)
2168     */
2169    public boolean hasChain(String value) { 
2170      if (this.chain == null)
2171        return false;
2172      for (StringType v : this.chain)
2173        if (v.getValue().equals(value)) // string
2174          return true;
2175      return false;
2176    }
2177
2178    /**
2179     * @return {@link #component} (Used to define the parts of a composite search parameter.)
2180     */
2181    public List<SearchParameterComponentComponent> getComponent() { 
2182      if (this.component == null)
2183        this.component = new ArrayList<SearchParameterComponentComponent>();
2184      return this.component;
2185    }
2186
2187    /**
2188     * @return Returns a reference to <code>this</code> for easy method chaining
2189     */
2190    public SearchParameter setComponent(List<SearchParameterComponentComponent> theComponent) { 
2191      this.component = theComponent;
2192      return this;
2193    }
2194
2195    public boolean hasComponent() { 
2196      if (this.component == null)
2197        return false;
2198      for (SearchParameterComponentComponent item : this.component)
2199        if (!item.isEmpty())
2200          return true;
2201      return false;
2202    }
2203
2204    public SearchParameterComponentComponent addComponent() { //3
2205      SearchParameterComponentComponent t = new SearchParameterComponentComponent();
2206      if (this.component == null)
2207        this.component = new ArrayList<SearchParameterComponentComponent>();
2208      this.component.add(t);
2209      return t;
2210    }
2211
2212    public SearchParameter addComponent(SearchParameterComponentComponent t) { //3
2213      if (t == null)
2214        return this;
2215      if (this.component == null)
2216        this.component = new ArrayList<SearchParameterComponentComponent>();
2217      this.component.add(t);
2218      return this;
2219    }
2220
2221    /**
2222     * @return The first repetition of repeating field {@link #component}, creating it if it does not already exist
2223     */
2224    public SearchParameterComponentComponent getComponentFirstRep() { 
2225      if (getComponent().isEmpty()) {
2226        addComponent();
2227      }
2228      return getComponent().get(0);
2229    }
2230
2231      protected void listChildren(List<Property> children) {
2232        super.listChildren(children);
2233        children.add(new Property("url", "uri", "An absolute URI that is used to identify this search parameter when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this search parameter is (or will be) published. The URL SHOULD include the major version of the search parameter. For more information see [Technical and Business Versions](resource.html#versions).", 0, 1, url));
2234        children.add(new Property("version", "string", "The identifier that is used to identify this version of the search parameter when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the search parameter author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.", 0, 1, version));
2235        children.add(new Property("name", "string", "A natural language name identifying the search parameter. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name));
2236        children.add(new Property("status", "code", "The status of this search parameter. Enables tracking the life-cycle of the content.", 0, 1, status));
2237        children.add(new Property("experimental", "boolean", "A boolean value to indicate that this search parameter is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.", 0, 1, experimental));
2238        children.add(new Property("date", "dateTime", "The date  (and optionally time) when the search parameter was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the search parameter changes.", 0, 1, date));
2239        children.add(new Property("publisher", "string", "The name of the individual or organization that published the search parameter.", 0, 1, publisher));
2240        children.add(new Property("contact", "ContactDetail", "Contact details to assist a user in finding and communicating with the publisher.", 0, java.lang.Integer.MAX_VALUE, contact));
2241        children.add(new Property("useContext", "UsageContext", "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate search parameter instances.", 0, java.lang.Integer.MAX_VALUE, useContext));
2242        children.add(new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the search parameter is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction));
2243        children.add(new Property("purpose", "markdown", "Explaination of why this search parameter is needed and why it has been designed as it has.", 0, 1, purpose));
2244        children.add(new Property("code", "code", "The code used in the URL or the parameter name in a parameters resource for this search parameter.", 0, 1, code));
2245        children.add(new Property("base", "code", "The base resource type(s) that this search parameter can be used against.", 0, java.lang.Integer.MAX_VALUE, base));
2246        children.add(new Property("type", "code", "The type of value a search parameter refers to, and how the content is interpreted.", 0, 1, type));
2247        children.add(new Property("derivedFrom", "uri", "Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter.", 0, 1, derivedFrom));
2248        children.add(new Property("description", "markdown", "A free text natural language description of the search parameter from a consumer's perspective. and how it used.", 0, 1, description));
2249        children.add(new Property("expression", "string", "A FHIRPath expression that returns a set of elements for the search parameter.", 0, 1, expression));
2250        children.add(new Property("xpath", "string", "An XPath expression that returns a set of elements for the search parameter.", 0, 1, xpath));
2251        children.add(new Property("xpathUsage", "code", "How the search parameter relates to the set of elements returned by evaluating the xpath query.", 0, 1, xpathUsage));
2252        children.add(new Property("target", "code", "Types of resource (if a resource is referenced).", 0, java.lang.Integer.MAX_VALUE, target));
2253        children.add(new Property("comparator", "code", "Comparators supported for the search parameter.", 0, java.lang.Integer.MAX_VALUE, comparator));
2254        children.add(new Property("modifier", "code", "A modifier supported for the search parameter.", 0, java.lang.Integer.MAX_VALUE, modifier));
2255        children.add(new Property("chain", "string", "Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.", 0, java.lang.Integer.MAX_VALUE, chain));
2256        children.add(new Property("component", "", "Used to define the parts of a composite search parameter.", 0, java.lang.Integer.MAX_VALUE, component));
2257      }
2258
2259      @Override
2260      public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2261        switch (_hash) {
2262        case 116079: /*url*/  return new Property("url", "uri", "An absolute URI that is used to identify this search parameter when it is referenced in a specification, model, design or an instance. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this search parameter is (or will be) published. The URL SHOULD include the major version of the search parameter. For more information see [Technical and Business Versions](resource.html#versions).", 0, 1, url);
2263        case 351608024: /*version*/  return new Property("version", "string", "The identifier that is used to identify this version of the search parameter when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the search parameter author and is not expected to be globally unique. For example, it might be a timestamp (e.g. yyyymmdd) if a managed version is not available. There is also no expectation that versions can be placed in a lexicographical sequence.", 0, 1, version);
2264        case 3373707: /*name*/  return new Property("name", "string", "A natural language name identifying the search parameter. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name);
2265        case -892481550: /*status*/  return new Property("status", "code", "The status of this search parameter. Enables tracking the life-cycle of the content.", 0, 1, status);
2266        case -404562712: /*experimental*/  return new Property("experimental", "boolean", "A boolean value to indicate that this search parameter is authored for testing purposes (or education/evaluation/marketing), and is not intended to be used for genuine usage.", 0, 1, experimental);
2267        case 3076014: /*date*/  return new Property("date", "dateTime", "The date  (and optionally time) when the search parameter was published. The date must change if and when the business version changes and it must change if the status code changes. In addition, it should change when the substantive content of the search parameter changes.", 0, 1, date);
2268        case 1447404028: /*publisher*/  return new Property("publisher", "string", "The name of the individual or organization that published the search parameter.", 0, 1, publisher);
2269        case 951526432: /*contact*/  return new Property("contact", "ContactDetail", "Contact details to assist a user in finding and communicating with the publisher.", 0, java.lang.Integer.MAX_VALUE, contact);
2270        case -669707736: /*useContext*/  return new Property("useContext", "UsageContext", "The content was developed with a focus and intent of supporting the contexts that are listed. These terms may be used to assist with indexing and searching for appropriate search parameter instances.", 0, java.lang.Integer.MAX_VALUE, useContext);
2271        case -507075711: /*jurisdiction*/  return new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the search parameter is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction);
2272        case -220463842: /*purpose*/  return new Property("purpose", "markdown", "Explaination of why this search parameter is needed and why it has been designed as it has.", 0, 1, purpose);
2273        case 3059181: /*code*/  return new Property("code", "code", "The code used in the URL or the parameter name in a parameters resource for this search parameter.", 0, 1, code);
2274        case 3016401: /*base*/  return new Property("base", "code", "The base resource type(s) that this search parameter can be used against.", 0, java.lang.Integer.MAX_VALUE, base);
2275        case 3575610: /*type*/  return new Property("type", "code", "The type of value a search parameter refers to, and how the content is interpreted.", 0, 1, type);
2276        case 1077922663: /*derivedFrom*/  return new Property("derivedFrom", "uri", "Where this search parameter is originally defined. If a derivedFrom is provided, then the details in the search parameter must be consistent with the definition from which it is defined. I.e. the parameter should have the same meaning, and (usually) the functionality should be a proper subset of the underlying search parameter.", 0, 1, derivedFrom);
2277        case -1724546052: /*description*/  return new Property("description", "markdown", "A free text natural language description of the search parameter from a consumer's perspective. and how it used.", 0, 1, description);
2278        case -1795452264: /*expression*/  return new Property("expression", "string", "A FHIRPath expression that returns a set of elements for the search parameter.", 0, 1, expression);
2279        case 114256029: /*xpath*/  return new Property("xpath", "string", "An XPath expression that returns a set of elements for the search parameter.", 0, 1, xpath);
2280        case 1801322244: /*xpathUsage*/  return new Property("xpathUsage", "code", "How the search parameter relates to the set of elements returned by evaluating the xpath query.", 0, 1, xpathUsage);
2281        case -880905839: /*target*/  return new Property("target", "code", "Types of resource (if a resource is referenced).", 0, java.lang.Integer.MAX_VALUE, target);
2282        case -844673834: /*comparator*/  return new Property("comparator", "code", "Comparators supported for the search parameter.", 0, java.lang.Integer.MAX_VALUE, comparator);
2283        case -615513385: /*modifier*/  return new Property("modifier", "code", "A modifier supported for the search parameter.", 0, java.lang.Integer.MAX_VALUE, modifier);
2284        case 94623425: /*chain*/  return new Property("chain", "string", "Contains the names of any search parameters which may be chained to the containing search parameter. Chained parameters may be added to search parameters of type reference, and specify that resources will only be returned if they contain a reference to a resource which matches the chained parameter value. Values for this field should be drawn from SearchParameter.code for a parameter on the target resource type.", 0, java.lang.Integer.MAX_VALUE, chain);
2285        case -1399907075: /*component*/  return new Property("component", "", "Used to define the parts of a composite search parameter.", 0, java.lang.Integer.MAX_VALUE, component);
2286        default: return super.getNamedProperty(_hash, _name, _checkValid);
2287        }
2288
2289      }
2290
2291      @Override
2292      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2293        switch (hash) {
2294        case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType
2295        case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType
2296        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
2297        case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<PublicationStatus>
2298        case -404562712: /*experimental*/ return this.experimental == null ? new Base[0] : new Base[] {this.experimental}; // BooleanType
2299        case 3076014: /*date*/ return this.date == null ? new Base[0] : new Base[] {this.date}; // DateTimeType
2300        case 1447404028: /*publisher*/ return this.publisher == null ? new Base[0] : new Base[] {this.publisher}; // StringType
2301        case 951526432: /*contact*/ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail
2302        case -669707736: /*useContext*/ return this.useContext == null ? new Base[0] : this.useContext.toArray(new Base[this.useContext.size()]); // UsageContext
2303        case -507075711: /*jurisdiction*/ return this.jurisdiction == null ? new Base[0] : this.jurisdiction.toArray(new Base[this.jurisdiction.size()]); // CodeableConcept
2304        case -220463842: /*purpose*/ return this.purpose == null ? new Base[0] : new Base[] {this.purpose}; // MarkdownType
2305        case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // CodeType
2306        case 3016401: /*base*/ return this.base == null ? new Base[0] : this.base.toArray(new Base[this.base.size()]); // CodeType
2307        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration<SearchParamType>
2308        case 1077922663: /*derivedFrom*/ return this.derivedFrom == null ? new Base[0] : new Base[] {this.derivedFrom}; // UriType
2309        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType
2310        case -1795452264: /*expression*/ return this.expression == null ? new Base[0] : new Base[] {this.expression}; // StringType
2311        case 114256029: /*xpath*/ return this.xpath == null ? new Base[0] : new Base[] {this.xpath}; // StringType
2312        case 1801322244: /*xpathUsage*/ return this.xpathUsage == null ? new Base[0] : new Base[] {this.xpathUsage}; // Enumeration<XPathUsageType>
2313        case -880905839: /*target*/ return this.target == null ? new Base[0] : this.target.toArray(new Base[this.target.size()]); // CodeType
2314        case -844673834: /*comparator*/ return this.comparator == null ? new Base[0] : this.comparator.toArray(new Base[this.comparator.size()]); // Enumeration<SearchComparator>
2315        case -615513385: /*modifier*/ return this.modifier == null ? new Base[0] : this.modifier.toArray(new Base[this.modifier.size()]); // Enumeration<SearchModifierCode>
2316        case 94623425: /*chain*/ return this.chain == null ? new Base[0] : this.chain.toArray(new Base[this.chain.size()]); // StringType
2317        case -1399907075: /*component*/ return this.component == null ? new Base[0] : this.component.toArray(new Base[this.component.size()]); // SearchParameterComponentComponent
2318        default: return super.getProperty(hash, name, checkValid);
2319        }
2320
2321      }
2322
2323      @Override
2324      public Base setProperty(int hash, String name, Base value) throws FHIRException {
2325        switch (hash) {
2326        case 116079: // url
2327          this.url = castToUri(value); // UriType
2328          return value;
2329        case 351608024: // version
2330          this.version = castToString(value); // StringType
2331          return value;
2332        case 3373707: // name
2333          this.name = castToString(value); // StringType
2334          return value;
2335        case -892481550: // status
2336          value = new PublicationStatusEnumFactory().fromType(castToCode(value));
2337          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
2338          return value;
2339        case -404562712: // experimental
2340          this.experimental = castToBoolean(value); // BooleanType
2341          return value;
2342        case 3076014: // date
2343          this.date = castToDateTime(value); // DateTimeType
2344          return value;
2345        case 1447404028: // publisher
2346          this.publisher = castToString(value); // StringType
2347          return value;
2348        case 951526432: // contact
2349          this.getContact().add(castToContactDetail(value)); // ContactDetail
2350          return value;
2351        case -669707736: // useContext
2352          this.getUseContext().add(castToUsageContext(value)); // UsageContext
2353          return value;
2354        case -507075711: // jurisdiction
2355          this.getJurisdiction().add(castToCodeableConcept(value)); // CodeableConcept
2356          return value;
2357        case -220463842: // purpose
2358          this.purpose = castToMarkdown(value); // MarkdownType
2359          return value;
2360        case 3059181: // code
2361          this.code = castToCode(value); // CodeType
2362          return value;
2363        case 3016401: // base
2364          this.getBase().add(castToCode(value)); // CodeType
2365          return value;
2366        case 3575610: // type
2367          value = new SearchParamTypeEnumFactory().fromType(castToCode(value));
2368          this.type = (Enumeration) value; // Enumeration<SearchParamType>
2369          return value;
2370        case 1077922663: // derivedFrom
2371          this.derivedFrom = castToUri(value); // UriType
2372          return value;
2373        case -1724546052: // description
2374          this.description = castToMarkdown(value); // MarkdownType
2375          return value;
2376        case -1795452264: // expression
2377          this.expression = castToString(value); // StringType
2378          return value;
2379        case 114256029: // xpath
2380          this.xpath = castToString(value); // StringType
2381          return value;
2382        case 1801322244: // xpathUsage
2383          value = new XPathUsageTypeEnumFactory().fromType(castToCode(value));
2384          this.xpathUsage = (Enumeration) value; // Enumeration<XPathUsageType>
2385          return value;
2386        case -880905839: // target
2387          this.getTarget().add(castToCode(value)); // CodeType
2388          return value;
2389        case -844673834: // comparator
2390          value = new SearchComparatorEnumFactory().fromType(castToCode(value));
2391          this.getComparator().add((Enumeration) value); // Enumeration<SearchComparator>
2392          return value;
2393        case -615513385: // modifier
2394          value = new SearchModifierCodeEnumFactory().fromType(castToCode(value));
2395          this.getModifier().add((Enumeration) value); // Enumeration<SearchModifierCode>
2396          return value;
2397        case 94623425: // chain
2398          this.getChain().add(castToString(value)); // StringType
2399          return value;
2400        case -1399907075: // component
2401          this.getComponent().add((SearchParameterComponentComponent) value); // SearchParameterComponentComponent
2402          return value;
2403        default: return super.setProperty(hash, name, value);
2404        }
2405
2406      }
2407
2408      @Override
2409      public Base setProperty(String name, Base value) throws FHIRException {
2410        if (name.equals("url")) {
2411          this.url = castToUri(value); // UriType
2412        } else if (name.equals("version")) {
2413          this.version = castToString(value); // StringType
2414        } else if (name.equals("name")) {
2415          this.name = castToString(value); // StringType
2416        } else if (name.equals("status")) {
2417          value = new PublicationStatusEnumFactory().fromType(castToCode(value));
2418          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
2419        } else if (name.equals("experimental")) {
2420          this.experimental = castToBoolean(value); // BooleanType
2421        } else if (name.equals("date")) {
2422          this.date = castToDateTime(value); // DateTimeType
2423        } else if (name.equals("publisher")) {
2424          this.publisher = castToString(value); // StringType
2425        } else if (name.equals("contact")) {
2426          this.getContact().add(castToContactDetail(value));
2427        } else if (name.equals("useContext")) {
2428          this.getUseContext().add(castToUsageContext(value));
2429        } else if (name.equals("jurisdiction")) {
2430          this.getJurisdiction().add(castToCodeableConcept(value));
2431        } else if (name.equals("purpose")) {
2432          this.purpose = castToMarkdown(value); // MarkdownType
2433        } else if (name.equals("code")) {
2434          this.code = castToCode(value); // CodeType
2435        } else if (name.equals("base")) {
2436          this.getBase().add(castToCode(value));
2437        } else if (name.equals("type")) {
2438          value = new SearchParamTypeEnumFactory().fromType(castToCode(value));
2439          this.type = (Enumeration) value; // Enumeration<SearchParamType>
2440        } else if (name.equals("derivedFrom")) {
2441          this.derivedFrom = castToUri(value); // UriType
2442        } else if (name.equals("description")) {
2443          this.description = castToMarkdown(value); // MarkdownType
2444        } else if (name.equals("expression")) {
2445          this.expression = castToString(value); // StringType
2446        } else if (name.equals("xpath")) {
2447          this.xpath = castToString(value); // StringType
2448        } else if (name.equals("xpathUsage")) {
2449          value = new XPathUsageTypeEnumFactory().fromType(castToCode(value));
2450          this.xpathUsage = (Enumeration) value; // Enumeration<XPathUsageType>
2451        } else if (name.equals("target")) {
2452          this.getTarget().add(castToCode(value));
2453        } else if (name.equals("comparator")) {
2454          value = new SearchComparatorEnumFactory().fromType(castToCode(value));
2455          this.getComparator().add((Enumeration) value);
2456        } else if (name.equals("modifier")) {
2457          value = new SearchModifierCodeEnumFactory().fromType(castToCode(value));
2458          this.getModifier().add((Enumeration) value);
2459        } else if (name.equals("chain")) {
2460          this.getChain().add(castToString(value));
2461        } else if (name.equals("component")) {
2462          this.getComponent().add((SearchParameterComponentComponent) value);
2463        } else
2464          return super.setProperty(name, value);
2465        return value;
2466      }
2467
2468      @Override
2469      public Base makeProperty(int hash, String name) throws FHIRException {
2470        switch (hash) {
2471        case 116079:  return getUrlElement();
2472        case 351608024:  return getVersionElement();
2473        case 3373707:  return getNameElement();
2474        case -892481550:  return getStatusElement();
2475        case -404562712:  return getExperimentalElement();
2476        case 3076014:  return getDateElement();
2477        case 1447404028:  return getPublisherElement();
2478        case 951526432:  return addContact(); 
2479        case -669707736:  return addUseContext(); 
2480        case -507075711:  return addJurisdiction(); 
2481        case -220463842:  return getPurposeElement();
2482        case 3059181:  return getCodeElement();
2483        case 3016401:  return addBaseElement();
2484        case 3575610:  return getTypeElement();
2485        case 1077922663:  return getDerivedFromElement();
2486        case -1724546052:  return getDescriptionElement();
2487        case -1795452264:  return getExpressionElement();
2488        case 114256029:  return getXpathElement();
2489        case 1801322244:  return getXpathUsageElement();
2490        case -880905839:  return addTargetElement();
2491        case -844673834:  return addComparatorElement();
2492        case -615513385:  return addModifierElement();
2493        case 94623425:  return addChainElement();
2494        case -1399907075:  return addComponent(); 
2495        default: return super.makeProperty(hash, name);
2496        }
2497
2498      }
2499
2500      @Override
2501      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2502        switch (hash) {
2503        case 116079: /*url*/ return new String[] {"uri"};
2504        case 351608024: /*version*/ return new String[] {"string"};
2505        case 3373707: /*name*/ return new String[] {"string"};
2506        case -892481550: /*status*/ return new String[] {"code"};
2507        case -404562712: /*experimental*/ return new String[] {"boolean"};
2508        case 3076014: /*date*/ return new String[] {"dateTime"};
2509        case 1447404028: /*publisher*/ return new String[] {"string"};
2510        case 951526432: /*contact*/ return new String[] {"ContactDetail"};
2511        case -669707736: /*useContext*/ return new String[] {"UsageContext"};
2512        case -507075711: /*jurisdiction*/ return new String[] {"CodeableConcept"};
2513        case -220463842: /*purpose*/ return new String[] {"markdown"};
2514        case 3059181: /*code*/ return new String[] {"code"};
2515        case 3016401: /*base*/ return new String[] {"code"};
2516        case 3575610: /*type*/ return new String[] {"code"};
2517        case 1077922663: /*derivedFrom*/ return new String[] {"uri"};
2518        case -1724546052: /*description*/ return new String[] {"markdown"};
2519        case -1795452264: /*expression*/ return new String[] {"string"};
2520        case 114256029: /*xpath*/ return new String[] {"string"};
2521        case 1801322244: /*xpathUsage*/ return new String[] {"code"};
2522        case -880905839: /*target*/ return new String[] {"code"};
2523        case -844673834: /*comparator*/ return new String[] {"code"};
2524        case -615513385: /*modifier*/ return new String[] {"code"};
2525        case 94623425: /*chain*/ return new String[] {"string"};
2526        case -1399907075: /*component*/ return new String[] {};
2527        default: return super.getTypesForProperty(hash, name);
2528        }
2529
2530      }
2531
2532      @Override
2533      public Base addChild(String name) throws FHIRException {
2534        if (name.equals("url")) {
2535          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.url");
2536        }
2537        else if (name.equals("version")) {
2538          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.version");
2539        }
2540        else if (name.equals("name")) {
2541          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.name");
2542        }
2543        else if (name.equals("status")) {
2544          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.status");
2545        }
2546        else if (name.equals("experimental")) {
2547          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.experimental");
2548        }
2549        else if (name.equals("date")) {
2550          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.date");
2551        }
2552        else if (name.equals("publisher")) {
2553          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.publisher");
2554        }
2555        else if (name.equals("contact")) {
2556          return addContact();
2557        }
2558        else if (name.equals("useContext")) {
2559          return addUseContext();
2560        }
2561        else if (name.equals("jurisdiction")) {
2562          return addJurisdiction();
2563        }
2564        else if (name.equals("purpose")) {
2565          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.purpose");
2566        }
2567        else if (name.equals("code")) {
2568          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.code");
2569        }
2570        else if (name.equals("base")) {
2571          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.base");
2572        }
2573        else if (name.equals("type")) {
2574          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.type");
2575        }
2576        else if (name.equals("derivedFrom")) {
2577          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.derivedFrom");
2578        }
2579        else if (name.equals("description")) {
2580          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.description");
2581        }
2582        else if (name.equals("expression")) {
2583          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.expression");
2584        }
2585        else if (name.equals("xpath")) {
2586          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.xpath");
2587        }
2588        else if (name.equals("xpathUsage")) {
2589          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.xpathUsage");
2590        }
2591        else if (name.equals("target")) {
2592          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.target");
2593        }
2594        else if (name.equals("comparator")) {
2595          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.comparator");
2596        }
2597        else if (name.equals("modifier")) {
2598          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.modifier");
2599        }
2600        else if (name.equals("chain")) {
2601          throw new FHIRException("Cannot call addChild on a primitive type SearchParameter.chain");
2602        }
2603        else if (name.equals("component")) {
2604          return addComponent();
2605        }
2606        else
2607          return super.addChild(name);
2608      }
2609
2610  public String fhirType() {
2611    return "SearchParameter";
2612
2613  }
2614
2615      public SearchParameter copy() {
2616        SearchParameter dst = new SearchParameter();
2617        copyValues(dst);
2618        dst.url = url == null ? null : url.copy();
2619        dst.version = version == null ? null : version.copy();
2620        dst.name = name == null ? null : name.copy();
2621        dst.status = status == null ? null : status.copy();
2622        dst.experimental = experimental == null ? null : experimental.copy();
2623        dst.date = date == null ? null : date.copy();
2624        dst.publisher = publisher == null ? null : publisher.copy();
2625        if (contact != null) {
2626          dst.contact = new ArrayList<ContactDetail>();
2627          for (ContactDetail i : contact)
2628            dst.contact.add(i.copy());
2629        };
2630        if (useContext != null) {
2631          dst.useContext = new ArrayList<UsageContext>();
2632          for (UsageContext i : useContext)
2633            dst.useContext.add(i.copy());
2634        };
2635        if (jurisdiction != null) {
2636          dst.jurisdiction = new ArrayList<CodeableConcept>();
2637          for (CodeableConcept i : jurisdiction)
2638            dst.jurisdiction.add(i.copy());
2639        };
2640        dst.purpose = purpose == null ? null : purpose.copy();
2641        dst.code = code == null ? null : code.copy();
2642        if (base != null) {
2643          dst.base = new ArrayList<CodeType>();
2644          for (CodeType i : base)
2645            dst.base.add(i.copy());
2646        };
2647        dst.type = type == null ? null : type.copy();
2648        dst.derivedFrom = derivedFrom == null ? null : derivedFrom.copy();
2649        dst.description = description == null ? null : description.copy();
2650        dst.expression = expression == null ? null : expression.copy();
2651        dst.xpath = xpath == null ? null : xpath.copy();
2652        dst.xpathUsage = xpathUsage == null ? null : xpathUsage.copy();
2653        if (target != null) {
2654          dst.target = new ArrayList<CodeType>();
2655          for (CodeType i : target)
2656            dst.target.add(i.copy());
2657        };
2658        if (comparator != null) {
2659          dst.comparator = new ArrayList<Enumeration<SearchComparator>>();
2660          for (Enumeration<SearchComparator> i : comparator)
2661            dst.comparator.add(i.copy());
2662        };
2663        if (modifier != null) {
2664          dst.modifier = new ArrayList<Enumeration<SearchModifierCode>>();
2665          for (Enumeration<SearchModifierCode> i : modifier)
2666            dst.modifier.add(i.copy());
2667        };
2668        if (chain != null) {
2669          dst.chain = new ArrayList<StringType>();
2670          for (StringType i : chain)
2671            dst.chain.add(i.copy());
2672        };
2673        if (component != null) {
2674          dst.component = new ArrayList<SearchParameterComponentComponent>();
2675          for (SearchParameterComponentComponent i : component)
2676            dst.component.add(i.copy());
2677        };
2678        return dst;
2679      }
2680
2681      protected SearchParameter typedCopy() {
2682        return copy();
2683      }
2684
2685      @Override
2686      public boolean equalsDeep(Base other_) {
2687        if (!super.equalsDeep(other_))
2688          return false;
2689        if (!(other_ instanceof SearchParameter))
2690          return false;
2691        SearchParameter o = (SearchParameter) other_;
2692        return compareDeep(purpose, o.purpose, true) && compareDeep(code, o.code, true) && compareDeep(base, o.base, true)
2693           && compareDeep(type, o.type, true) && compareDeep(derivedFrom, o.derivedFrom, true) && compareDeep(expression, o.expression, true)
2694           && compareDeep(xpath, o.xpath, true) && compareDeep(xpathUsage, o.xpathUsage, true) && compareDeep(target, o.target, true)
2695           && compareDeep(comparator, o.comparator, true) && compareDeep(modifier, o.modifier, true) && compareDeep(chain, o.chain, true)
2696           && compareDeep(component, o.component, true);
2697      }
2698
2699      @Override
2700      public boolean equalsShallow(Base other_) {
2701        if (!super.equalsShallow(other_))
2702          return false;
2703        if (!(other_ instanceof SearchParameter))
2704          return false;
2705        SearchParameter o = (SearchParameter) other_;
2706        return compareValues(purpose, o.purpose, true) && compareValues(code, o.code, true) && compareValues(base, o.base, true)
2707           && compareValues(type, o.type, true) && compareValues(derivedFrom, o.derivedFrom, true) && compareValues(expression, o.expression, true)
2708           && compareValues(xpath, o.xpath, true) && compareValues(xpathUsage, o.xpathUsage, true) && compareValues(target, o.target, true)
2709           && compareValues(comparator, o.comparator, true) && compareValues(modifier, o.modifier, true) && compareValues(chain, o.chain, true)
2710          ;
2711      }
2712
2713      public boolean isEmpty() {
2714        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(purpose, code, base, type
2715          , derivedFrom, expression, xpath, xpathUsage, target, comparator, modifier, chain
2716          , component);
2717      }
2718
2719  @Override
2720  public ResourceType getResourceType() {
2721    return ResourceType.SearchParameter;
2722   }
2723
2724 /**
2725   * Search parameter: <b>date</b>
2726   * <p>
2727   * Description: <b>The search parameter publication date</b><br>
2728   * Type: <b>date</b><br>
2729   * Path: <b>SearchParameter.date</b><br>
2730   * </p>
2731   */
2732  @SearchParamDefinition(name="date", path="SearchParameter.date", description="The search parameter publication date", type="date" )
2733  public static final String SP_DATE = "date";
2734 /**
2735   * <b>Fluent Client</b> search parameter constant for <b>date</b>
2736   * <p>
2737   * Description: <b>The search parameter publication date</b><br>
2738   * Type: <b>date</b><br>
2739   * Path: <b>SearchParameter.date</b><br>
2740   * </p>
2741   */
2742  public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_DATE);
2743
2744 /**
2745   * Search parameter: <b>code</b>
2746   * <p>
2747   * Description: <b>Code used in URL</b><br>
2748   * Type: <b>token</b><br>
2749   * Path: <b>SearchParameter.code</b><br>
2750   * </p>
2751   */
2752  @SearchParamDefinition(name="code", path="SearchParameter.code", description="Code used in URL", type="token" )
2753  public static final String SP_CODE = "code";
2754 /**
2755   * <b>Fluent Client</b> search parameter constant for <b>code</b>
2756   * <p>
2757   * Description: <b>Code used in URL</b><br>
2758   * Type: <b>token</b><br>
2759   * Path: <b>SearchParameter.code</b><br>
2760   * </p>
2761   */
2762  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CODE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CODE);
2763
2764 /**
2765   * Search parameter: <b>jurisdiction</b>
2766   * <p>
2767   * Description: <b>Intended jurisdiction for the search parameter</b><br>
2768   * Type: <b>token</b><br>
2769   * Path: <b>SearchParameter.jurisdiction</b><br>
2770   * </p>
2771   */
2772  @SearchParamDefinition(name="jurisdiction", path="SearchParameter.jurisdiction", description="Intended jurisdiction for the search parameter", type="token" )
2773  public static final String SP_JURISDICTION = "jurisdiction";
2774 /**
2775   * <b>Fluent Client</b> search parameter constant for <b>jurisdiction</b>
2776   * <p>
2777   * Description: <b>Intended jurisdiction for the search parameter</b><br>
2778   * Type: <b>token</b><br>
2779   * Path: <b>SearchParameter.jurisdiction</b><br>
2780   * </p>
2781   */
2782  public static final ca.uhn.fhir.rest.gclient.TokenClientParam JURISDICTION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_JURISDICTION);
2783
2784 /**
2785   * Search parameter: <b>description</b>
2786   * <p>
2787   * Description: <b>The description of the search parameter</b><br>
2788   * Type: <b>string</b><br>
2789   * Path: <b>SearchParameter.description</b><br>
2790   * </p>
2791   */
2792  @SearchParamDefinition(name="description", path="SearchParameter.description", description="The description of the search parameter", type="string" )
2793  public static final String SP_DESCRIPTION = "description";
2794 /**
2795   * <b>Fluent Client</b> search parameter constant for <b>description</b>
2796   * <p>
2797   * Description: <b>The description of the search parameter</b><br>
2798   * Type: <b>string</b><br>
2799   * Path: <b>SearchParameter.description</b><br>
2800   * </p>
2801   */
2802  public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_DESCRIPTION);
2803
2804 /**
2805   * Search parameter: <b>derived-from</b>
2806   * <p>
2807   * Description: <b>Original Definition for the search parameter</b><br>
2808   * Type: <b>uri</b><br>
2809   * Path: <b>SearchParameter.derivedFrom</b><br>
2810   * </p>
2811   */
2812  @SearchParamDefinition(name="derived-from", path="SearchParameter.derivedFrom", description="Original Definition for the search parameter", type="uri" )
2813  public static final String SP_DERIVED_FROM = "derived-from";
2814 /**
2815   * <b>Fluent Client</b> search parameter constant for <b>derived-from</b>
2816   * <p>
2817   * Description: <b>Original Definition for the search parameter</b><br>
2818   * Type: <b>uri</b><br>
2819   * Path: <b>SearchParameter.derivedFrom</b><br>
2820   * </p>
2821   */
2822  public static final ca.uhn.fhir.rest.gclient.UriClientParam DERIVED_FROM = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_DERIVED_FROM);
2823
2824 /**
2825   * Search parameter: <b>type</b>
2826   * <p>
2827   * Description: <b>number | date | string | token | reference | composite | quantity | uri</b><br>
2828   * Type: <b>token</b><br>
2829   * Path: <b>SearchParameter.type</b><br>
2830   * </p>
2831   */
2832  @SearchParamDefinition(name="type", path="SearchParameter.type", description="number | date | string | token | reference | composite | quantity | uri", type="token" )
2833  public static final String SP_TYPE = "type";
2834 /**
2835   * <b>Fluent Client</b> search parameter constant for <b>type</b>
2836   * <p>
2837   * Description: <b>number | date | string | token | reference | composite | quantity | uri</b><br>
2838   * Type: <b>token</b><br>
2839   * Path: <b>SearchParameter.type</b><br>
2840   * </p>
2841   */
2842  public static final ca.uhn.fhir.rest.gclient.TokenClientParam TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_TYPE);
2843
2844 /**
2845   * Search parameter: <b>version</b>
2846   * <p>
2847   * Description: <b>The business version of the search parameter</b><br>
2848   * Type: <b>token</b><br>
2849   * Path: <b>SearchParameter.version</b><br>
2850   * </p>
2851   */
2852  @SearchParamDefinition(name="version", path="SearchParameter.version", description="The business version of the search parameter", type="token" )
2853  public static final String SP_VERSION = "version";
2854 /**
2855   * <b>Fluent Client</b> search parameter constant for <b>version</b>
2856   * <p>
2857   * Description: <b>The business version of the search parameter</b><br>
2858   * Type: <b>token</b><br>
2859   * Path: <b>SearchParameter.version</b><br>
2860   * </p>
2861   */
2862  public static final ca.uhn.fhir.rest.gclient.TokenClientParam VERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_VERSION);
2863
2864 /**
2865   * Search parameter: <b>url</b>
2866   * <p>
2867   * Description: <b>The uri that identifies the search parameter</b><br>
2868   * Type: <b>uri</b><br>
2869   * Path: <b>SearchParameter.url</b><br>
2870   * </p>
2871   */
2872  @SearchParamDefinition(name="url", path="SearchParameter.url", description="The uri that identifies the search parameter", type="uri" )
2873  public static final String SP_URL = "url";
2874 /**
2875   * <b>Fluent Client</b> search parameter constant for <b>url</b>
2876   * <p>
2877   * Description: <b>The uri that identifies the search parameter</b><br>
2878   * Type: <b>uri</b><br>
2879   * Path: <b>SearchParameter.url</b><br>
2880   * </p>
2881   */
2882  public static final ca.uhn.fhir.rest.gclient.UriClientParam URL = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_URL);
2883
2884 /**
2885   * Search parameter: <b>target</b>
2886   * <p>
2887   * Description: <b>Types of resource (if a resource reference)</b><br>
2888   * Type: <b>token</b><br>
2889   * Path: <b>SearchParameter.target</b><br>
2890   * </p>
2891   */
2892  @SearchParamDefinition(name="target", path="SearchParameter.target", description="Types of resource (if a resource reference)", type="token" )
2893  public static final String SP_TARGET = "target";
2894 /**
2895   * <b>Fluent Client</b> search parameter constant for <b>target</b>
2896   * <p>
2897   * Description: <b>Types of resource (if a resource reference)</b><br>
2898   * Type: <b>token</b><br>
2899   * Path: <b>SearchParameter.target</b><br>
2900   * </p>
2901   */
2902  public static final ca.uhn.fhir.rest.gclient.TokenClientParam TARGET = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_TARGET);
2903
2904 /**
2905   * Search parameter: <b>component</b>
2906   * <p>
2907   * Description: <b>Defines how the part works</b><br>
2908   * Type: <b>reference</b><br>
2909   * Path: <b>SearchParameter.component.definition</b><br>
2910   * </p>
2911   */
2912  @SearchParamDefinition(name="component", path="SearchParameter.component.definition", description="Defines how the part works", type="reference", target={SearchParameter.class } )
2913  public static final String SP_COMPONENT = "component";
2914 /**
2915   * <b>Fluent Client</b> search parameter constant for <b>component</b>
2916   * <p>
2917   * Description: <b>Defines how the part works</b><br>
2918   * Type: <b>reference</b><br>
2919   * Path: <b>SearchParameter.component.definition</b><br>
2920   * </p>
2921   */
2922  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam COMPONENT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_COMPONENT);
2923
2924/**
2925   * Constant for fluent queries to be used to add include statements. Specifies
2926   * the path value of "<b>SearchParameter:component</b>".
2927   */
2928  public static final ca.uhn.fhir.model.api.Include INCLUDE_COMPONENT = new ca.uhn.fhir.model.api.Include("SearchParameter:component").toLocked();
2929
2930 /**
2931   * Search parameter: <b>name</b>
2932   * <p>
2933   * Description: <b>Computationally friendly name of the search parameter</b><br>
2934   * Type: <b>string</b><br>
2935   * Path: <b>SearchParameter.name</b><br>
2936   * </p>
2937   */
2938  @SearchParamDefinition(name="name", path="SearchParameter.name", description="Computationally friendly name of the search parameter", type="string" )
2939  public static final String SP_NAME = "name";
2940 /**
2941   * <b>Fluent Client</b> search parameter constant for <b>name</b>
2942   * <p>
2943   * Description: <b>Computationally friendly name of the search parameter</b><br>
2944   * Type: <b>string</b><br>
2945   * Path: <b>SearchParameter.name</b><br>
2946   * </p>
2947   */
2948  public static final ca.uhn.fhir.rest.gclient.StringClientParam NAME = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_NAME);
2949
2950 /**
2951   * Search parameter: <b>publisher</b>
2952   * <p>
2953   * Description: <b>Name of the publisher of the search parameter</b><br>
2954   * Type: <b>string</b><br>
2955   * Path: <b>SearchParameter.publisher</b><br>
2956   * </p>
2957   */
2958  @SearchParamDefinition(name="publisher", path="SearchParameter.publisher", description="Name of the publisher of the search parameter", type="string" )
2959  public static final String SP_PUBLISHER = "publisher";
2960 /**
2961   * <b>Fluent Client</b> search parameter constant for <b>publisher</b>
2962   * <p>
2963   * Description: <b>Name of the publisher of the search parameter</b><br>
2964   * Type: <b>string</b><br>
2965   * Path: <b>SearchParameter.publisher</b><br>
2966   * </p>
2967   */
2968  public static final ca.uhn.fhir.rest.gclient.StringClientParam PUBLISHER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_PUBLISHER);
2969
2970 /**
2971   * Search parameter: <b>status</b>
2972   * <p>
2973   * Description: <b>The current status of the search parameter</b><br>
2974   * Type: <b>token</b><br>
2975   * Path: <b>SearchParameter.status</b><br>
2976   * </p>
2977   */
2978  @SearchParamDefinition(name="status", path="SearchParameter.status", description="The current status of the search parameter", type="token" )
2979  public static final String SP_STATUS = "status";
2980 /**
2981   * <b>Fluent Client</b> search parameter constant for <b>status</b>
2982   * <p>
2983   * Description: <b>The current status of the search parameter</b><br>
2984   * Type: <b>token</b><br>
2985   * Path: <b>SearchParameter.status</b><br>
2986   * </p>
2987   */
2988  public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS);
2989
2990 /**
2991   * Search parameter: <b>base</b>
2992   * <p>
2993   * Description: <b>The resource type(s) this search parameter applies to</b><br>
2994   * Type: <b>token</b><br>
2995   * Path: <b>SearchParameter.base</b><br>
2996   * </p>
2997   */
2998  @SearchParamDefinition(name="base", path="SearchParameter.base", description="The resource type(s) this search parameter applies to", type="token" )
2999  public static final String SP_BASE = "base";
3000 /**
3001   * <b>Fluent Client</b> search parameter constant for <b>base</b>
3002   * <p>
3003   * Description: <b>The resource type(s) this search parameter applies to</b><br>
3004   * Type: <b>token</b><br>
3005   * Path: <b>SearchParameter.base</b><br>
3006   * </p>
3007   */
3008  public static final ca.uhn.fhir.rest.gclient.TokenClientParam BASE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_BASE);
3009
3010
3011}