001package org.hl7.fhir.r5.model;
002
003
004/*
005  Copyright (c) 2011+, HL7, Inc.
006  All rights reserved.
007  
008  Redistribution and use in source and binary forms, with or without modification, \
009  are permitted provided that the following conditions are met:
010  
011   * Redistributions of source code must retain the above copyright notice, this \
012     list of conditions and the following disclaimer.
013   * Redistributions in binary form must reproduce the above copyright notice, \
014     this list of conditions and the following disclaimer in the documentation \
015     and/or other materials provided with the distribution.
016   * Neither the name of HL7 nor the names of its contributors may be used to 
017     endorse or promote products derived from this software without specific 
018     prior written permission.
019  
020  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND \
021  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED \
022  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \
023  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, \
024  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT \
025  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR \
026  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \
027  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) \
028  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \
029  POSSIBILITY OF SUCH DAMAGE.
030  */
031
032// Generated on Sat, Nov 5, 2022 10:47+1100 for FHIR v5.0.0-ballot
033
034import java.util.ArrayList;
035import java.util.Date;
036import java.util.List;
037import org.hl7.fhir.utilities.Utilities;
038import org.hl7.fhir.r5.model.Enumerations.*;
039import org.hl7.fhir.instance.model.api.IBaseBackboneElement;
040import org.hl7.fhir.exceptions.FHIRException;
041import org.hl7.fhir.instance.model.api.ICompositeType;
042import ca.uhn.fhir.model.api.annotation.ResourceDef;
043import ca.uhn.fhir.model.api.annotation.SearchParamDefinition;
044import org.hl7.fhir.instance.model.api.IBaseBackboneElement;
045import ca.uhn.fhir.model.api.annotation.Child;
046import ca.uhn.fhir.model.api.annotation.ChildOrder;
047import ca.uhn.fhir.model.api.annotation.Description;
048import ca.uhn.fhir.model.api.annotation.Block;
049
050/**
051 * A TerminologyCapabilities resource documents a set of capabilities (behaviors) of a FHIR Terminology Server that may be used as a statement of actual server functionality or a statement of required or desired server implementation.
052 */
053@ResourceDef(name="TerminologyCapabilities", profile="http://hl7.org/fhir/StructureDefinition/TerminologyCapabilities")
054public class TerminologyCapabilities extends CanonicalResource {
055
056    public enum CodeSearchSupport {
057        /**
058         * The search for code on ValueSet returns ValueSet resources where the code is included in the extensional definition of the ValueSet.
059         */
060        INCOMPOSE, 
061        /**
062         * The search for code on ValueSet returns ValueSet resources where the code is contained in the  ValueSet expansion.
063         */
064        INEXPANSION, 
065        /**
066         * The search for code on ValueSet returns ValueSet resources where the code is included in the extensional definition or contained in the ValueSet expansion.
067         */
068        INCOMPOSEOREXPANSION, 
069        /**
070         * added to help the parsers with the generic types
071         */
072        NULL;
073        public static CodeSearchSupport fromCode(String codeString) throws FHIRException {
074            if (codeString == null || "".equals(codeString))
075                return null;
076        if ("in-compose".equals(codeString))
077          return INCOMPOSE;
078        if ("in-expansion".equals(codeString))
079          return INEXPANSION;
080        if ("in-compose-or-expansion".equals(codeString))
081          return INCOMPOSEOREXPANSION;
082        if (Configuration.isAcceptInvalidEnums())
083          return null;
084        else
085          throw new FHIRException("Unknown CodeSearchSupport code '"+codeString+"'");
086        }
087        public String toCode() {
088          switch (this) {
089            case INCOMPOSE: return "in-compose";
090            case INEXPANSION: return "in-expansion";
091            case INCOMPOSEOREXPANSION: return "in-compose-or-expansion";
092            case NULL: return null;
093            default: return "?";
094          }
095        }
096        public String getSystem() {
097          switch (this) {
098            case INCOMPOSE: return "http://hl7.org/fhir/code-search-support";
099            case INEXPANSION: return "http://hl7.org/fhir/code-search-support";
100            case INCOMPOSEOREXPANSION: return "http://hl7.org/fhir/code-search-support";
101            case NULL: return null;
102            default: return "?";
103          }
104        }
105        public String getDefinition() {
106          switch (this) {
107            case INCOMPOSE: return "The search for code on ValueSet returns ValueSet resources where the code is included in the extensional definition of the ValueSet.";
108            case INEXPANSION: return "The search for code on ValueSet returns ValueSet resources where the code is contained in the  ValueSet expansion.";
109            case INCOMPOSEOREXPANSION: return "The search for code on ValueSet returns ValueSet resources where the code is included in the extensional definition or contained in the ValueSet expansion.";
110            case NULL: return null;
111            default: return "?";
112          }
113        }
114        public String getDisplay() {
115          switch (this) {
116            case INCOMPOSE: return "In Compose";
117            case INEXPANSION: return "In Expansion";
118            case INCOMPOSEOREXPANSION: return "In Compose Or Expansion";
119            case NULL: return null;
120            default: return "?";
121          }
122        }
123    }
124
125  public static class CodeSearchSupportEnumFactory implements EnumFactory<CodeSearchSupport> {
126    public CodeSearchSupport fromCode(String codeString) throws IllegalArgumentException {
127      if (codeString == null || "".equals(codeString))
128            if (codeString == null || "".equals(codeString))
129                return null;
130        if ("in-compose".equals(codeString))
131          return CodeSearchSupport.INCOMPOSE;
132        if ("in-expansion".equals(codeString))
133          return CodeSearchSupport.INEXPANSION;
134        if ("in-compose-or-expansion".equals(codeString))
135          return CodeSearchSupport.INCOMPOSEOREXPANSION;
136        throw new IllegalArgumentException("Unknown CodeSearchSupport code '"+codeString+"'");
137        }
138        public Enumeration<CodeSearchSupport> fromType(Base code) throws FHIRException {
139          if (code == null)
140            return null;
141          if (code.isEmpty())
142            return new Enumeration<CodeSearchSupport>(this);
143          String codeString = ((PrimitiveType) code).asStringValue();
144          if (codeString == null || "".equals(codeString))
145            return null;
146        if ("in-compose".equals(codeString))
147          return new Enumeration<CodeSearchSupport>(this, CodeSearchSupport.INCOMPOSE);
148        if ("in-expansion".equals(codeString))
149          return new Enumeration<CodeSearchSupport>(this, CodeSearchSupport.INEXPANSION);
150        if ("in-compose-or-expansion".equals(codeString))
151          return new Enumeration<CodeSearchSupport>(this, CodeSearchSupport.INCOMPOSEOREXPANSION);
152        throw new FHIRException("Unknown CodeSearchSupport code '"+codeString+"'");
153        }
154    public String toCode(CodeSearchSupport code) {
155      if (code == CodeSearchSupport.INCOMPOSE)
156        return "in-compose";
157      if (code == CodeSearchSupport.INEXPANSION)
158        return "in-expansion";
159      if (code == CodeSearchSupport.INCOMPOSEOREXPANSION)
160        return "in-compose-or-expansion";
161      return "?";
162      }
163    public String toSystem(CodeSearchSupport code) {
164      return code.getSystem();
165      }
166    }
167
168    public enum CommonLanguages {
169        /**
170         * 
171         */
172        AR, 
173        /**
174         * 
175         */
176        BN, 
177        /**
178         * 
179         */
180        CS, 
181        /**
182         * 
183         */
184        DA, 
185        /**
186         * 
187         */
188        DE, 
189        /**
190         * 
191         */
192        DEAT, 
193        /**
194         * 
195         */
196        DECH, 
197        /**
198         * 
199         */
200        DEDE, 
201        /**
202         * 
203         */
204        EL, 
205        /**
206         * 
207         */
208        EN, 
209        /**
210         * 
211         */
212        ENAU, 
213        /**
214         * 
215         */
216        ENCA, 
217        /**
218         * 
219         */
220        ENGB, 
221        /**
222         * 
223         */
224        ENIN, 
225        /**
226         * 
227         */
228        ENNZ, 
229        /**
230         * 
231         */
232        ENSG, 
233        /**
234         * 
235         */
236        ENUS, 
237        /**
238         * 
239         */
240        ES, 
241        /**
242         * 
243         */
244        ESAR, 
245        /**
246         * 
247         */
248        ESES, 
249        /**
250         * 
251         */
252        ESUY, 
253        /**
254         * 
255         */
256        FI, 
257        /**
258         * 
259         */
260        FR, 
261        /**
262         * 
263         */
264        FRBE, 
265        /**
266         * 
267         */
268        FRCH, 
269        /**
270         * 
271         */
272        FRFR, 
273        /**
274         * 
275         */
276        FRCA, 
277        /**
278         * 
279         */
280        FY, 
281        /**
282         * 
283         */
284        FYNL, 
285        /**
286         * 
287         */
288        HI, 
289        /**
290         * 
291         */
292        HR, 
293        /**
294         * 
295         */
296        IT, 
297        /**
298         * 
299         */
300        ITCH, 
301        /**
302         * 
303         */
304        ITIT, 
305        /**
306         * 
307         */
308        JA, 
309        /**
310         * 
311         */
312        KO, 
313        /**
314         * 
315         */
316        NL, 
317        /**
318         * 
319         */
320        NLBE, 
321        /**
322         * 
323         */
324        NLNL, 
325        /**
326         * 
327         */
328        NO, 
329        /**
330         * 
331         */
332        NONO, 
333        /**
334         * 
335         */
336        PA, 
337        /**
338         * 
339         */
340        PL, 
341        /**
342         * 
343         */
344        PT, 
345        /**
346         * 
347         */
348        PTBR, 
349        /**
350         * 
351         */
352        RU, 
353        /**
354         * 
355         */
356        RURU, 
357        /**
358         * 
359         */
360        SR, 
361        /**
362         * 
363         */
364        SRRS, 
365        /**
366         * 
367         */
368        SV, 
369        /**
370         * 
371         */
372        SVSE, 
373        /**
374         * 
375         */
376        TE, 
377        /**
378         * 
379         */
380        ZH, 
381        /**
382         * 
383         */
384        ZHCN, 
385        /**
386         * 
387         */
388        ZHHK, 
389        /**
390         * 
391         */
392        ZHSG, 
393        /**
394         * 
395         */
396        ZHTW, 
397        /**
398         * added to help the parsers with the generic types
399         */
400        NULL;
401        public static CommonLanguages fromCode(String codeString) throws FHIRException {
402            if (codeString == null || "".equals(codeString))
403                return null;
404        if ("ar".equals(codeString))
405          return AR;
406        if ("bn".equals(codeString))
407          return BN;
408        if ("cs".equals(codeString))
409          return CS;
410        if ("da".equals(codeString))
411          return DA;
412        if ("de".equals(codeString))
413          return DE;
414        if ("de-AT".equals(codeString))
415          return DEAT;
416        if ("de-CH".equals(codeString))
417          return DECH;
418        if ("de-DE".equals(codeString))
419          return DEDE;
420        if ("el".equals(codeString))
421          return EL;
422        if ("en".equals(codeString))
423          return EN;
424        if ("en-AU".equals(codeString))
425          return ENAU;
426        if ("en-CA".equals(codeString))
427          return ENCA;
428        if ("en-GB".equals(codeString))
429          return ENGB;
430        if ("en-IN".equals(codeString))
431          return ENIN;
432        if ("en-NZ".equals(codeString))
433          return ENNZ;
434        if ("en-SG".equals(codeString))
435          return ENSG;
436        if ("en-US".equals(codeString))
437          return ENUS;
438        if ("es".equals(codeString))
439          return ES;
440        if ("es-AR".equals(codeString))
441          return ESAR;
442        if ("es-ES".equals(codeString))
443          return ESES;
444        if ("es-UY".equals(codeString))
445          return ESUY;
446        if ("fi".equals(codeString))
447          return FI;
448        if ("fr".equals(codeString))
449          return FR;
450        if ("fr-BE".equals(codeString))
451          return FRBE;
452        if ("fr-CH".equals(codeString))
453          return FRCH;
454        if ("fr-FR".equals(codeString))
455          return FRFR;
456        if ("fr-CA".equals(codeString))
457          return FRCA;
458        if ("fy".equals(codeString))
459          return FY;
460        if ("fy-NL".equals(codeString))
461          return FYNL;
462        if ("hi".equals(codeString))
463          return HI;
464        if ("hr".equals(codeString))
465          return HR;
466        if ("it".equals(codeString))
467          return IT;
468        if ("it-CH".equals(codeString))
469          return ITCH;
470        if ("it-IT".equals(codeString))
471          return ITIT;
472        if ("ja".equals(codeString))
473          return JA;
474        if ("ko".equals(codeString))
475          return KO;
476        if ("nl".equals(codeString))
477          return NL;
478        if ("nl-BE".equals(codeString))
479          return NLBE;
480        if ("nl-NL".equals(codeString))
481          return NLNL;
482        if ("no".equals(codeString))
483          return NO;
484        if ("no-NO".equals(codeString))
485          return NONO;
486        if ("pa".equals(codeString))
487          return PA;
488        if ("pl".equals(codeString))
489          return PL;
490        if ("pt".equals(codeString))
491          return PT;
492        if ("pt-BR".equals(codeString))
493          return PTBR;
494        if ("ru".equals(codeString))
495          return RU;
496        if ("ru-RU".equals(codeString))
497          return RURU;
498        if ("sr".equals(codeString))
499          return SR;
500        if ("sr-RS".equals(codeString))
501          return SRRS;
502        if ("sv".equals(codeString))
503          return SV;
504        if ("sv-SE".equals(codeString))
505          return SVSE;
506        if ("te".equals(codeString))
507          return TE;
508        if ("zh".equals(codeString))
509          return ZH;
510        if ("zh-CN".equals(codeString))
511          return ZHCN;
512        if ("zh-HK".equals(codeString))
513          return ZHHK;
514        if ("zh-SG".equals(codeString))
515          return ZHSG;
516        if ("zh-TW".equals(codeString))
517          return ZHTW;
518        if (Configuration.isAcceptInvalidEnums())
519          return null;
520        else
521          throw new FHIRException("Unknown CommonLanguages code '"+codeString+"'");
522        }
523        public String toCode() {
524          switch (this) {
525            case AR: return "ar";
526            case BN: return "bn";
527            case CS: return "cs";
528            case DA: return "da";
529            case DE: return "de";
530            case DEAT: return "de-AT";
531            case DECH: return "de-CH";
532            case DEDE: return "de-DE";
533            case EL: return "el";
534            case EN: return "en";
535            case ENAU: return "en-AU";
536            case ENCA: return "en-CA";
537            case ENGB: return "en-GB";
538            case ENIN: return "en-IN";
539            case ENNZ: return "en-NZ";
540            case ENSG: return "en-SG";
541            case ENUS: return "en-US";
542            case ES: return "es";
543            case ESAR: return "es-AR";
544            case ESES: return "es-ES";
545            case ESUY: return "es-UY";
546            case FI: return "fi";
547            case FR: return "fr";
548            case FRBE: return "fr-BE";
549            case FRCH: return "fr-CH";
550            case FRFR: return "fr-FR";
551            case FRCA: return "fr-CA";
552            case FY: return "fy";
553            case FYNL: return "fy-NL";
554            case HI: return "hi";
555            case HR: return "hr";
556            case IT: return "it";
557            case ITCH: return "it-CH";
558            case ITIT: return "it-IT";
559            case JA: return "ja";
560            case KO: return "ko";
561            case NL: return "nl";
562            case NLBE: return "nl-BE";
563            case NLNL: return "nl-NL";
564            case NO: return "no";
565            case NONO: return "no-NO";
566            case PA: return "pa";
567            case PL: return "pl";
568            case PT: return "pt";
569            case PTBR: return "pt-BR";
570            case RU: return "ru";
571            case RURU: return "ru-RU";
572            case SR: return "sr";
573            case SRRS: return "sr-RS";
574            case SV: return "sv";
575            case SVSE: return "sv-SE";
576            case TE: return "te";
577            case ZH: return "zh";
578            case ZHCN: return "zh-CN";
579            case ZHHK: return "zh-HK";
580            case ZHSG: return "zh-SG";
581            case ZHTW: return "zh-TW";
582            case NULL: return null;
583            default: return "?";
584          }
585        }
586        public String getSystem() {
587          switch (this) {
588            case AR: return "urn:ietf:bcp:47";
589            case BN: return "urn:ietf:bcp:47";
590            case CS: return "urn:ietf:bcp:47";
591            case DA: return "urn:ietf:bcp:47";
592            case DE: return "urn:ietf:bcp:47";
593            case DEAT: return "urn:ietf:bcp:47";
594            case DECH: return "urn:ietf:bcp:47";
595            case DEDE: return "urn:ietf:bcp:47";
596            case EL: return "urn:ietf:bcp:47";
597            case EN: return "urn:ietf:bcp:47";
598            case ENAU: return "urn:ietf:bcp:47";
599            case ENCA: return "urn:ietf:bcp:47";
600            case ENGB: return "urn:ietf:bcp:47";
601            case ENIN: return "urn:ietf:bcp:47";
602            case ENNZ: return "urn:ietf:bcp:47";
603            case ENSG: return "urn:ietf:bcp:47";
604            case ENUS: return "urn:ietf:bcp:47";
605            case ES: return "urn:ietf:bcp:47";
606            case ESAR: return "urn:ietf:bcp:47";
607            case ESES: return "urn:ietf:bcp:47";
608            case ESUY: return "urn:ietf:bcp:47";
609            case FI: return "urn:ietf:bcp:47";
610            case FR: return "urn:ietf:bcp:47";
611            case FRBE: return "urn:ietf:bcp:47";
612            case FRCH: return "urn:ietf:bcp:47";
613            case FRFR: return "urn:ietf:bcp:47";
614            case FRCA: return "urn:ietf:bcp:47";
615            case FY: return "urn:ietf:bcp:47";
616            case FYNL: return "urn:ietf:bcp:47";
617            case HI: return "urn:ietf:bcp:47";
618            case HR: return "urn:ietf:bcp:47";
619            case IT: return "urn:ietf:bcp:47";
620            case ITCH: return "urn:ietf:bcp:47";
621            case ITIT: return "urn:ietf:bcp:47";
622            case JA: return "urn:ietf:bcp:47";
623            case KO: return "urn:ietf:bcp:47";
624            case NL: return "urn:ietf:bcp:47";
625            case NLBE: return "urn:ietf:bcp:47";
626            case NLNL: return "urn:ietf:bcp:47";
627            case NO: return "urn:ietf:bcp:47";
628            case NONO: return "urn:ietf:bcp:47";
629            case PA: return "urn:ietf:bcp:47";
630            case PL: return "urn:ietf:bcp:47";
631            case PT: return "urn:ietf:bcp:47";
632            case PTBR: return "urn:ietf:bcp:47";
633            case RU: return "urn:ietf:bcp:47";
634            case RURU: return "urn:ietf:bcp:47";
635            case SR: return "urn:ietf:bcp:47";
636            case SRRS: return "urn:ietf:bcp:47";
637            case SV: return "urn:ietf:bcp:47";
638            case SVSE: return "urn:ietf:bcp:47";
639            case TE: return "urn:ietf:bcp:47";
640            case ZH: return "urn:ietf:bcp:47";
641            case ZHCN: return "urn:ietf:bcp:47";
642            case ZHHK: return "urn:ietf:bcp:47";
643            case ZHSG: return "urn:ietf:bcp:47";
644            case ZHTW: return "urn:ietf:bcp:47";
645            case NULL: return null;
646            default: return "?";
647          }
648        }
649        public String getDefinition() {
650          switch (this) {
651            case AR: return "";
652            case BN: return "";
653            case CS: return "";
654            case DA: return "";
655            case DE: return "";
656            case DEAT: return "";
657            case DECH: return "";
658            case DEDE: return "";
659            case EL: return "";
660            case EN: return "";
661            case ENAU: return "";
662            case ENCA: return "";
663            case ENGB: return "";
664            case ENIN: return "";
665            case ENNZ: return "";
666            case ENSG: return "";
667            case ENUS: return "";
668            case ES: return "";
669            case ESAR: return "";
670            case ESES: return "";
671            case ESUY: return "";
672            case FI: return "";
673            case FR: return "";
674            case FRBE: return "";
675            case FRCH: return "";
676            case FRFR: return "";
677            case FRCA: return "";
678            case FY: return "";
679            case FYNL: return "";
680            case HI: return "";
681            case HR: return "";
682            case IT: return "";
683            case ITCH: return "";
684            case ITIT: return "";
685            case JA: return "";
686            case KO: return "";
687            case NL: return "";
688            case NLBE: return "";
689            case NLNL: return "";
690            case NO: return "";
691            case NONO: return "";
692            case PA: return "";
693            case PL: return "";
694            case PT: return "";
695            case PTBR: return "";
696            case RU: return "";
697            case RURU: return "";
698            case SR: return "";
699            case SRRS: return "";
700            case SV: return "";
701            case SVSE: return "";
702            case TE: return "";
703            case ZH: return "";
704            case ZHCN: return "";
705            case ZHHK: return "";
706            case ZHSG: return "";
707            case ZHTW: return "";
708            case NULL: return null;
709            default: return "?";
710          }
711        }
712        public String getDisplay() {
713          switch (this) {
714            case AR: return "Arabisk";
715            case BN: return "Bengali";
716            case CS: return "Czech";
717            case DA: return "Danish";
718            case DE: return "German";
719            case DEAT: return "German (Austria)";
720            case DECH: return "German (Switzerland)";
721            case DEDE: return "German (Germany)";
722            case EL: return "Greek";
723            case EN: return "English";
724            case ENAU: return "English (Australia)";
725            case ENCA: return "English (Canada)";
726            case ENGB: return "English (Great Britain)";
727            case ENIN: return "English (India)";
728            case ENNZ: return "English (New Zealand)";
729            case ENSG: return "English (Singapore)";
730            case ENUS: return "English (United States)";
731            case ES: return "Spanish";
732            case ESAR: return "Spanish (Argentina)";
733            case ESES: return "Spanish (Spain)";
734            case ESUY: return "Spanish (Uruguay)";
735            case FI: return "Finnish";
736            case FR: return "French";
737            case FRBE: return "French (Belgium)";
738            case FRCH: return "French (Switzerland)";
739            case FRFR: return "French (France)";
740            case FRCA: return "French (Canada)";
741            case FY: return "Frysian";
742            case FYNL: return "Frysian (Netherlands)";
743            case HI: return "Hindi";
744            case HR: return "Croatian";
745            case IT: return "Italian";
746            case ITCH: return "Italian (Switzerland)";
747            case ITIT: return "Italian (Italy)";
748            case JA: return "Japanese";
749            case KO: return "Korean";
750            case NL: return "Dutch";
751            case NLBE: return "Dutch (Belgium)";
752            case NLNL: return "Dutch (Netherlands)";
753            case NO: return "Norwegian";
754            case NONO: return "Norwegian (Norway)";
755            case PA: return "Punjabi";
756            case PL: return "Polskie";
757            case PT: return "Portuguese";
758            case PTBR: return "Portuguese (Brazil)";
759            case RU: return "Russian";
760            case RURU: return "Russian (Russia)";
761            case SR: return "Serbian";
762            case SRRS: return "Serbian (Serbia)";
763            case SV: return "Swedish";
764            case SVSE: return "Swedish (Sweden)";
765            case TE: return "Telegu";
766            case ZH: return "Chinese";
767            case ZHCN: return "Chinese (China)";
768            case ZHHK: return "Chinese (Hong Kong)";
769            case ZHSG: return "Chinese (Singapore)";
770            case ZHTW: return "Chinese (Taiwan)";
771            case NULL: return null;
772            default: return "?";
773          }
774        }
775    }
776
777  public static class CommonLanguagesEnumFactory implements EnumFactory<CommonLanguages> {
778    public CommonLanguages fromCode(String codeString) throws IllegalArgumentException {
779      if (codeString == null || "".equals(codeString))
780            if (codeString == null || "".equals(codeString))
781                return null;
782        if ("ar".equals(codeString))
783          return CommonLanguages.AR;
784        if ("bn".equals(codeString))
785          return CommonLanguages.BN;
786        if ("cs".equals(codeString))
787          return CommonLanguages.CS;
788        if ("da".equals(codeString))
789          return CommonLanguages.DA;
790        if ("de".equals(codeString))
791          return CommonLanguages.DE;
792        if ("de-AT".equals(codeString))
793          return CommonLanguages.DEAT;
794        if ("de-CH".equals(codeString))
795          return CommonLanguages.DECH;
796        if ("de-DE".equals(codeString))
797          return CommonLanguages.DEDE;
798        if ("el".equals(codeString))
799          return CommonLanguages.EL;
800        if ("en".equals(codeString))
801          return CommonLanguages.EN;
802        if ("en-AU".equals(codeString))
803          return CommonLanguages.ENAU;
804        if ("en-CA".equals(codeString))
805          return CommonLanguages.ENCA;
806        if ("en-GB".equals(codeString))
807          return CommonLanguages.ENGB;
808        if ("en-IN".equals(codeString))
809          return CommonLanguages.ENIN;
810        if ("en-NZ".equals(codeString))
811          return CommonLanguages.ENNZ;
812        if ("en-SG".equals(codeString))
813          return CommonLanguages.ENSG;
814        if ("en-US".equals(codeString))
815          return CommonLanguages.ENUS;
816        if ("es".equals(codeString))
817          return CommonLanguages.ES;
818        if ("es-AR".equals(codeString))
819          return CommonLanguages.ESAR;
820        if ("es-ES".equals(codeString))
821          return CommonLanguages.ESES;
822        if ("es-UY".equals(codeString))
823          return CommonLanguages.ESUY;
824        if ("fi".equals(codeString))
825          return CommonLanguages.FI;
826        if ("fr".equals(codeString))
827          return CommonLanguages.FR;
828        if ("fr-BE".equals(codeString))
829          return CommonLanguages.FRBE;
830        if ("fr-CH".equals(codeString))
831          return CommonLanguages.FRCH;
832        if ("fr-FR".equals(codeString))
833          return CommonLanguages.FRFR;
834        if ("fr-CA".equals(codeString))
835          return CommonLanguages.FRCA;
836        if ("fy".equals(codeString))
837          return CommonLanguages.FY;
838        if ("fy-NL".equals(codeString))
839          return CommonLanguages.FYNL;
840        if ("hi".equals(codeString))
841          return CommonLanguages.HI;
842        if ("hr".equals(codeString))
843          return CommonLanguages.HR;
844        if ("it".equals(codeString))
845          return CommonLanguages.IT;
846        if ("it-CH".equals(codeString))
847          return CommonLanguages.ITCH;
848        if ("it-IT".equals(codeString))
849          return CommonLanguages.ITIT;
850        if ("ja".equals(codeString))
851          return CommonLanguages.JA;
852        if ("ko".equals(codeString))
853          return CommonLanguages.KO;
854        if ("nl".equals(codeString))
855          return CommonLanguages.NL;
856        if ("nl-BE".equals(codeString))
857          return CommonLanguages.NLBE;
858        if ("nl-NL".equals(codeString))
859          return CommonLanguages.NLNL;
860        if ("no".equals(codeString))
861          return CommonLanguages.NO;
862        if ("no-NO".equals(codeString))
863          return CommonLanguages.NONO;
864        if ("pa".equals(codeString))
865          return CommonLanguages.PA;
866        if ("pl".equals(codeString))
867          return CommonLanguages.PL;
868        if ("pt".equals(codeString))
869          return CommonLanguages.PT;
870        if ("pt-BR".equals(codeString))
871          return CommonLanguages.PTBR;
872        if ("ru".equals(codeString))
873          return CommonLanguages.RU;
874        if ("ru-RU".equals(codeString))
875          return CommonLanguages.RURU;
876        if ("sr".equals(codeString))
877          return CommonLanguages.SR;
878        if ("sr-RS".equals(codeString))
879          return CommonLanguages.SRRS;
880        if ("sv".equals(codeString))
881          return CommonLanguages.SV;
882        if ("sv-SE".equals(codeString))
883          return CommonLanguages.SVSE;
884        if ("te".equals(codeString))
885          return CommonLanguages.TE;
886        if ("zh".equals(codeString))
887          return CommonLanguages.ZH;
888        if ("zh-CN".equals(codeString))
889          return CommonLanguages.ZHCN;
890        if ("zh-HK".equals(codeString))
891          return CommonLanguages.ZHHK;
892        if ("zh-SG".equals(codeString))
893          return CommonLanguages.ZHSG;
894        if ("zh-TW".equals(codeString))
895          return CommonLanguages.ZHTW;
896        throw new IllegalArgumentException("Unknown CommonLanguages code '"+codeString+"'");
897        }
898        public Enumeration<CommonLanguages> fromType(Base code) throws FHIRException {
899          if (code == null)
900            return null;
901          if (code.isEmpty())
902            return new Enumeration<CommonLanguages>(this);
903          String codeString = ((PrimitiveType) code).asStringValue();
904          if (codeString == null || "".equals(codeString))
905            return null;
906        if ("ar".equals(codeString))
907          return new Enumeration<CommonLanguages>(this, CommonLanguages.AR);
908        if ("bn".equals(codeString))
909          return new Enumeration<CommonLanguages>(this, CommonLanguages.BN);
910        if ("cs".equals(codeString))
911          return new Enumeration<CommonLanguages>(this, CommonLanguages.CS);
912        if ("da".equals(codeString))
913          return new Enumeration<CommonLanguages>(this, CommonLanguages.DA);
914        if ("de".equals(codeString))
915          return new Enumeration<CommonLanguages>(this, CommonLanguages.DE);
916        if ("de-AT".equals(codeString))
917          return new Enumeration<CommonLanguages>(this, CommonLanguages.DEAT);
918        if ("de-CH".equals(codeString))
919          return new Enumeration<CommonLanguages>(this, CommonLanguages.DECH);
920        if ("de-DE".equals(codeString))
921          return new Enumeration<CommonLanguages>(this, CommonLanguages.DEDE);
922        if ("el".equals(codeString))
923          return new Enumeration<CommonLanguages>(this, CommonLanguages.EL);
924        if ("en".equals(codeString))
925          return new Enumeration<CommonLanguages>(this, CommonLanguages.EN);
926        if ("en-AU".equals(codeString))
927          return new Enumeration<CommonLanguages>(this, CommonLanguages.ENAU);
928        if ("en-CA".equals(codeString))
929          return new Enumeration<CommonLanguages>(this, CommonLanguages.ENCA);
930        if ("en-GB".equals(codeString))
931          return new Enumeration<CommonLanguages>(this, CommonLanguages.ENGB);
932        if ("en-IN".equals(codeString))
933          return new Enumeration<CommonLanguages>(this, CommonLanguages.ENIN);
934        if ("en-NZ".equals(codeString))
935          return new Enumeration<CommonLanguages>(this, CommonLanguages.ENNZ);
936        if ("en-SG".equals(codeString))
937          return new Enumeration<CommonLanguages>(this, CommonLanguages.ENSG);
938        if ("en-US".equals(codeString))
939          return new Enumeration<CommonLanguages>(this, CommonLanguages.ENUS);
940        if ("es".equals(codeString))
941          return new Enumeration<CommonLanguages>(this, CommonLanguages.ES);
942        if ("es-AR".equals(codeString))
943          return new Enumeration<CommonLanguages>(this, CommonLanguages.ESAR);
944        if ("es-ES".equals(codeString))
945          return new Enumeration<CommonLanguages>(this, CommonLanguages.ESES);
946        if ("es-UY".equals(codeString))
947          return new Enumeration<CommonLanguages>(this, CommonLanguages.ESUY);
948        if ("fi".equals(codeString))
949          return new Enumeration<CommonLanguages>(this, CommonLanguages.FI);
950        if ("fr".equals(codeString))
951          return new Enumeration<CommonLanguages>(this, CommonLanguages.FR);
952        if ("fr-BE".equals(codeString))
953          return new Enumeration<CommonLanguages>(this, CommonLanguages.FRBE);
954        if ("fr-CH".equals(codeString))
955          return new Enumeration<CommonLanguages>(this, CommonLanguages.FRCH);
956        if ("fr-FR".equals(codeString))
957          return new Enumeration<CommonLanguages>(this, CommonLanguages.FRFR);
958        if ("fr-CA".equals(codeString))
959          return new Enumeration<CommonLanguages>(this, CommonLanguages.FRCA);
960        if ("fy".equals(codeString))
961          return new Enumeration<CommonLanguages>(this, CommonLanguages.FY);
962        if ("fy-NL".equals(codeString))
963          return new Enumeration<CommonLanguages>(this, CommonLanguages.FYNL);
964        if ("hi".equals(codeString))
965          return new Enumeration<CommonLanguages>(this, CommonLanguages.HI);
966        if ("hr".equals(codeString))
967          return new Enumeration<CommonLanguages>(this, CommonLanguages.HR);
968        if ("it".equals(codeString))
969          return new Enumeration<CommonLanguages>(this, CommonLanguages.IT);
970        if ("it-CH".equals(codeString))
971          return new Enumeration<CommonLanguages>(this, CommonLanguages.ITCH);
972        if ("it-IT".equals(codeString))
973          return new Enumeration<CommonLanguages>(this, CommonLanguages.ITIT);
974        if ("ja".equals(codeString))
975          return new Enumeration<CommonLanguages>(this, CommonLanguages.JA);
976        if ("ko".equals(codeString))
977          return new Enumeration<CommonLanguages>(this, CommonLanguages.KO);
978        if ("nl".equals(codeString))
979          return new Enumeration<CommonLanguages>(this, CommonLanguages.NL);
980        if ("nl-BE".equals(codeString))
981          return new Enumeration<CommonLanguages>(this, CommonLanguages.NLBE);
982        if ("nl-NL".equals(codeString))
983          return new Enumeration<CommonLanguages>(this, CommonLanguages.NLNL);
984        if ("no".equals(codeString))
985          return new Enumeration<CommonLanguages>(this, CommonLanguages.NO);
986        if ("no-NO".equals(codeString))
987          return new Enumeration<CommonLanguages>(this, CommonLanguages.NONO);
988        if ("pa".equals(codeString))
989          return new Enumeration<CommonLanguages>(this, CommonLanguages.PA);
990        if ("pl".equals(codeString))
991          return new Enumeration<CommonLanguages>(this, CommonLanguages.PL);
992        if ("pt".equals(codeString))
993          return new Enumeration<CommonLanguages>(this, CommonLanguages.PT);
994        if ("pt-BR".equals(codeString))
995          return new Enumeration<CommonLanguages>(this, CommonLanguages.PTBR);
996        if ("ru".equals(codeString))
997          return new Enumeration<CommonLanguages>(this, CommonLanguages.RU);
998        if ("ru-RU".equals(codeString))
999          return new Enumeration<CommonLanguages>(this, CommonLanguages.RURU);
1000        if ("sr".equals(codeString))
1001          return new Enumeration<CommonLanguages>(this, CommonLanguages.SR);
1002        if ("sr-RS".equals(codeString))
1003          return new Enumeration<CommonLanguages>(this, CommonLanguages.SRRS);
1004        if ("sv".equals(codeString))
1005          return new Enumeration<CommonLanguages>(this, CommonLanguages.SV);
1006        if ("sv-SE".equals(codeString))
1007          return new Enumeration<CommonLanguages>(this, CommonLanguages.SVSE);
1008        if ("te".equals(codeString))
1009          return new Enumeration<CommonLanguages>(this, CommonLanguages.TE);
1010        if ("zh".equals(codeString))
1011          return new Enumeration<CommonLanguages>(this, CommonLanguages.ZH);
1012        if ("zh-CN".equals(codeString))
1013          return new Enumeration<CommonLanguages>(this, CommonLanguages.ZHCN);
1014        if ("zh-HK".equals(codeString))
1015          return new Enumeration<CommonLanguages>(this, CommonLanguages.ZHHK);
1016        if ("zh-SG".equals(codeString))
1017          return new Enumeration<CommonLanguages>(this, CommonLanguages.ZHSG);
1018        if ("zh-TW".equals(codeString))
1019          return new Enumeration<CommonLanguages>(this, CommonLanguages.ZHTW);
1020        throw new FHIRException("Unknown CommonLanguages code '"+codeString+"'");
1021        }
1022    public String toCode(CommonLanguages code) {
1023      if (code == CommonLanguages.AR)
1024        return "ar";
1025      if (code == CommonLanguages.BN)
1026        return "bn";
1027      if (code == CommonLanguages.CS)
1028        return "cs";
1029      if (code == CommonLanguages.DA)
1030        return "da";
1031      if (code == CommonLanguages.DE)
1032        return "de";
1033      if (code == CommonLanguages.DEAT)
1034        return "de-AT";
1035      if (code == CommonLanguages.DECH)
1036        return "de-CH";
1037      if (code == CommonLanguages.DEDE)
1038        return "de-DE";
1039      if (code == CommonLanguages.EL)
1040        return "el";
1041      if (code == CommonLanguages.EN)
1042        return "en";
1043      if (code == CommonLanguages.ENAU)
1044        return "en-AU";
1045      if (code == CommonLanguages.ENCA)
1046        return "en-CA";
1047      if (code == CommonLanguages.ENGB)
1048        return "en-GB";
1049      if (code == CommonLanguages.ENIN)
1050        return "en-IN";
1051      if (code == CommonLanguages.ENNZ)
1052        return "en-NZ";
1053      if (code == CommonLanguages.ENSG)
1054        return "en-SG";
1055      if (code == CommonLanguages.ENUS)
1056        return "en-US";
1057      if (code == CommonLanguages.ES)
1058        return "es";
1059      if (code == CommonLanguages.ESAR)
1060        return "es-AR";
1061      if (code == CommonLanguages.ESES)
1062        return "es-ES";
1063      if (code == CommonLanguages.ESUY)
1064        return "es-UY";
1065      if (code == CommonLanguages.FI)
1066        return "fi";
1067      if (code == CommonLanguages.FR)
1068        return "fr";
1069      if (code == CommonLanguages.FRBE)
1070        return "fr-BE";
1071      if (code == CommonLanguages.FRCH)
1072        return "fr-CH";
1073      if (code == CommonLanguages.FRFR)
1074        return "fr-FR";
1075      if (code == CommonLanguages.FRCA)
1076        return "fr-CA";
1077      if (code == CommonLanguages.FY)
1078        return "fy";
1079      if (code == CommonLanguages.FYNL)
1080        return "fy-NL";
1081      if (code == CommonLanguages.HI)
1082        return "hi";
1083      if (code == CommonLanguages.HR)
1084        return "hr";
1085      if (code == CommonLanguages.IT)
1086        return "it";
1087      if (code == CommonLanguages.ITCH)
1088        return "it-CH";
1089      if (code == CommonLanguages.ITIT)
1090        return "it-IT";
1091      if (code == CommonLanguages.JA)
1092        return "ja";
1093      if (code == CommonLanguages.KO)
1094        return "ko";
1095      if (code == CommonLanguages.NL)
1096        return "nl";
1097      if (code == CommonLanguages.NLBE)
1098        return "nl-BE";
1099      if (code == CommonLanguages.NLNL)
1100        return "nl-NL";
1101      if (code == CommonLanguages.NO)
1102        return "no";
1103      if (code == CommonLanguages.NONO)
1104        return "no-NO";
1105      if (code == CommonLanguages.PA)
1106        return "pa";
1107      if (code == CommonLanguages.PL)
1108        return "pl";
1109      if (code == CommonLanguages.PT)
1110        return "pt";
1111      if (code == CommonLanguages.PTBR)
1112        return "pt-BR";
1113      if (code == CommonLanguages.RU)
1114        return "ru";
1115      if (code == CommonLanguages.RURU)
1116        return "ru-RU";
1117      if (code == CommonLanguages.SR)
1118        return "sr";
1119      if (code == CommonLanguages.SRRS)
1120        return "sr-RS";
1121      if (code == CommonLanguages.SV)
1122        return "sv";
1123      if (code == CommonLanguages.SVSE)
1124        return "sv-SE";
1125      if (code == CommonLanguages.TE)
1126        return "te";
1127      if (code == CommonLanguages.ZH)
1128        return "zh";
1129      if (code == CommonLanguages.ZHCN)
1130        return "zh-CN";
1131      if (code == CommonLanguages.ZHHK)
1132        return "zh-HK";
1133      if (code == CommonLanguages.ZHSG)
1134        return "zh-SG";
1135      if (code == CommonLanguages.ZHTW)
1136        return "zh-TW";
1137      return "?";
1138      }
1139    public String toSystem(CommonLanguages code) {
1140      return code.getSystem();
1141      }
1142    }
1143
1144    @Block()
1145    public static class TerminologyCapabilitiesSoftwareComponent extends BackboneElement implements IBaseBackboneElement {
1146        /**
1147         * Name the software is known by.
1148         */
1149        @Child(name = "name", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=true)
1150        @Description(shortDefinition="A name the software is known by", formalDefinition="Name the software is known by." )
1151        protected StringType name;
1152
1153        /**
1154         * The version identifier for the software covered by this statement.
1155         */
1156        @Child(name = "version", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true)
1157        @Description(shortDefinition="Version covered by this statement", formalDefinition="The version identifier for the software covered by this statement." )
1158        protected StringType version;
1159
1160        private static final long serialVersionUID = -790299911L;
1161
1162    /**
1163     * Constructor
1164     */
1165      public TerminologyCapabilitiesSoftwareComponent() {
1166        super();
1167      }
1168
1169    /**
1170     * Constructor
1171     */
1172      public TerminologyCapabilitiesSoftwareComponent(String name) {
1173        super();
1174        this.setName(name);
1175      }
1176
1177        /**
1178         * @return {@link #name} (Name the software is known by.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
1179         */
1180        public StringType getNameElement() { 
1181          if (this.name == null)
1182            if (Configuration.errorOnAutoCreate())
1183              throw new Error("Attempt to auto-create TerminologyCapabilitiesSoftwareComponent.name");
1184            else if (Configuration.doAutoCreate())
1185              this.name = new StringType(); // bb
1186          return this.name;
1187        }
1188
1189        public boolean hasNameElement() { 
1190          return this.name != null && !this.name.isEmpty();
1191        }
1192
1193        public boolean hasName() { 
1194          return this.name != null && !this.name.isEmpty();
1195        }
1196
1197        /**
1198         * @param value {@link #name} (Name the software is known by.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
1199         */
1200        public TerminologyCapabilitiesSoftwareComponent setNameElement(StringType value) { 
1201          this.name = value;
1202          return this;
1203        }
1204
1205        /**
1206         * @return Name the software is known by.
1207         */
1208        public String getName() { 
1209          return this.name == null ? null : this.name.getValue();
1210        }
1211
1212        /**
1213         * @param value Name the software is known by.
1214         */
1215        public TerminologyCapabilitiesSoftwareComponent setName(String value) { 
1216            if (this.name == null)
1217              this.name = new StringType();
1218            this.name.setValue(value);
1219          return this;
1220        }
1221
1222        /**
1223         * @return {@link #version} (The version identifier for the software covered by this statement.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value
1224         */
1225        public StringType getVersionElement() { 
1226          if (this.version == null)
1227            if (Configuration.errorOnAutoCreate())
1228              throw new Error("Attempt to auto-create TerminologyCapabilitiesSoftwareComponent.version");
1229            else if (Configuration.doAutoCreate())
1230              this.version = new StringType(); // bb
1231          return this.version;
1232        }
1233
1234        public boolean hasVersionElement() { 
1235          return this.version != null && !this.version.isEmpty();
1236        }
1237
1238        public boolean hasVersion() { 
1239          return this.version != null && !this.version.isEmpty();
1240        }
1241
1242        /**
1243         * @param value {@link #version} (The version identifier for the software covered by this statement.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value
1244         */
1245        public TerminologyCapabilitiesSoftwareComponent setVersionElement(StringType value) { 
1246          this.version = value;
1247          return this;
1248        }
1249
1250        /**
1251         * @return The version identifier for the software covered by this statement.
1252         */
1253        public String getVersion() { 
1254          return this.version == null ? null : this.version.getValue();
1255        }
1256
1257        /**
1258         * @param value The version identifier for the software covered by this statement.
1259         */
1260        public TerminologyCapabilitiesSoftwareComponent setVersion(String value) { 
1261          if (Utilities.noString(value))
1262            this.version = null;
1263          else {
1264            if (this.version == null)
1265              this.version = new StringType();
1266            this.version.setValue(value);
1267          }
1268          return this;
1269        }
1270
1271        protected void listChildren(List<Property> children) {
1272          super.listChildren(children);
1273          children.add(new Property("name", "string", "Name the software is known by.", 0, 1, name));
1274          children.add(new Property("version", "string", "The version identifier for the software covered by this statement.", 0, 1, version));
1275        }
1276
1277        @Override
1278        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1279          switch (_hash) {
1280          case 3373707: /*name*/  return new Property("name", "string", "Name the software is known by.", 0, 1, name);
1281          case 351608024: /*version*/  return new Property("version", "string", "The version identifier for the software covered by this statement.", 0, 1, version);
1282          default: return super.getNamedProperty(_hash, _name, _checkValid);
1283          }
1284
1285        }
1286
1287      @Override
1288      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1289        switch (hash) {
1290        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
1291        case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType
1292        default: return super.getProperty(hash, name, checkValid);
1293        }
1294
1295      }
1296
1297      @Override
1298      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1299        switch (hash) {
1300        case 3373707: // name
1301          this.name = TypeConvertor.castToString(value); // StringType
1302          return value;
1303        case 351608024: // version
1304          this.version = TypeConvertor.castToString(value); // StringType
1305          return value;
1306        default: return super.setProperty(hash, name, value);
1307        }
1308
1309      }
1310
1311      @Override
1312      public Base setProperty(String name, Base value) throws FHIRException {
1313        if (name.equals("name")) {
1314          this.name = TypeConvertor.castToString(value); // StringType
1315        } else if (name.equals("version")) {
1316          this.version = TypeConvertor.castToString(value); // StringType
1317        } else
1318          return super.setProperty(name, value);
1319        return value;
1320      }
1321
1322      @Override
1323      public Base makeProperty(int hash, String name) throws FHIRException {
1324        switch (hash) {
1325        case 3373707:  return getNameElement();
1326        case 351608024:  return getVersionElement();
1327        default: return super.makeProperty(hash, name);
1328        }
1329
1330      }
1331
1332      @Override
1333      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1334        switch (hash) {
1335        case 3373707: /*name*/ return new String[] {"string"};
1336        case 351608024: /*version*/ return new String[] {"string"};
1337        default: return super.getTypesForProperty(hash, name);
1338        }
1339
1340      }
1341
1342      @Override
1343      public Base addChild(String name) throws FHIRException {
1344        if (name.equals("name")) {
1345          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.software.name");
1346        }
1347        else if (name.equals("version")) {
1348          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.software.version");
1349        }
1350        else
1351          return super.addChild(name);
1352      }
1353
1354      public TerminologyCapabilitiesSoftwareComponent copy() {
1355        TerminologyCapabilitiesSoftwareComponent dst = new TerminologyCapabilitiesSoftwareComponent();
1356        copyValues(dst);
1357        return dst;
1358      }
1359
1360      public void copyValues(TerminologyCapabilitiesSoftwareComponent dst) {
1361        super.copyValues(dst);
1362        dst.name = name == null ? null : name.copy();
1363        dst.version = version == null ? null : version.copy();
1364      }
1365
1366      @Override
1367      public boolean equalsDeep(Base other_) {
1368        if (!super.equalsDeep(other_))
1369          return false;
1370        if (!(other_ instanceof TerminologyCapabilitiesSoftwareComponent))
1371          return false;
1372        TerminologyCapabilitiesSoftwareComponent o = (TerminologyCapabilitiesSoftwareComponent) other_;
1373        return compareDeep(name, o.name, true) && compareDeep(version, o.version, true);
1374      }
1375
1376      @Override
1377      public boolean equalsShallow(Base other_) {
1378        if (!super.equalsShallow(other_))
1379          return false;
1380        if (!(other_ instanceof TerminologyCapabilitiesSoftwareComponent))
1381          return false;
1382        TerminologyCapabilitiesSoftwareComponent o = (TerminologyCapabilitiesSoftwareComponent) other_;
1383        return compareValues(name, o.name, true) && compareValues(version, o.version, true);
1384      }
1385
1386      public boolean isEmpty() {
1387        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, version);
1388      }
1389
1390  public String fhirType() {
1391    return "TerminologyCapabilities.software";
1392
1393  }
1394
1395  }
1396
1397    @Block()
1398    public static class TerminologyCapabilitiesImplementationComponent extends BackboneElement implements IBaseBackboneElement {
1399        /**
1400         * Information about the specific installation that this terminology capability statement relates to.
1401         */
1402        @Child(name = "description", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=true)
1403        @Description(shortDefinition="Describes this specific instance", formalDefinition="Information about the specific installation that this terminology capability statement relates to." )
1404        protected StringType description;
1405
1406        /**
1407         * An absolute base URL for the implementation.
1408         */
1409        @Child(name = "url", type = {UrlType.class}, order=2, min=0, max=1, modifier=false, summary=true)
1410        @Description(shortDefinition="Base URL for the implementation", formalDefinition="An absolute base URL for the implementation." )
1411        protected UrlType url;
1412
1413        private static final long serialVersionUID = 98009649L;
1414
1415    /**
1416     * Constructor
1417     */
1418      public TerminologyCapabilitiesImplementationComponent() {
1419        super();
1420      }
1421
1422    /**
1423     * Constructor
1424     */
1425      public TerminologyCapabilitiesImplementationComponent(String description) {
1426        super();
1427        this.setDescription(description);
1428      }
1429
1430        /**
1431         * @return {@link #description} (Information about the specific installation that this terminology capability statement relates to.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
1432         */
1433        public StringType getDescriptionElement() { 
1434          if (this.description == null)
1435            if (Configuration.errorOnAutoCreate())
1436              throw new Error("Attempt to auto-create TerminologyCapabilitiesImplementationComponent.description");
1437            else if (Configuration.doAutoCreate())
1438              this.description = new StringType(); // bb
1439          return this.description;
1440        }
1441
1442        public boolean hasDescriptionElement() { 
1443          return this.description != null && !this.description.isEmpty();
1444        }
1445
1446        public boolean hasDescription() { 
1447          return this.description != null && !this.description.isEmpty();
1448        }
1449
1450        /**
1451         * @param value {@link #description} (Information about the specific installation that this terminology capability statement relates to.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
1452         */
1453        public TerminologyCapabilitiesImplementationComponent setDescriptionElement(StringType value) { 
1454          this.description = value;
1455          return this;
1456        }
1457
1458        /**
1459         * @return Information about the specific installation that this terminology capability statement relates to.
1460         */
1461        public String getDescription() { 
1462          return this.description == null ? null : this.description.getValue();
1463        }
1464
1465        /**
1466         * @param value Information about the specific installation that this terminology capability statement relates to.
1467         */
1468        public TerminologyCapabilitiesImplementationComponent setDescription(String value) { 
1469            if (this.description == null)
1470              this.description = new StringType();
1471            this.description.setValue(value);
1472          return this;
1473        }
1474
1475        /**
1476         * @return {@link #url} (An absolute base URL for the implementation.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
1477         */
1478        public UrlType getUrlElement() { 
1479          if (this.url == null)
1480            if (Configuration.errorOnAutoCreate())
1481              throw new Error("Attempt to auto-create TerminologyCapabilitiesImplementationComponent.url");
1482            else if (Configuration.doAutoCreate())
1483              this.url = new UrlType(); // bb
1484          return this.url;
1485        }
1486
1487        public boolean hasUrlElement() { 
1488          return this.url != null && !this.url.isEmpty();
1489        }
1490
1491        public boolean hasUrl() { 
1492          return this.url != null && !this.url.isEmpty();
1493        }
1494
1495        /**
1496         * @param value {@link #url} (An absolute base URL for the implementation.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
1497         */
1498        public TerminologyCapabilitiesImplementationComponent setUrlElement(UrlType value) { 
1499          this.url = value;
1500          return this;
1501        }
1502
1503        /**
1504         * @return An absolute base URL for the implementation.
1505         */
1506        public String getUrl() { 
1507          return this.url == null ? null : this.url.getValue();
1508        }
1509
1510        /**
1511         * @param value An absolute base URL for the implementation.
1512         */
1513        public TerminologyCapabilitiesImplementationComponent setUrl(String value) { 
1514          if (Utilities.noString(value))
1515            this.url = null;
1516          else {
1517            if (this.url == null)
1518              this.url = new UrlType();
1519            this.url.setValue(value);
1520          }
1521          return this;
1522        }
1523
1524        protected void listChildren(List<Property> children) {
1525          super.listChildren(children);
1526          children.add(new Property("description", "string", "Information about the specific installation that this terminology capability statement relates to.", 0, 1, description));
1527          children.add(new Property("url", "url", "An absolute base URL for the implementation.", 0, 1, url));
1528        }
1529
1530        @Override
1531        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1532          switch (_hash) {
1533          case -1724546052: /*description*/  return new Property("description", "string", "Information about the specific installation that this terminology capability statement relates to.", 0, 1, description);
1534          case 116079: /*url*/  return new Property("url", "url", "An absolute base URL for the implementation.", 0, 1, url);
1535          default: return super.getNamedProperty(_hash, _name, _checkValid);
1536          }
1537
1538        }
1539
1540      @Override
1541      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1542        switch (hash) {
1543        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType
1544        case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UrlType
1545        default: return super.getProperty(hash, name, checkValid);
1546        }
1547
1548      }
1549
1550      @Override
1551      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1552        switch (hash) {
1553        case -1724546052: // description
1554          this.description = TypeConvertor.castToString(value); // StringType
1555          return value;
1556        case 116079: // url
1557          this.url = TypeConvertor.castToUrl(value); // UrlType
1558          return value;
1559        default: return super.setProperty(hash, name, value);
1560        }
1561
1562      }
1563
1564      @Override
1565      public Base setProperty(String name, Base value) throws FHIRException {
1566        if (name.equals("description")) {
1567          this.description = TypeConvertor.castToString(value); // StringType
1568        } else if (name.equals("url")) {
1569          this.url = TypeConvertor.castToUrl(value); // UrlType
1570        } else
1571          return super.setProperty(name, value);
1572        return value;
1573      }
1574
1575      @Override
1576      public Base makeProperty(int hash, String name) throws FHIRException {
1577        switch (hash) {
1578        case -1724546052:  return getDescriptionElement();
1579        case 116079:  return getUrlElement();
1580        default: return super.makeProperty(hash, name);
1581        }
1582
1583      }
1584
1585      @Override
1586      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1587        switch (hash) {
1588        case -1724546052: /*description*/ return new String[] {"string"};
1589        case 116079: /*url*/ return new String[] {"url"};
1590        default: return super.getTypesForProperty(hash, name);
1591        }
1592
1593      }
1594
1595      @Override
1596      public Base addChild(String name) throws FHIRException {
1597        if (name.equals("description")) {
1598          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.implementation.description");
1599        }
1600        else if (name.equals("url")) {
1601          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.implementation.url");
1602        }
1603        else
1604          return super.addChild(name);
1605      }
1606
1607      public TerminologyCapabilitiesImplementationComponent copy() {
1608        TerminologyCapabilitiesImplementationComponent dst = new TerminologyCapabilitiesImplementationComponent();
1609        copyValues(dst);
1610        return dst;
1611      }
1612
1613      public void copyValues(TerminologyCapabilitiesImplementationComponent dst) {
1614        super.copyValues(dst);
1615        dst.description = description == null ? null : description.copy();
1616        dst.url = url == null ? null : url.copy();
1617      }
1618
1619      @Override
1620      public boolean equalsDeep(Base other_) {
1621        if (!super.equalsDeep(other_))
1622          return false;
1623        if (!(other_ instanceof TerminologyCapabilitiesImplementationComponent))
1624          return false;
1625        TerminologyCapabilitiesImplementationComponent o = (TerminologyCapabilitiesImplementationComponent) other_;
1626        return compareDeep(description, o.description, true) && compareDeep(url, o.url, true);
1627      }
1628
1629      @Override
1630      public boolean equalsShallow(Base other_) {
1631        if (!super.equalsShallow(other_))
1632          return false;
1633        if (!(other_ instanceof TerminologyCapabilitiesImplementationComponent))
1634          return false;
1635        TerminologyCapabilitiesImplementationComponent o = (TerminologyCapabilitiesImplementationComponent) other_;
1636        return compareValues(description, o.description, true) && compareValues(url, o.url, true);
1637      }
1638
1639      public boolean isEmpty() {
1640        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(description, url);
1641      }
1642
1643  public String fhirType() {
1644    return "TerminologyCapabilities.implementation";
1645
1646  }
1647
1648  }
1649
1650    @Block()
1651    public static class TerminologyCapabilitiesCodeSystemComponent extends BackboneElement implements IBaseBackboneElement {
1652        /**
1653         * Canonical identifier for the code system, represented as a URI.
1654         */
1655        @Child(name = "uri", type = {CanonicalType.class}, order=1, min=0, max=1, modifier=false, summary=false)
1656        @Description(shortDefinition="Canonical identifier for the code system, represented as a URI", formalDefinition="Canonical identifier for the code system, represented as a URI." )
1657        protected CanonicalType uri;
1658
1659        /**
1660         * For the code system, a list of versions that are supported by the server.
1661         */
1662        @Child(name = "version", type = {}, order=2, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1663        @Description(shortDefinition="Version of Code System supported", formalDefinition="For the code system, a list of versions that are supported by the server." )
1664        protected List<TerminologyCapabilitiesCodeSystemVersionComponent> version;
1665
1666        /**
1667         * The extent of the content of the code system (the concepts and codes it defines) are represented in this resource instance.
1668         */
1669        @Child(name = "content", type = {CodeType.class}, order=3, min=1, max=1, modifier=false, summary=true)
1670        @Description(shortDefinition="not-present | example | fragment | complete | supplement", formalDefinition="The extent of the content of the code system (the concepts and codes it defines) are represented in this resource instance." )
1671        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/codesystem-content-mode")
1672        protected CodeType content;
1673
1674        /**
1675         * True if subsumption is supported for this version of the code system.
1676         */
1677        @Child(name = "subsumption", type = {BooleanType.class}, order=4, min=0, max=1, modifier=false, summary=false)
1678        @Description(shortDefinition="Whether subsumption is supported", formalDefinition="True if subsumption is supported for this version of the code system." )
1679        protected BooleanType subsumption;
1680
1681        private static final long serialVersionUID = 177402405L;
1682
1683    /**
1684     * Constructor
1685     */
1686      public TerminologyCapabilitiesCodeSystemComponent() {
1687        super();
1688      }
1689
1690    /**
1691     * Constructor
1692     */
1693      public TerminologyCapabilitiesCodeSystemComponent(String content) {
1694        super();
1695        this.setContent(content);
1696      }
1697
1698        /**
1699         * @return {@link #uri} (Canonical identifier for the code system, represented as a URI.). This is the underlying object with id, value and extensions. The accessor "getUri" gives direct access to the value
1700         */
1701        public CanonicalType getUriElement() { 
1702          if (this.uri == null)
1703            if (Configuration.errorOnAutoCreate())
1704              throw new Error("Attempt to auto-create TerminologyCapabilitiesCodeSystemComponent.uri");
1705            else if (Configuration.doAutoCreate())
1706              this.uri = new CanonicalType(); // bb
1707          return this.uri;
1708        }
1709
1710        public boolean hasUriElement() { 
1711          return this.uri != null && !this.uri.isEmpty();
1712        }
1713
1714        public boolean hasUri() { 
1715          return this.uri != null && !this.uri.isEmpty();
1716        }
1717
1718        /**
1719         * @param value {@link #uri} (Canonical identifier for the code system, represented as a URI.). This is the underlying object with id, value and extensions. The accessor "getUri" gives direct access to the value
1720         */
1721        public TerminologyCapabilitiesCodeSystemComponent setUriElement(CanonicalType value) { 
1722          this.uri = value;
1723          return this;
1724        }
1725
1726        /**
1727         * @return Canonical identifier for the code system, represented as a URI.
1728         */
1729        public String getUri() { 
1730          return this.uri == null ? null : this.uri.getValue();
1731        }
1732
1733        /**
1734         * @param value Canonical identifier for the code system, represented as a URI.
1735         */
1736        public TerminologyCapabilitiesCodeSystemComponent setUri(String value) { 
1737          if (Utilities.noString(value))
1738            this.uri = null;
1739          else {
1740            if (this.uri == null)
1741              this.uri = new CanonicalType();
1742            this.uri.setValue(value);
1743          }
1744          return this;
1745        }
1746
1747        /**
1748         * @return {@link #version} (For the code system, a list of versions that are supported by the server.)
1749         */
1750        public List<TerminologyCapabilitiesCodeSystemVersionComponent> getVersion() { 
1751          if (this.version == null)
1752            this.version = new ArrayList<TerminologyCapabilitiesCodeSystemVersionComponent>();
1753          return this.version;
1754        }
1755
1756        /**
1757         * @return Returns a reference to <code>this</code> for easy method chaining
1758         */
1759        public TerminologyCapabilitiesCodeSystemComponent setVersion(List<TerminologyCapabilitiesCodeSystemVersionComponent> theVersion) { 
1760          this.version = theVersion;
1761          return this;
1762        }
1763
1764        public boolean hasVersion() { 
1765          if (this.version == null)
1766            return false;
1767          for (TerminologyCapabilitiesCodeSystemVersionComponent item : this.version)
1768            if (!item.isEmpty())
1769              return true;
1770          return false;
1771        }
1772
1773        public TerminologyCapabilitiesCodeSystemVersionComponent addVersion() { //3
1774          TerminologyCapabilitiesCodeSystemVersionComponent t = new TerminologyCapabilitiesCodeSystemVersionComponent();
1775          if (this.version == null)
1776            this.version = new ArrayList<TerminologyCapabilitiesCodeSystemVersionComponent>();
1777          this.version.add(t);
1778          return t;
1779        }
1780
1781        public TerminologyCapabilitiesCodeSystemComponent addVersion(TerminologyCapabilitiesCodeSystemVersionComponent t) { //3
1782          if (t == null)
1783            return this;
1784          if (this.version == null)
1785            this.version = new ArrayList<TerminologyCapabilitiesCodeSystemVersionComponent>();
1786          this.version.add(t);
1787          return this;
1788        }
1789
1790        /**
1791         * @return The first repetition of repeating field {@link #version}, creating it if it does not already exist {3}
1792         */
1793        public TerminologyCapabilitiesCodeSystemVersionComponent getVersionFirstRep() { 
1794          if (getVersion().isEmpty()) {
1795            addVersion();
1796          }
1797          return getVersion().get(0);
1798        }
1799
1800        /**
1801         * @return {@link #content} (The extent of the content of the code system (the concepts and codes it defines) are represented in this resource instance.). This is the underlying object with id, value and extensions. The accessor "getContent" gives direct access to the value
1802         */
1803        public CodeType getContentElement() { 
1804          if (this.content == null)
1805            if (Configuration.errorOnAutoCreate())
1806              throw new Error("Attempt to auto-create TerminologyCapabilitiesCodeSystemComponent.content");
1807            else if (Configuration.doAutoCreate())
1808              this.content = new CodeType(); // bb
1809          return this.content;
1810        }
1811
1812        public boolean hasContentElement() { 
1813          return this.content != null && !this.content.isEmpty();
1814        }
1815
1816        public boolean hasContent() { 
1817          return this.content != null && !this.content.isEmpty();
1818        }
1819
1820        /**
1821         * @param value {@link #content} (The extent of the content of the code system (the concepts and codes it defines) are represented in this resource instance.). This is the underlying object with id, value and extensions. The accessor "getContent" gives direct access to the value
1822         */
1823        public TerminologyCapabilitiesCodeSystemComponent setContentElement(CodeType value) { 
1824          this.content = value;
1825          return this;
1826        }
1827
1828        /**
1829         * @return The extent of the content of the code system (the concepts and codes it defines) are represented in this resource instance.
1830         */
1831        public String getContent() { 
1832          return this.content == null ? null : this.content.getValue();
1833        }
1834
1835        /**
1836         * @param value The extent of the content of the code system (the concepts and codes it defines) are represented in this resource instance.
1837         */
1838        public TerminologyCapabilitiesCodeSystemComponent setContent(String value) { 
1839            if (this.content == null)
1840              this.content = new CodeType();
1841            this.content.setValue(value);
1842          return this;
1843        }
1844
1845        /**
1846         * @return {@link #subsumption} (True if subsumption is supported for this version of the code system.). This is the underlying object with id, value and extensions. The accessor "getSubsumption" gives direct access to the value
1847         */
1848        public BooleanType getSubsumptionElement() { 
1849          if (this.subsumption == null)
1850            if (Configuration.errorOnAutoCreate())
1851              throw new Error("Attempt to auto-create TerminologyCapabilitiesCodeSystemComponent.subsumption");
1852            else if (Configuration.doAutoCreate())
1853              this.subsumption = new BooleanType(); // bb
1854          return this.subsumption;
1855        }
1856
1857        public boolean hasSubsumptionElement() { 
1858          return this.subsumption != null && !this.subsumption.isEmpty();
1859        }
1860
1861        public boolean hasSubsumption() { 
1862          return this.subsumption != null && !this.subsumption.isEmpty();
1863        }
1864
1865        /**
1866         * @param value {@link #subsumption} (True if subsumption is supported for this version of the code system.). This is the underlying object with id, value and extensions. The accessor "getSubsumption" gives direct access to the value
1867         */
1868        public TerminologyCapabilitiesCodeSystemComponent setSubsumptionElement(BooleanType value) { 
1869          this.subsumption = value;
1870          return this;
1871        }
1872
1873        /**
1874         * @return True if subsumption is supported for this version of the code system.
1875         */
1876        public boolean getSubsumption() { 
1877          return this.subsumption == null || this.subsumption.isEmpty() ? false : this.subsumption.getValue();
1878        }
1879
1880        /**
1881         * @param value True if subsumption is supported for this version of the code system.
1882         */
1883        public TerminologyCapabilitiesCodeSystemComponent setSubsumption(boolean value) { 
1884            if (this.subsumption == null)
1885              this.subsumption = new BooleanType();
1886            this.subsumption.setValue(value);
1887          return this;
1888        }
1889
1890        protected void listChildren(List<Property> children) {
1891          super.listChildren(children);
1892          children.add(new Property("uri", "canonical(CodeSystem)", "Canonical identifier for the code system, represented as a URI.", 0, 1, uri));
1893          children.add(new Property("version", "", "For the code system, a list of versions that are supported by the server.", 0, java.lang.Integer.MAX_VALUE, version));
1894          children.add(new Property("content", "code", "The extent of the content of the code system (the concepts and codes it defines) are represented in this resource instance.", 0, 1, content));
1895          children.add(new Property("subsumption", "boolean", "True if subsumption is supported for this version of the code system.", 0, 1, subsumption));
1896        }
1897
1898        @Override
1899        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1900          switch (_hash) {
1901          case 116076: /*uri*/  return new Property("uri", "canonical(CodeSystem)", "Canonical identifier for the code system, represented as a URI.", 0, 1, uri);
1902          case 351608024: /*version*/  return new Property("version", "", "For the code system, a list of versions that are supported by the server.", 0, java.lang.Integer.MAX_VALUE, version);
1903          case 951530617: /*content*/  return new Property("content", "code", "The extent of the content of the code system (the concepts and codes it defines) are represented in this resource instance.", 0, 1, content);
1904          case -499084711: /*subsumption*/  return new Property("subsumption", "boolean", "True if subsumption is supported for this version of the code system.", 0, 1, subsumption);
1905          default: return super.getNamedProperty(_hash, _name, _checkValid);
1906          }
1907
1908        }
1909
1910      @Override
1911      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1912        switch (hash) {
1913        case 116076: /*uri*/ return this.uri == null ? new Base[0] : new Base[] {this.uri}; // CanonicalType
1914        case 351608024: /*version*/ return this.version == null ? new Base[0] : this.version.toArray(new Base[this.version.size()]); // TerminologyCapabilitiesCodeSystemVersionComponent
1915        case 951530617: /*content*/ return this.content == null ? new Base[0] : new Base[] {this.content}; // CodeType
1916        case -499084711: /*subsumption*/ return this.subsumption == null ? new Base[0] : new Base[] {this.subsumption}; // BooleanType
1917        default: return super.getProperty(hash, name, checkValid);
1918        }
1919
1920      }
1921
1922      @Override
1923      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1924        switch (hash) {
1925        case 116076: // uri
1926          this.uri = TypeConvertor.castToCanonical(value); // CanonicalType
1927          return value;
1928        case 351608024: // version
1929          this.getVersion().add((TerminologyCapabilitiesCodeSystemVersionComponent) value); // TerminologyCapabilitiesCodeSystemVersionComponent
1930          return value;
1931        case 951530617: // content
1932          this.content = TypeConvertor.castToCode(value); // CodeType
1933          return value;
1934        case -499084711: // subsumption
1935          this.subsumption = TypeConvertor.castToBoolean(value); // BooleanType
1936          return value;
1937        default: return super.setProperty(hash, name, value);
1938        }
1939
1940      }
1941
1942      @Override
1943      public Base setProperty(String name, Base value) throws FHIRException {
1944        if (name.equals("uri")) {
1945          this.uri = TypeConvertor.castToCanonical(value); // CanonicalType
1946        } else if (name.equals("version")) {
1947          this.getVersion().add((TerminologyCapabilitiesCodeSystemVersionComponent) value);
1948        } else if (name.equals("content")) {
1949          this.content = TypeConvertor.castToCode(value); // CodeType
1950        } else if (name.equals("subsumption")) {
1951          this.subsumption = TypeConvertor.castToBoolean(value); // BooleanType
1952        } else
1953          return super.setProperty(name, value);
1954        return value;
1955      }
1956
1957      @Override
1958      public Base makeProperty(int hash, String name) throws FHIRException {
1959        switch (hash) {
1960        case 116076:  return getUriElement();
1961        case 351608024:  return addVersion(); 
1962        case 951530617:  return getContentElement();
1963        case -499084711:  return getSubsumptionElement();
1964        default: return super.makeProperty(hash, name);
1965        }
1966
1967      }
1968
1969      @Override
1970      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1971        switch (hash) {
1972        case 116076: /*uri*/ return new String[] {"canonical"};
1973        case 351608024: /*version*/ return new String[] {};
1974        case 951530617: /*content*/ return new String[] {"code"};
1975        case -499084711: /*subsumption*/ return new String[] {"boolean"};
1976        default: return super.getTypesForProperty(hash, name);
1977        }
1978
1979      }
1980
1981      @Override
1982      public Base addChild(String name) throws FHIRException {
1983        if (name.equals("uri")) {
1984          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.codeSystem.uri");
1985        }
1986        else if (name.equals("version")) {
1987          return addVersion();
1988        }
1989        else if (name.equals("content")) {
1990          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.codeSystem.content");
1991        }
1992        else if (name.equals("subsumption")) {
1993          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.codeSystem.subsumption");
1994        }
1995        else
1996          return super.addChild(name);
1997      }
1998
1999      public TerminologyCapabilitiesCodeSystemComponent copy() {
2000        TerminologyCapabilitiesCodeSystemComponent dst = new TerminologyCapabilitiesCodeSystemComponent();
2001        copyValues(dst);
2002        return dst;
2003      }
2004
2005      public void copyValues(TerminologyCapabilitiesCodeSystemComponent dst) {
2006        super.copyValues(dst);
2007        dst.uri = uri == null ? null : uri.copy();
2008        if (version != null) {
2009          dst.version = new ArrayList<TerminologyCapabilitiesCodeSystemVersionComponent>();
2010          for (TerminologyCapabilitiesCodeSystemVersionComponent i : version)
2011            dst.version.add(i.copy());
2012        };
2013        dst.content = content == null ? null : content.copy();
2014        dst.subsumption = subsumption == null ? null : subsumption.copy();
2015      }
2016
2017      @Override
2018      public boolean equalsDeep(Base other_) {
2019        if (!super.equalsDeep(other_))
2020          return false;
2021        if (!(other_ instanceof TerminologyCapabilitiesCodeSystemComponent))
2022          return false;
2023        TerminologyCapabilitiesCodeSystemComponent o = (TerminologyCapabilitiesCodeSystemComponent) other_;
2024        return compareDeep(uri, o.uri, true) && compareDeep(version, o.version, true) && compareDeep(content, o.content, true)
2025           && compareDeep(subsumption, o.subsumption, true);
2026      }
2027
2028      @Override
2029      public boolean equalsShallow(Base other_) {
2030        if (!super.equalsShallow(other_))
2031          return false;
2032        if (!(other_ instanceof TerminologyCapabilitiesCodeSystemComponent))
2033          return false;
2034        TerminologyCapabilitiesCodeSystemComponent o = (TerminologyCapabilitiesCodeSystemComponent) other_;
2035        return compareValues(uri, o.uri, true) && compareValues(content, o.content, true) && compareValues(subsumption, o.subsumption, true)
2036          ;
2037      }
2038
2039      public boolean isEmpty() {
2040        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(uri, version, content, subsumption
2041          );
2042      }
2043
2044  public String fhirType() {
2045    return "TerminologyCapabilities.codeSystem";
2046
2047  }
2048
2049  }
2050
2051    @Block()
2052    public static class TerminologyCapabilitiesCodeSystemVersionComponent extends BackboneElement implements IBaseBackboneElement {
2053        /**
2054         * For version-less code systems, there should be a single version with no identifier.
2055         */
2056        @Child(name = "code", type = {StringType.class}, order=1, min=0, max=1, modifier=false, summary=true)
2057        @Description(shortDefinition="Version identifier for this version", formalDefinition="For version-less code systems, there should be a single version with no identifier." )
2058        protected StringType code;
2059
2060        /**
2061         * If this is the default version for this code system.
2062         */
2063        @Child(name = "isDefault", type = {BooleanType.class}, order=2, min=0, max=1, modifier=false, summary=true)
2064        @Description(shortDefinition="If this is the default version for this code system", formalDefinition="If this is the default version for this code system." )
2065        protected BooleanType isDefault;
2066
2067        /**
2068         * If the compositional grammar defined by the code system is supported.
2069         */
2070        @Child(name = "compositional", type = {BooleanType.class}, order=3, min=0, max=1, modifier=false, summary=false)
2071        @Description(shortDefinition="If compositional grammar is supported", formalDefinition="If the compositional grammar defined by the code system is supported." )
2072        protected BooleanType compositional;
2073
2074        /**
2075         * Language Displays supported.
2076         */
2077        @Child(name = "language", type = {CodeType.class}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2078        @Description(shortDefinition="Language Displays supported", formalDefinition="Language Displays supported." )
2079        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/languages")
2080        protected List<Enumeration<CommonLanguages>> language;
2081
2082        /**
2083         * Filter Properties supported.
2084         */
2085        @Child(name = "filter", type = {}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2086        @Description(shortDefinition="Filter Properties supported", formalDefinition="Filter Properties supported." )
2087        protected List<TerminologyCapabilitiesCodeSystemVersionFilterComponent> filter;
2088
2089        /**
2090         * Properties supported for $lookup.
2091         */
2092        @Child(name = "property", type = {CodeType.class}, order=6, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2093        @Description(shortDefinition="Properties supported for $lookup", formalDefinition="Properties supported for $lookup." )
2094        protected List<CodeType> property;
2095
2096        private static final long serialVersionUID = 658198795L;
2097
2098    /**
2099     * Constructor
2100     */
2101      public TerminologyCapabilitiesCodeSystemVersionComponent() {
2102        super();
2103      }
2104
2105        /**
2106         * @return {@link #code} (For version-less code systems, there should be a single version with no identifier.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value
2107         */
2108        public StringType getCodeElement() { 
2109          if (this.code == null)
2110            if (Configuration.errorOnAutoCreate())
2111              throw new Error("Attempt to auto-create TerminologyCapabilitiesCodeSystemVersionComponent.code");
2112            else if (Configuration.doAutoCreate())
2113              this.code = new StringType(); // bb
2114          return this.code;
2115        }
2116
2117        public boolean hasCodeElement() { 
2118          return this.code != null && !this.code.isEmpty();
2119        }
2120
2121        public boolean hasCode() { 
2122          return this.code != null && !this.code.isEmpty();
2123        }
2124
2125        /**
2126         * @param value {@link #code} (For version-less code systems, there should be a single version with no identifier.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value
2127         */
2128        public TerminologyCapabilitiesCodeSystemVersionComponent setCodeElement(StringType value) { 
2129          this.code = value;
2130          return this;
2131        }
2132
2133        /**
2134         * @return For version-less code systems, there should be a single version with no identifier.
2135         */
2136        public String getCode() { 
2137          return this.code == null ? null : this.code.getValue();
2138        }
2139
2140        /**
2141         * @param value For version-less code systems, there should be a single version with no identifier.
2142         */
2143        public TerminologyCapabilitiesCodeSystemVersionComponent setCode(String value) { 
2144          if (Utilities.noString(value))
2145            this.code = null;
2146          else {
2147            if (this.code == null)
2148              this.code = new StringType();
2149            this.code.setValue(value);
2150          }
2151          return this;
2152        }
2153
2154        /**
2155         * @return {@link #isDefault} (If this is the default version for this code system.). This is the underlying object with id, value and extensions. The accessor "getIsDefault" gives direct access to the value
2156         */
2157        public BooleanType getIsDefaultElement() { 
2158          if (this.isDefault == null)
2159            if (Configuration.errorOnAutoCreate())
2160              throw new Error("Attempt to auto-create TerminologyCapabilitiesCodeSystemVersionComponent.isDefault");
2161            else if (Configuration.doAutoCreate())
2162              this.isDefault = new BooleanType(); // bb
2163          return this.isDefault;
2164        }
2165
2166        public boolean hasIsDefaultElement() { 
2167          return this.isDefault != null && !this.isDefault.isEmpty();
2168        }
2169
2170        public boolean hasIsDefault() { 
2171          return this.isDefault != null && !this.isDefault.isEmpty();
2172        }
2173
2174        /**
2175         * @param value {@link #isDefault} (If this is the default version for this code system.). This is the underlying object with id, value and extensions. The accessor "getIsDefault" gives direct access to the value
2176         */
2177        public TerminologyCapabilitiesCodeSystemVersionComponent setIsDefaultElement(BooleanType value) { 
2178          this.isDefault = value;
2179          return this;
2180        }
2181
2182        /**
2183         * @return If this is the default version for this code system.
2184         */
2185        public boolean getIsDefault() { 
2186          return this.isDefault == null || this.isDefault.isEmpty() ? false : this.isDefault.getValue();
2187        }
2188
2189        /**
2190         * @param value If this is the default version for this code system.
2191         */
2192        public TerminologyCapabilitiesCodeSystemVersionComponent setIsDefault(boolean value) { 
2193            if (this.isDefault == null)
2194              this.isDefault = new BooleanType();
2195            this.isDefault.setValue(value);
2196          return this;
2197        }
2198
2199        /**
2200         * @return {@link #compositional} (If the compositional grammar defined by the code system is supported.). This is the underlying object with id, value and extensions. The accessor "getCompositional" gives direct access to the value
2201         */
2202        public BooleanType getCompositionalElement() { 
2203          if (this.compositional == null)
2204            if (Configuration.errorOnAutoCreate())
2205              throw new Error("Attempt to auto-create TerminologyCapabilitiesCodeSystemVersionComponent.compositional");
2206            else if (Configuration.doAutoCreate())
2207              this.compositional = new BooleanType(); // bb
2208          return this.compositional;
2209        }
2210
2211        public boolean hasCompositionalElement() { 
2212          return this.compositional != null && !this.compositional.isEmpty();
2213        }
2214
2215        public boolean hasCompositional() { 
2216          return this.compositional != null && !this.compositional.isEmpty();
2217        }
2218
2219        /**
2220         * @param value {@link #compositional} (If the compositional grammar defined by the code system is supported.). This is the underlying object with id, value and extensions. The accessor "getCompositional" gives direct access to the value
2221         */
2222        public TerminologyCapabilitiesCodeSystemVersionComponent setCompositionalElement(BooleanType value) { 
2223          this.compositional = value;
2224          return this;
2225        }
2226
2227        /**
2228         * @return If the compositional grammar defined by the code system is supported.
2229         */
2230        public boolean getCompositional() { 
2231          return this.compositional == null || this.compositional.isEmpty() ? false : this.compositional.getValue();
2232        }
2233
2234        /**
2235         * @param value If the compositional grammar defined by the code system is supported.
2236         */
2237        public TerminologyCapabilitiesCodeSystemVersionComponent setCompositional(boolean value) { 
2238            if (this.compositional == null)
2239              this.compositional = new BooleanType();
2240            this.compositional.setValue(value);
2241          return this;
2242        }
2243
2244        /**
2245         * @return {@link #language} (Language Displays supported.)
2246         */
2247        public List<Enumeration<CommonLanguages>> getLanguage() { 
2248          if (this.language == null)
2249            this.language = new ArrayList<Enumeration<CommonLanguages>>();
2250          return this.language;
2251        }
2252
2253        /**
2254         * @return Returns a reference to <code>this</code> for easy method chaining
2255         */
2256        public TerminologyCapabilitiesCodeSystemVersionComponent setLanguage(List<Enumeration<CommonLanguages>> theLanguage) { 
2257          this.language = theLanguage;
2258          return this;
2259        }
2260
2261        public boolean hasLanguage() { 
2262          if (this.language == null)
2263            return false;
2264          for (Enumeration<CommonLanguages> item : this.language)
2265            if (!item.isEmpty())
2266              return true;
2267          return false;
2268        }
2269
2270        /**
2271         * @return {@link #language} (Language Displays supported.)
2272         */
2273        public Enumeration<CommonLanguages> addLanguageElement() {//2 
2274          Enumeration<CommonLanguages> t = new Enumeration<CommonLanguages>(new CommonLanguagesEnumFactory());
2275          if (this.language == null)
2276            this.language = new ArrayList<Enumeration<CommonLanguages>>();
2277          this.language.add(t);
2278          return t;
2279        }
2280
2281        /**
2282         * @param value {@link #language} (Language Displays supported.)
2283         */
2284        public TerminologyCapabilitiesCodeSystemVersionComponent addLanguage(CommonLanguages value) { //1
2285          Enumeration<CommonLanguages> t = new Enumeration<CommonLanguages>(new CommonLanguagesEnumFactory());
2286          t.setValue(value);
2287          if (this.language == null)
2288            this.language = new ArrayList<Enumeration<CommonLanguages>>();
2289          this.language.add(t);
2290          return this;
2291        }
2292
2293        /**
2294         * @param value {@link #language} (Language Displays supported.)
2295         */
2296        public boolean hasLanguage(CommonLanguages value) { 
2297          if (this.language == null)
2298            return false;
2299          for (Enumeration<CommonLanguages> v : this.language)
2300            if (v.getValue().equals(value)) // code
2301              return true;
2302          return false;
2303        }
2304
2305        /**
2306         * @return {@link #filter} (Filter Properties supported.)
2307         */
2308        public List<TerminologyCapabilitiesCodeSystemVersionFilterComponent> getFilter() { 
2309          if (this.filter == null)
2310            this.filter = new ArrayList<TerminologyCapabilitiesCodeSystemVersionFilterComponent>();
2311          return this.filter;
2312        }
2313
2314        /**
2315         * @return Returns a reference to <code>this</code> for easy method chaining
2316         */
2317        public TerminologyCapabilitiesCodeSystemVersionComponent setFilter(List<TerminologyCapabilitiesCodeSystemVersionFilterComponent> theFilter) { 
2318          this.filter = theFilter;
2319          return this;
2320        }
2321
2322        public boolean hasFilter() { 
2323          if (this.filter == null)
2324            return false;
2325          for (TerminologyCapabilitiesCodeSystemVersionFilterComponent item : this.filter)
2326            if (!item.isEmpty())
2327              return true;
2328          return false;
2329        }
2330
2331        public TerminologyCapabilitiesCodeSystemVersionFilterComponent addFilter() { //3
2332          TerminologyCapabilitiesCodeSystemVersionFilterComponent t = new TerminologyCapabilitiesCodeSystemVersionFilterComponent();
2333          if (this.filter == null)
2334            this.filter = new ArrayList<TerminologyCapabilitiesCodeSystemVersionFilterComponent>();
2335          this.filter.add(t);
2336          return t;
2337        }
2338
2339        public TerminologyCapabilitiesCodeSystemVersionComponent addFilter(TerminologyCapabilitiesCodeSystemVersionFilterComponent t) { //3
2340          if (t == null)
2341            return this;
2342          if (this.filter == null)
2343            this.filter = new ArrayList<TerminologyCapabilitiesCodeSystemVersionFilterComponent>();
2344          this.filter.add(t);
2345          return this;
2346        }
2347
2348        /**
2349         * @return The first repetition of repeating field {@link #filter}, creating it if it does not already exist {3}
2350         */
2351        public TerminologyCapabilitiesCodeSystemVersionFilterComponent getFilterFirstRep() { 
2352          if (getFilter().isEmpty()) {
2353            addFilter();
2354          }
2355          return getFilter().get(0);
2356        }
2357
2358        /**
2359         * @return {@link #property} (Properties supported for $lookup.)
2360         */
2361        public List<CodeType> getProperty() { 
2362          if (this.property == null)
2363            this.property = new ArrayList<CodeType>();
2364          return this.property;
2365        }
2366
2367        /**
2368         * @return Returns a reference to <code>this</code> for easy method chaining
2369         */
2370        public TerminologyCapabilitiesCodeSystemVersionComponent setProperty(List<CodeType> theProperty) { 
2371          this.property = theProperty;
2372          return this;
2373        }
2374
2375        public boolean hasProperty() { 
2376          if (this.property == null)
2377            return false;
2378          for (CodeType item : this.property)
2379            if (!item.isEmpty())
2380              return true;
2381          return false;
2382        }
2383
2384        /**
2385         * @return {@link #property} (Properties supported for $lookup.)
2386         */
2387        public CodeType addPropertyElement() {//2 
2388          CodeType t = new CodeType();
2389          if (this.property == null)
2390            this.property = new ArrayList<CodeType>();
2391          this.property.add(t);
2392          return t;
2393        }
2394
2395        /**
2396         * @param value {@link #property} (Properties supported for $lookup.)
2397         */
2398        public TerminologyCapabilitiesCodeSystemVersionComponent addProperty(String value) { //1
2399          CodeType t = new CodeType();
2400          t.setValue(value);
2401          if (this.property == null)
2402            this.property = new ArrayList<CodeType>();
2403          this.property.add(t);
2404          return this;
2405        }
2406
2407        /**
2408         * @param value {@link #property} (Properties supported for $lookup.)
2409         */
2410        public boolean hasProperty(String value) { 
2411          if (this.property == null)
2412            return false;
2413          for (CodeType v : this.property)
2414            if (v.getValue().equals(value)) // code
2415              return true;
2416          return false;
2417        }
2418
2419        protected void listChildren(List<Property> children) {
2420          super.listChildren(children);
2421          children.add(new Property("code", "string", "For version-less code systems, there should be a single version with no identifier.", 0, 1, code));
2422          children.add(new Property("isDefault", "boolean", "If this is the default version for this code system.", 0, 1, isDefault));
2423          children.add(new Property("compositional", "boolean", "If the compositional grammar defined by the code system is supported.", 0, 1, compositional));
2424          children.add(new Property("language", "code", "Language Displays supported.", 0, java.lang.Integer.MAX_VALUE, language));
2425          children.add(new Property("filter", "", "Filter Properties supported.", 0, java.lang.Integer.MAX_VALUE, filter));
2426          children.add(new Property("property", "code", "Properties supported for $lookup.", 0, java.lang.Integer.MAX_VALUE, property));
2427        }
2428
2429        @Override
2430        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2431          switch (_hash) {
2432          case 3059181: /*code*/  return new Property("code", "string", "For version-less code systems, there should be a single version with no identifier.", 0, 1, code);
2433          case 965025207: /*isDefault*/  return new Property("isDefault", "boolean", "If this is the default version for this code system.", 0, 1, isDefault);
2434          case 1248023381: /*compositional*/  return new Property("compositional", "boolean", "If the compositional grammar defined by the code system is supported.", 0, 1, compositional);
2435          case -1613589672: /*language*/  return new Property("language", "code", "Language Displays supported.", 0, java.lang.Integer.MAX_VALUE, language);
2436          case -1274492040: /*filter*/  return new Property("filter", "", "Filter Properties supported.", 0, java.lang.Integer.MAX_VALUE, filter);
2437          case -993141291: /*property*/  return new Property("property", "code", "Properties supported for $lookup.", 0, java.lang.Integer.MAX_VALUE, property);
2438          default: return super.getNamedProperty(_hash, _name, _checkValid);
2439          }
2440
2441        }
2442
2443      @Override
2444      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2445        switch (hash) {
2446        case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // StringType
2447        case 965025207: /*isDefault*/ return this.isDefault == null ? new Base[0] : new Base[] {this.isDefault}; // BooleanType
2448        case 1248023381: /*compositional*/ return this.compositional == null ? new Base[0] : new Base[] {this.compositional}; // BooleanType
2449        case -1613589672: /*language*/ return this.language == null ? new Base[0] : this.language.toArray(new Base[this.language.size()]); // Enumeration<CommonLanguages>
2450        case -1274492040: /*filter*/ return this.filter == null ? new Base[0] : this.filter.toArray(new Base[this.filter.size()]); // TerminologyCapabilitiesCodeSystemVersionFilterComponent
2451        case -993141291: /*property*/ return this.property == null ? new Base[0] : this.property.toArray(new Base[this.property.size()]); // CodeType
2452        default: return super.getProperty(hash, name, checkValid);
2453        }
2454
2455      }
2456
2457      @Override
2458      public Base setProperty(int hash, String name, Base value) throws FHIRException {
2459        switch (hash) {
2460        case 3059181: // code
2461          this.code = TypeConvertor.castToString(value); // StringType
2462          return value;
2463        case 965025207: // isDefault
2464          this.isDefault = TypeConvertor.castToBoolean(value); // BooleanType
2465          return value;
2466        case 1248023381: // compositional
2467          this.compositional = TypeConvertor.castToBoolean(value); // BooleanType
2468          return value;
2469        case -1613589672: // language
2470          value = new CommonLanguagesEnumFactory().fromType(TypeConvertor.castToCode(value));
2471          this.getLanguage().add((Enumeration) value); // Enumeration<CommonLanguages>
2472          return value;
2473        case -1274492040: // filter
2474          this.getFilter().add((TerminologyCapabilitiesCodeSystemVersionFilterComponent) value); // TerminologyCapabilitiesCodeSystemVersionFilterComponent
2475          return value;
2476        case -993141291: // property
2477          this.getProperty().add(TypeConvertor.castToCode(value)); // CodeType
2478          return value;
2479        default: return super.setProperty(hash, name, value);
2480        }
2481
2482      }
2483
2484      @Override
2485      public Base setProperty(String name, Base value) throws FHIRException {
2486        if (name.equals("code")) {
2487          this.code = TypeConvertor.castToString(value); // StringType
2488        } else if (name.equals("isDefault")) {
2489          this.isDefault = TypeConvertor.castToBoolean(value); // BooleanType
2490        } else if (name.equals("compositional")) {
2491          this.compositional = TypeConvertor.castToBoolean(value); // BooleanType
2492        } else if (name.equals("language")) {
2493          value = new CommonLanguagesEnumFactory().fromType(TypeConvertor.castToCode(value));
2494          this.getLanguage().add((Enumeration) value);
2495        } else if (name.equals("filter")) {
2496          this.getFilter().add((TerminologyCapabilitiesCodeSystemVersionFilterComponent) value);
2497        } else if (name.equals("property")) {
2498          this.getProperty().add(TypeConvertor.castToCode(value));
2499        } else
2500          return super.setProperty(name, value);
2501        return value;
2502      }
2503
2504      @Override
2505      public Base makeProperty(int hash, String name) throws FHIRException {
2506        switch (hash) {
2507        case 3059181:  return getCodeElement();
2508        case 965025207:  return getIsDefaultElement();
2509        case 1248023381:  return getCompositionalElement();
2510        case -1613589672:  return addLanguageElement();
2511        case -1274492040:  return addFilter(); 
2512        case -993141291:  return addPropertyElement();
2513        default: return super.makeProperty(hash, name);
2514        }
2515
2516      }
2517
2518      @Override
2519      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2520        switch (hash) {
2521        case 3059181: /*code*/ return new String[] {"string"};
2522        case 965025207: /*isDefault*/ return new String[] {"boolean"};
2523        case 1248023381: /*compositional*/ return new String[] {"boolean"};
2524        case -1613589672: /*language*/ return new String[] {"code"};
2525        case -1274492040: /*filter*/ return new String[] {};
2526        case -993141291: /*property*/ return new String[] {"code"};
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("code")) {
2535          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.codeSystem.version.code");
2536        }
2537        else if (name.equals("isDefault")) {
2538          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.codeSystem.version.isDefault");
2539        }
2540        else if (name.equals("compositional")) {
2541          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.codeSystem.version.compositional");
2542        }
2543        else if (name.equals("language")) {
2544          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.codeSystem.version.language");
2545        }
2546        else if (name.equals("filter")) {
2547          return addFilter();
2548        }
2549        else if (name.equals("property")) {
2550          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.codeSystem.version.property");
2551        }
2552        else
2553          return super.addChild(name);
2554      }
2555
2556      public TerminologyCapabilitiesCodeSystemVersionComponent copy() {
2557        TerminologyCapabilitiesCodeSystemVersionComponent dst = new TerminologyCapabilitiesCodeSystemVersionComponent();
2558        copyValues(dst);
2559        return dst;
2560      }
2561
2562      public void copyValues(TerminologyCapabilitiesCodeSystemVersionComponent dst) {
2563        super.copyValues(dst);
2564        dst.code = code == null ? null : code.copy();
2565        dst.isDefault = isDefault == null ? null : isDefault.copy();
2566        dst.compositional = compositional == null ? null : compositional.copy();
2567        if (language != null) {
2568          dst.language = new ArrayList<Enumeration<CommonLanguages>>();
2569          for (Enumeration<CommonLanguages> i : language)
2570            dst.language.add(i.copy());
2571        };
2572        if (filter != null) {
2573          dst.filter = new ArrayList<TerminologyCapabilitiesCodeSystemVersionFilterComponent>();
2574          for (TerminologyCapabilitiesCodeSystemVersionFilterComponent i : filter)
2575            dst.filter.add(i.copy());
2576        };
2577        if (property != null) {
2578          dst.property = new ArrayList<CodeType>();
2579          for (CodeType i : property)
2580            dst.property.add(i.copy());
2581        };
2582      }
2583
2584      @Override
2585      public boolean equalsDeep(Base other_) {
2586        if (!super.equalsDeep(other_))
2587          return false;
2588        if (!(other_ instanceof TerminologyCapabilitiesCodeSystemVersionComponent))
2589          return false;
2590        TerminologyCapabilitiesCodeSystemVersionComponent o = (TerminologyCapabilitiesCodeSystemVersionComponent) other_;
2591        return compareDeep(code, o.code, true) && compareDeep(isDefault, o.isDefault, true) && compareDeep(compositional, o.compositional, true)
2592           && compareDeep(language, o.language, true) && compareDeep(filter, o.filter, true) && compareDeep(property, o.property, true)
2593          ;
2594      }
2595
2596      @Override
2597      public boolean equalsShallow(Base other_) {
2598        if (!super.equalsShallow(other_))
2599          return false;
2600        if (!(other_ instanceof TerminologyCapabilitiesCodeSystemVersionComponent))
2601          return false;
2602        TerminologyCapabilitiesCodeSystemVersionComponent o = (TerminologyCapabilitiesCodeSystemVersionComponent) other_;
2603        return compareValues(code, o.code, true) && compareValues(isDefault, o.isDefault, true) && compareValues(compositional, o.compositional, true)
2604           && compareValues(language, o.language, true) && compareValues(property, o.property, true);
2605      }
2606
2607      public boolean isEmpty() {
2608        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, isDefault, compositional
2609          , language, filter, property);
2610      }
2611
2612  public String fhirType() {
2613    return "TerminologyCapabilities.codeSystem.version";
2614
2615  }
2616
2617  }
2618
2619    @Block()
2620    public static class TerminologyCapabilitiesCodeSystemVersionFilterComponent extends BackboneElement implements IBaseBackboneElement {
2621        /**
2622         * Code of the property supported.
2623         */
2624        @Child(name = "code", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=false)
2625        @Description(shortDefinition="Code of the property supported", formalDefinition="Code of the property supported." )
2626        protected CodeType code;
2627
2628        /**
2629         * Operations supported for the property.
2630         */
2631        @Child(name = "op", type = {CodeType.class}, order=2, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2632        @Description(shortDefinition="Operations supported for the property", formalDefinition="Operations supported for the property." )
2633        protected List<CodeType> op;
2634
2635        private static final long serialVersionUID = -489160282L;
2636
2637    /**
2638     * Constructor
2639     */
2640      public TerminologyCapabilitiesCodeSystemVersionFilterComponent() {
2641        super();
2642      }
2643
2644    /**
2645     * Constructor
2646     */
2647      public TerminologyCapabilitiesCodeSystemVersionFilterComponent(String code, String op) {
2648        super();
2649        this.setCode(code);
2650        this.addOp(op);
2651      }
2652
2653        /**
2654         * @return {@link #code} (Code of the property supported.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value
2655         */
2656        public CodeType getCodeElement() { 
2657          if (this.code == null)
2658            if (Configuration.errorOnAutoCreate())
2659              throw new Error("Attempt to auto-create TerminologyCapabilitiesCodeSystemVersionFilterComponent.code");
2660            else if (Configuration.doAutoCreate())
2661              this.code = new CodeType(); // bb
2662          return this.code;
2663        }
2664
2665        public boolean hasCodeElement() { 
2666          return this.code != null && !this.code.isEmpty();
2667        }
2668
2669        public boolean hasCode() { 
2670          return this.code != null && !this.code.isEmpty();
2671        }
2672
2673        /**
2674         * @param value {@link #code} (Code of the property supported.). This is the underlying object with id, value and extensions. The accessor "getCode" gives direct access to the value
2675         */
2676        public TerminologyCapabilitiesCodeSystemVersionFilterComponent setCodeElement(CodeType value) { 
2677          this.code = value;
2678          return this;
2679        }
2680
2681        /**
2682         * @return Code of the property supported.
2683         */
2684        public String getCode() { 
2685          return this.code == null ? null : this.code.getValue();
2686        }
2687
2688        /**
2689         * @param value Code of the property supported.
2690         */
2691        public TerminologyCapabilitiesCodeSystemVersionFilterComponent setCode(String value) { 
2692            if (this.code == null)
2693              this.code = new CodeType();
2694            this.code.setValue(value);
2695          return this;
2696        }
2697
2698        /**
2699         * @return {@link #op} (Operations supported for the property.)
2700         */
2701        public List<CodeType> getOp() { 
2702          if (this.op == null)
2703            this.op = new ArrayList<CodeType>();
2704          return this.op;
2705        }
2706
2707        /**
2708         * @return Returns a reference to <code>this</code> for easy method chaining
2709         */
2710        public TerminologyCapabilitiesCodeSystemVersionFilterComponent setOp(List<CodeType> theOp) { 
2711          this.op = theOp;
2712          return this;
2713        }
2714
2715        public boolean hasOp() { 
2716          if (this.op == null)
2717            return false;
2718          for (CodeType item : this.op)
2719            if (!item.isEmpty())
2720              return true;
2721          return false;
2722        }
2723
2724        /**
2725         * @return {@link #op} (Operations supported for the property.)
2726         */
2727        public CodeType addOpElement() {//2 
2728          CodeType t = new CodeType();
2729          if (this.op == null)
2730            this.op = new ArrayList<CodeType>();
2731          this.op.add(t);
2732          return t;
2733        }
2734
2735        /**
2736         * @param value {@link #op} (Operations supported for the property.)
2737         */
2738        public TerminologyCapabilitiesCodeSystemVersionFilterComponent addOp(String value) { //1
2739          CodeType t = new CodeType();
2740          t.setValue(value);
2741          if (this.op == null)
2742            this.op = new ArrayList<CodeType>();
2743          this.op.add(t);
2744          return this;
2745        }
2746
2747        /**
2748         * @param value {@link #op} (Operations supported for the property.)
2749         */
2750        public boolean hasOp(String value) { 
2751          if (this.op == null)
2752            return false;
2753          for (CodeType v : this.op)
2754            if (v.getValue().equals(value)) // code
2755              return true;
2756          return false;
2757        }
2758
2759        protected void listChildren(List<Property> children) {
2760          super.listChildren(children);
2761          children.add(new Property("code", "code", "Code of the property supported.", 0, 1, code));
2762          children.add(new Property("op", "code", "Operations supported for the property.", 0, java.lang.Integer.MAX_VALUE, op));
2763        }
2764
2765        @Override
2766        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2767          switch (_hash) {
2768          case 3059181: /*code*/  return new Property("code", "code", "Code of the property supported.", 0, 1, code);
2769          case 3553: /*op*/  return new Property("op", "code", "Operations supported for the property.", 0, java.lang.Integer.MAX_VALUE, op);
2770          default: return super.getNamedProperty(_hash, _name, _checkValid);
2771          }
2772
2773        }
2774
2775      @Override
2776      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2777        switch (hash) {
2778        case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // CodeType
2779        case 3553: /*op*/ return this.op == null ? new Base[0] : this.op.toArray(new Base[this.op.size()]); // CodeType
2780        default: return super.getProperty(hash, name, checkValid);
2781        }
2782
2783      }
2784
2785      @Override
2786      public Base setProperty(int hash, String name, Base value) throws FHIRException {
2787        switch (hash) {
2788        case 3059181: // code
2789          this.code = TypeConvertor.castToCode(value); // CodeType
2790          return value;
2791        case 3553: // op
2792          this.getOp().add(TypeConvertor.castToCode(value)); // CodeType
2793          return value;
2794        default: return super.setProperty(hash, name, value);
2795        }
2796
2797      }
2798
2799      @Override
2800      public Base setProperty(String name, Base value) throws FHIRException {
2801        if (name.equals("code")) {
2802          this.code = TypeConvertor.castToCode(value); // CodeType
2803        } else if (name.equals("op")) {
2804          this.getOp().add(TypeConvertor.castToCode(value));
2805        } else
2806          return super.setProperty(name, value);
2807        return value;
2808      }
2809
2810      @Override
2811      public Base makeProperty(int hash, String name) throws FHIRException {
2812        switch (hash) {
2813        case 3059181:  return getCodeElement();
2814        case 3553:  return addOpElement();
2815        default: return super.makeProperty(hash, name);
2816        }
2817
2818      }
2819
2820      @Override
2821      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2822        switch (hash) {
2823        case 3059181: /*code*/ return new String[] {"code"};
2824        case 3553: /*op*/ return new String[] {"code"};
2825        default: return super.getTypesForProperty(hash, name);
2826        }
2827
2828      }
2829
2830      @Override
2831      public Base addChild(String name) throws FHIRException {
2832        if (name.equals("code")) {
2833          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.codeSystem.version.filter.code");
2834        }
2835        else if (name.equals("op")) {
2836          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.codeSystem.version.filter.op");
2837        }
2838        else
2839          return super.addChild(name);
2840      }
2841
2842      public TerminologyCapabilitiesCodeSystemVersionFilterComponent copy() {
2843        TerminologyCapabilitiesCodeSystemVersionFilterComponent dst = new TerminologyCapabilitiesCodeSystemVersionFilterComponent();
2844        copyValues(dst);
2845        return dst;
2846      }
2847
2848      public void copyValues(TerminologyCapabilitiesCodeSystemVersionFilterComponent dst) {
2849        super.copyValues(dst);
2850        dst.code = code == null ? null : code.copy();
2851        if (op != null) {
2852          dst.op = new ArrayList<CodeType>();
2853          for (CodeType i : op)
2854            dst.op.add(i.copy());
2855        };
2856      }
2857
2858      @Override
2859      public boolean equalsDeep(Base other_) {
2860        if (!super.equalsDeep(other_))
2861          return false;
2862        if (!(other_ instanceof TerminologyCapabilitiesCodeSystemVersionFilterComponent))
2863          return false;
2864        TerminologyCapabilitiesCodeSystemVersionFilterComponent o = (TerminologyCapabilitiesCodeSystemVersionFilterComponent) other_;
2865        return compareDeep(code, o.code, true) && compareDeep(op, o.op, true);
2866      }
2867
2868      @Override
2869      public boolean equalsShallow(Base other_) {
2870        if (!super.equalsShallow(other_))
2871          return false;
2872        if (!(other_ instanceof TerminologyCapabilitiesCodeSystemVersionFilterComponent))
2873          return false;
2874        TerminologyCapabilitiesCodeSystemVersionFilterComponent o = (TerminologyCapabilitiesCodeSystemVersionFilterComponent) other_;
2875        return compareValues(code, o.code, true) && compareValues(op, o.op, true);
2876      }
2877
2878      public boolean isEmpty() {
2879        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(code, op);
2880      }
2881
2882  public String fhirType() {
2883    return "TerminologyCapabilities.codeSystem.version.filter";
2884
2885  }
2886
2887  }
2888
2889    @Block()
2890    public static class TerminologyCapabilitiesExpansionComponent extends BackboneElement implements IBaseBackboneElement {
2891        /**
2892         * Whether the server can return nested value sets.
2893         */
2894        @Child(name = "hierarchical", type = {BooleanType.class}, order=1, min=0, max=1, modifier=false, summary=false)
2895        @Description(shortDefinition="Whether the server can return nested value sets", formalDefinition="Whether the server can return nested value sets." )
2896        protected BooleanType hierarchical;
2897
2898        /**
2899         * Whether the server supports paging on expansion.
2900         */
2901        @Child(name = "paging", type = {BooleanType.class}, order=2, min=0, max=1, modifier=false, summary=false)
2902        @Description(shortDefinition="Whether the server supports paging on expansion", formalDefinition="Whether the server supports paging on expansion." )
2903        protected BooleanType paging;
2904
2905        /**
2906         * True if requests for incomplete expansions are allowed.
2907         */
2908        @Child(name = "incomplete", type = {BooleanType.class}, order=3, min=0, max=1, modifier=false, summary=false)
2909        @Description(shortDefinition="Allow request for incomplete expansions?", formalDefinition="True if requests for incomplete expansions are allowed." )
2910        protected BooleanType incomplete;
2911
2912        /**
2913         * Supported expansion parameter.
2914         */
2915        @Child(name = "parameter", type = {}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2916        @Description(shortDefinition="Supported expansion parameter", formalDefinition="Supported expansion parameter." )
2917        protected List<TerminologyCapabilitiesExpansionParameterComponent> parameter;
2918
2919        /**
2920         * Documentation about text searching works.
2921         */
2922        @Child(name = "textFilter", type = {MarkdownType.class}, order=5, min=0, max=1, modifier=false, summary=false)
2923        @Description(shortDefinition="Documentation about text searching works", formalDefinition="Documentation about text searching works." )
2924        protected MarkdownType textFilter;
2925
2926        private static final long serialVersionUID = -1011350616L;
2927
2928    /**
2929     * Constructor
2930     */
2931      public TerminologyCapabilitiesExpansionComponent() {
2932        super();
2933      }
2934
2935        /**
2936         * @return {@link #hierarchical} (Whether the server can return nested value sets.). This is the underlying object with id, value and extensions. The accessor "getHierarchical" gives direct access to the value
2937         */
2938        public BooleanType getHierarchicalElement() { 
2939          if (this.hierarchical == null)
2940            if (Configuration.errorOnAutoCreate())
2941              throw new Error("Attempt to auto-create TerminologyCapabilitiesExpansionComponent.hierarchical");
2942            else if (Configuration.doAutoCreate())
2943              this.hierarchical = new BooleanType(); // bb
2944          return this.hierarchical;
2945        }
2946
2947        public boolean hasHierarchicalElement() { 
2948          return this.hierarchical != null && !this.hierarchical.isEmpty();
2949        }
2950
2951        public boolean hasHierarchical() { 
2952          return this.hierarchical != null && !this.hierarchical.isEmpty();
2953        }
2954
2955        /**
2956         * @param value {@link #hierarchical} (Whether the server can return nested value sets.). This is the underlying object with id, value and extensions. The accessor "getHierarchical" gives direct access to the value
2957         */
2958        public TerminologyCapabilitiesExpansionComponent setHierarchicalElement(BooleanType value) { 
2959          this.hierarchical = value;
2960          return this;
2961        }
2962
2963        /**
2964         * @return Whether the server can return nested value sets.
2965         */
2966        public boolean getHierarchical() { 
2967          return this.hierarchical == null || this.hierarchical.isEmpty() ? false : this.hierarchical.getValue();
2968        }
2969
2970        /**
2971         * @param value Whether the server can return nested value sets.
2972         */
2973        public TerminologyCapabilitiesExpansionComponent setHierarchical(boolean value) { 
2974            if (this.hierarchical == null)
2975              this.hierarchical = new BooleanType();
2976            this.hierarchical.setValue(value);
2977          return this;
2978        }
2979
2980        /**
2981         * @return {@link #paging} (Whether the server supports paging on expansion.). This is the underlying object with id, value and extensions. The accessor "getPaging" gives direct access to the value
2982         */
2983        public BooleanType getPagingElement() { 
2984          if (this.paging == null)
2985            if (Configuration.errorOnAutoCreate())
2986              throw new Error("Attempt to auto-create TerminologyCapabilitiesExpansionComponent.paging");
2987            else if (Configuration.doAutoCreate())
2988              this.paging = new BooleanType(); // bb
2989          return this.paging;
2990        }
2991
2992        public boolean hasPagingElement() { 
2993          return this.paging != null && !this.paging.isEmpty();
2994        }
2995
2996        public boolean hasPaging() { 
2997          return this.paging != null && !this.paging.isEmpty();
2998        }
2999
3000        /**
3001         * @param value {@link #paging} (Whether the server supports paging on expansion.). This is the underlying object with id, value and extensions. The accessor "getPaging" gives direct access to the value
3002         */
3003        public TerminologyCapabilitiesExpansionComponent setPagingElement(BooleanType value) { 
3004          this.paging = value;
3005          return this;
3006        }
3007
3008        /**
3009         * @return Whether the server supports paging on expansion.
3010         */
3011        public boolean getPaging() { 
3012          return this.paging == null || this.paging.isEmpty() ? false : this.paging.getValue();
3013        }
3014
3015        /**
3016         * @param value Whether the server supports paging on expansion.
3017         */
3018        public TerminologyCapabilitiesExpansionComponent setPaging(boolean value) { 
3019            if (this.paging == null)
3020              this.paging = new BooleanType();
3021            this.paging.setValue(value);
3022          return this;
3023        }
3024
3025        /**
3026         * @return {@link #incomplete} (True if requests for incomplete expansions are allowed.). This is the underlying object with id, value and extensions. The accessor "getIncomplete" gives direct access to the value
3027         */
3028        public BooleanType getIncompleteElement() { 
3029          if (this.incomplete == null)
3030            if (Configuration.errorOnAutoCreate())
3031              throw new Error("Attempt to auto-create TerminologyCapabilitiesExpansionComponent.incomplete");
3032            else if (Configuration.doAutoCreate())
3033              this.incomplete = new BooleanType(); // bb
3034          return this.incomplete;
3035        }
3036
3037        public boolean hasIncompleteElement() { 
3038          return this.incomplete != null && !this.incomplete.isEmpty();
3039        }
3040
3041        public boolean hasIncomplete() { 
3042          return this.incomplete != null && !this.incomplete.isEmpty();
3043        }
3044
3045        /**
3046         * @param value {@link #incomplete} (True if requests for incomplete expansions are allowed.). This is the underlying object with id, value and extensions. The accessor "getIncomplete" gives direct access to the value
3047         */
3048        public TerminologyCapabilitiesExpansionComponent setIncompleteElement(BooleanType value) { 
3049          this.incomplete = value;
3050          return this;
3051        }
3052
3053        /**
3054         * @return True if requests for incomplete expansions are allowed.
3055         */
3056        public boolean getIncomplete() { 
3057          return this.incomplete == null || this.incomplete.isEmpty() ? false : this.incomplete.getValue();
3058        }
3059
3060        /**
3061         * @param value True if requests for incomplete expansions are allowed.
3062         */
3063        public TerminologyCapabilitiesExpansionComponent setIncomplete(boolean value) { 
3064            if (this.incomplete == null)
3065              this.incomplete = new BooleanType();
3066            this.incomplete.setValue(value);
3067          return this;
3068        }
3069
3070        /**
3071         * @return {@link #parameter} (Supported expansion parameter.)
3072         */
3073        public List<TerminologyCapabilitiesExpansionParameterComponent> getParameter() { 
3074          if (this.parameter == null)
3075            this.parameter = new ArrayList<TerminologyCapabilitiesExpansionParameterComponent>();
3076          return this.parameter;
3077        }
3078
3079        /**
3080         * @return Returns a reference to <code>this</code> for easy method chaining
3081         */
3082        public TerminologyCapabilitiesExpansionComponent setParameter(List<TerminologyCapabilitiesExpansionParameterComponent> theParameter) { 
3083          this.parameter = theParameter;
3084          return this;
3085        }
3086
3087        public boolean hasParameter() { 
3088          if (this.parameter == null)
3089            return false;
3090          for (TerminologyCapabilitiesExpansionParameterComponent item : this.parameter)
3091            if (!item.isEmpty())
3092              return true;
3093          return false;
3094        }
3095
3096        public TerminologyCapabilitiesExpansionParameterComponent addParameter() { //3
3097          TerminologyCapabilitiesExpansionParameterComponent t = new TerminologyCapabilitiesExpansionParameterComponent();
3098          if (this.parameter == null)
3099            this.parameter = new ArrayList<TerminologyCapabilitiesExpansionParameterComponent>();
3100          this.parameter.add(t);
3101          return t;
3102        }
3103
3104        public TerminologyCapabilitiesExpansionComponent addParameter(TerminologyCapabilitiesExpansionParameterComponent t) { //3
3105          if (t == null)
3106            return this;
3107          if (this.parameter == null)
3108            this.parameter = new ArrayList<TerminologyCapabilitiesExpansionParameterComponent>();
3109          this.parameter.add(t);
3110          return this;
3111        }
3112
3113        /**
3114         * @return The first repetition of repeating field {@link #parameter}, creating it if it does not already exist {3}
3115         */
3116        public TerminologyCapabilitiesExpansionParameterComponent getParameterFirstRep() { 
3117          if (getParameter().isEmpty()) {
3118            addParameter();
3119          }
3120          return getParameter().get(0);
3121        }
3122
3123        /**
3124         * @return {@link #textFilter} (Documentation about text searching works.). This is the underlying object with id, value and extensions. The accessor "getTextFilter" gives direct access to the value
3125         */
3126        public MarkdownType getTextFilterElement() { 
3127          if (this.textFilter == null)
3128            if (Configuration.errorOnAutoCreate())
3129              throw new Error("Attempt to auto-create TerminologyCapabilitiesExpansionComponent.textFilter");
3130            else if (Configuration.doAutoCreate())
3131              this.textFilter = new MarkdownType(); // bb
3132          return this.textFilter;
3133        }
3134
3135        public boolean hasTextFilterElement() { 
3136          return this.textFilter != null && !this.textFilter.isEmpty();
3137        }
3138
3139        public boolean hasTextFilter() { 
3140          return this.textFilter != null && !this.textFilter.isEmpty();
3141        }
3142
3143        /**
3144         * @param value {@link #textFilter} (Documentation about text searching works.). This is the underlying object with id, value and extensions. The accessor "getTextFilter" gives direct access to the value
3145         */
3146        public TerminologyCapabilitiesExpansionComponent setTextFilterElement(MarkdownType value) { 
3147          this.textFilter = value;
3148          return this;
3149        }
3150
3151        /**
3152         * @return Documentation about text searching works.
3153         */
3154        public String getTextFilter() { 
3155          return this.textFilter == null ? null : this.textFilter.getValue();
3156        }
3157
3158        /**
3159         * @param value Documentation about text searching works.
3160         */
3161        public TerminologyCapabilitiesExpansionComponent setTextFilter(String value) { 
3162          if (value == null)
3163            this.textFilter = null;
3164          else {
3165            if (this.textFilter == null)
3166              this.textFilter = new MarkdownType();
3167            this.textFilter.setValue(value);
3168          }
3169          return this;
3170        }
3171
3172        protected void listChildren(List<Property> children) {
3173          super.listChildren(children);
3174          children.add(new Property("hierarchical", "boolean", "Whether the server can return nested value sets.", 0, 1, hierarchical));
3175          children.add(new Property("paging", "boolean", "Whether the server supports paging on expansion.", 0, 1, paging));
3176          children.add(new Property("incomplete", "boolean", "True if requests for incomplete expansions are allowed.", 0, 1, incomplete));
3177          children.add(new Property("parameter", "", "Supported expansion parameter.", 0, java.lang.Integer.MAX_VALUE, parameter));
3178          children.add(new Property("textFilter", "markdown", "Documentation about text searching works.", 0, 1, textFilter));
3179        }
3180
3181        @Override
3182        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
3183          switch (_hash) {
3184          case 857636745: /*hierarchical*/  return new Property("hierarchical", "boolean", "Whether the server can return nested value sets.", 0, 1, hierarchical);
3185          case -995747956: /*paging*/  return new Property("paging", "boolean", "Whether the server supports paging on expansion.", 0, 1, paging);
3186          case -1010022050: /*incomplete*/  return new Property("incomplete", "boolean", "True if requests for incomplete expansions are allowed.", 0, 1, incomplete);
3187          case 1954460585: /*parameter*/  return new Property("parameter", "", "Supported expansion parameter.", 0, java.lang.Integer.MAX_VALUE, parameter);
3188          case 1469359877: /*textFilter*/  return new Property("textFilter", "markdown", "Documentation about text searching works.", 0, 1, textFilter);
3189          default: return super.getNamedProperty(_hash, _name, _checkValid);
3190          }
3191
3192        }
3193
3194      @Override
3195      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3196        switch (hash) {
3197        case 857636745: /*hierarchical*/ return this.hierarchical == null ? new Base[0] : new Base[] {this.hierarchical}; // BooleanType
3198        case -995747956: /*paging*/ return this.paging == null ? new Base[0] : new Base[] {this.paging}; // BooleanType
3199        case -1010022050: /*incomplete*/ return this.incomplete == null ? new Base[0] : new Base[] {this.incomplete}; // BooleanType
3200        case 1954460585: /*parameter*/ return this.parameter == null ? new Base[0] : this.parameter.toArray(new Base[this.parameter.size()]); // TerminologyCapabilitiesExpansionParameterComponent
3201        case 1469359877: /*textFilter*/ return this.textFilter == null ? new Base[0] : new Base[] {this.textFilter}; // MarkdownType
3202        default: return super.getProperty(hash, name, checkValid);
3203        }
3204
3205      }
3206
3207      @Override
3208      public Base setProperty(int hash, String name, Base value) throws FHIRException {
3209        switch (hash) {
3210        case 857636745: // hierarchical
3211          this.hierarchical = TypeConvertor.castToBoolean(value); // BooleanType
3212          return value;
3213        case -995747956: // paging
3214          this.paging = TypeConvertor.castToBoolean(value); // BooleanType
3215          return value;
3216        case -1010022050: // incomplete
3217          this.incomplete = TypeConvertor.castToBoolean(value); // BooleanType
3218          return value;
3219        case 1954460585: // parameter
3220          this.getParameter().add((TerminologyCapabilitiesExpansionParameterComponent) value); // TerminologyCapabilitiesExpansionParameterComponent
3221          return value;
3222        case 1469359877: // textFilter
3223          this.textFilter = TypeConvertor.castToMarkdown(value); // MarkdownType
3224          return value;
3225        default: return super.setProperty(hash, name, value);
3226        }
3227
3228      }
3229
3230      @Override
3231      public Base setProperty(String name, Base value) throws FHIRException {
3232        if (name.equals("hierarchical")) {
3233          this.hierarchical = TypeConvertor.castToBoolean(value); // BooleanType
3234        } else if (name.equals("paging")) {
3235          this.paging = TypeConvertor.castToBoolean(value); // BooleanType
3236        } else if (name.equals("incomplete")) {
3237          this.incomplete = TypeConvertor.castToBoolean(value); // BooleanType
3238        } else if (name.equals("parameter")) {
3239          this.getParameter().add((TerminologyCapabilitiesExpansionParameterComponent) value);
3240        } else if (name.equals("textFilter")) {
3241          this.textFilter = TypeConvertor.castToMarkdown(value); // MarkdownType
3242        } else
3243          return super.setProperty(name, value);
3244        return value;
3245      }
3246
3247      @Override
3248      public Base makeProperty(int hash, String name) throws FHIRException {
3249        switch (hash) {
3250        case 857636745:  return getHierarchicalElement();
3251        case -995747956:  return getPagingElement();
3252        case -1010022050:  return getIncompleteElement();
3253        case 1954460585:  return addParameter(); 
3254        case 1469359877:  return getTextFilterElement();
3255        default: return super.makeProperty(hash, name);
3256        }
3257
3258      }
3259
3260      @Override
3261      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
3262        switch (hash) {
3263        case 857636745: /*hierarchical*/ return new String[] {"boolean"};
3264        case -995747956: /*paging*/ return new String[] {"boolean"};
3265        case -1010022050: /*incomplete*/ return new String[] {"boolean"};
3266        case 1954460585: /*parameter*/ return new String[] {};
3267        case 1469359877: /*textFilter*/ return new String[] {"markdown"};
3268        default: return super.getTypesForProperty(hash, name);
3269        }
3270
3271      }
3272
3273      @Override
3274      public Base addChild(String name) throws FHIRException {
3275        if (name.equals("hierarchical")) {
3276          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.expansion.hierarchical");
3277        }
3278        else if (name.equals("paging")) {
3279          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.expansion.paging");
3280        }
3281        else if (name.equals("incomplete")) {
3282          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.expansion.incomplete");
3283        }
3284        else if (name.equals("parameter")) {
3285          return addParameter();
3286        }
3287        else if (name.equals("textFilter")) {
3288          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.expansion.textFilter");
3289        }
3290        else
3291          return super.addChild(name);
3292      }
3293
3294      public TerminologyCapabilitiesExpansionComponent copy() {
3295        TerminologyCapabilitiesExpansionComponent dst = new TerminologyCapabilitiesExpansionComponent();
3296        copyValues(dst);
3297        return dst;
3298      }
3299
3300      public void copyValues(TerminologyCapabilitiesExpansionComponent dst) {
3301        super.copyValues(dst);
3302        dst.hierarchical = hierarchical == null ? null : hierarchical.copy();
3303        dst.paging = paging == null ? null : paging.copy();
3304        dst.incomplete = incomplete == null ? null : incomplete.copy();
3305        if (parameter != null) {
3306          dst.parameter = new ArrayList<TerminologyCapabilitiesExpansionParameterComponent>();
3307          for (TerminologyCapabilitiesExpansionParameterComponent i : parameter)
3308            dst.parameter.add(i.copy());
3309        };
3310        dst.textFilter = textFilter == null ? null : textFilter.copy();
3311      }
3312
3313      @Override
3314      public boolean equalsDeep(Base other_) {
3315        if (!super.equalsDeep(other_))
3316          return false;
3317        if (!(other_ instanceof TerminologyCapabilitiesExpansionComponent))
3318          return false;
3319        TerminologyCapabilitiesExpansionComponent o = (TerminologyCapabilitiesExpansionComponent) other_;
3320        return compareDeep(hierarchical, o.hierarchical, true) && compareDeep(paging, o.paging, true) && compareDeep(incomplete, o.incomplete, true)
3321           && compareDeep(parameter, o.parameter, true) && compareDeep(textFilter, o.textFilter, true);
3322      }
3323
3324      @Override
3325      public boolean equalsShallow(Base other_) {
3326        if (!super.equalsShallow(other_))
3327          return false;
3328        if (!(other_ instanceof TerminologyCapabilitiesExpansionComponent))
3329          return false;
3330        TerminologyCapabilitiesExpansionComponent o = (TerminologyCapabilitiesExpansionComponent) other_;
3331        return compareValues(hierarchical, o.hierarchical, true) && compareValues(paging, o.paging, true) && compareValues(incomplete, o.incomplete, true)
3332           && compareValues(textFilter, o.textFilter, true);
3333      }
3334
3335      public boolean isEmpty() {
3336        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(hierarchical, paging, incomplete
3337          , parameter, textFilter);
3338      }
3339
3340  public String fhirType() {
3341    return "TerminologyCapabilities.expansion";
3342
3343  }
3344
3345  }
3346
3347    @Block()
3348    public static class TerminologyCapabilitiesExpansionParameterComponent extends BackboneElement implements IBaseBackboneElement {
3349        /**
3350         * Name of the supported expansion parameter.
3351         */
3352        @Child(name = "name", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=false)
3353        @Description(shortDefinition="Name of the supported expansion parameter", formalDefinition="Name of the supported expansion parameter." )
3354        protected CodeType name;
3355
3356        /**
3357         * Description of support for parameter.
3358         */
3359        @Child(name = "documentation", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=false)
3360        @Description(shortDefinition="Description of support for parameter", formalDefinition="Description of support for parameter." )
3361        protected StringType documentation;
3362
3363        private static final long serialVersionUID = -1703372741L;
3364
3365    /**
3366     * Constructor
3367     */
3368      public TerminologyCapabilitiesExpansionParameterComponent() {
3369        super();
3370      }
3371
3372    /**
3373     * Constructor
3374     */
3375      public TerminologyCapabilitiesExpansionParameterComponent(String name) {
3376        super();
3377        this.setName(name);
3378      }
3379
3380        /**
3381         * @return {@link #name} (Name of the supported expansion parameter.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
3382         */
3383        public CodeType getNameElement() { 
3384          if (this.name == null)
3385            if (Configuration.errorOnAutoCreate())
3386              throw new Error("Attempt to auto-create TerminologyCapabilitiesExpansionParameterComponent.name");
3387            else if (Configuration.doAutoCreate())
3388              this.name = new CodeType(); // bb
3389          return this.name;
3390        }
3391
3392        public boolean hasNameElement() { 
3393          return this.name != null && !this.name.isEmpty();
3394        }
3395
3396        public boolean hasName() { 
3397          return this.name != null && !this.name.isEmpty();
3398        }
3399
3400        /**
3401         * @param value {@link #name} (Name of the supported expansion parameter.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
3402         */
3403        public TerminologyCapabilitiesExpansionParameterComponent setNameElement(CodeType value) { 
3404          this.name = value;
3405          return this;
3406        }
3407
3408        /**
3409         * @return Name of the supported expansion parameter.
3410         */
3411        public String getName() { 
3412          return this.name == null ? null : this.name.getValue();
3413        }
3414
3415        /**
3416         * @param value Name of the supported expansion parameter.
3417         */
3418        public TerminologyCapabilitiesExpansionParameterComponent setName(String value) { 
3419            if (this.name == null)
3420              this.name = new CodeType();
3421            this.name.setValue(value);
3422          return this;
3423        }
3424
3425        /**
3426         * @return {@link #documentation} (Description of support for parameter.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value
3427         */
3428        public StringType getDocumentationElement() { 
3429          if (this.documentation == null)
3430            if (Configuration.errorOnAutoCreate())
3431              throw new Error("Attempt to auto-create TerminologyCapabilitiesExpansionParameterComponent.documentation");
3432            else if (Configuration.doAutoCreate())
3433              this.documentation = new StringType(); // bb
3434          return this.documentation;
3435        }
3436
3437        public boolean hasDocumentationElement() { 
3438          return this.documentation != null && !this.documentation.isEmpty();
3439        }
3440
3441        public boolean hasDocumentation() { 
3442          return this.documentation != null && !this.documentation.isEmpty();
3443        }
3444
3445        /**
3446         * @param value {@link #documentation} (Description of support for parameter.). This is the underlying object with id, value and extensions. The accessor "getDocumentation" gives direct access to the value
3447         */
3448        public TerminologyCapabilitiesExpansionParameterComponent setDocumentationElement(StringType value) { 
3449          this.documentation = value;
3450          return this;
3451        }
3452
3453        /**
3454         * @return Description of support for parameter.
3455         */
3456        public String getDocumentation() { 
3457          return this.documentation == null ? null : this.documentation.getValue();
3458        }
3459
3460        /**
3461         * @param value Description of support for parameter.
3462         */
3463        public TerminologyCapabilitiesExpansionParameterComponent setDocumentation(String value) { 
3464          if (Utilities.noString(value))
3465            this.documentation = null;
3466          else {
3467            if (this.documentation == null)
3468              this.documentation = new StringType();
3469            this.documentation.setValue(value);
3470          }
3471          return this;
3472        }
3473
3474        protected void listChildren(List<Property> children) {
3475          super.listChildren(children);
3476          children.add(new Property("name", "code", "Name of the supported expansion parameter.", 0, 1, name));
3477          children.add(new Property("documentation", "string", "Description of support for parameter.", 0, 1, documentation));
3478        }
3479
3480        @Override
3481        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
3482          switch (_hash) {
3483          case 3373707: /*name*/  return new Property("name", "code", "Name of the supported expansion parameter.", 0, 1, name);
3484          case 1587405498: /*documentation*/  return new Property("documentation", "string", "Description of support for parameter.", 0, 1, documentation);
3485          default: return super.getNamedProperty(_hash, _name, _checkValid);
3486          }
3487
3488        }
3489
3490      @Override
3491      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3492        switch (hash) {
3493        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // CodeType
3494        case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : new Base[] {this.documentation}; // StringType
3495        default: return super.getProperty(hash, name, checkValid);
3496        }
3497
3498      }
3499
3500      @Override
3501      public Base setProperty(int hash, String name, Base value) throws FHIRException {
3502        switch (hash) {
3503        case 3373707: // name
3504          this.name = TypeConvertor.castToCode(value); // CodeType
3505          return value;
3506        case 1587405498: // documentation
3507          this.documentation = TypeConvertor.castToString(value); // StringType
3508          return value;
3509        default: return super.setProperty(hash, name, value);
3510        }
3511
3512      }
3513
3514      @Override
3515      public Base setProperty(String name, Base value) throws FHIRException {
3516        if (name.equals("name")) {
3517          this.name = TypeConvertor.castToCode(value); // CodeType
3518        } else if (name.equals("documentation")) {
3519          this.documentation = TypeConvertor.castToString(value); // StringType
3520        } else
3521          return super.setProperty(name, value);
3522        return value;
3523      }
3524
3525      @Override
3526      public Base makeProperty(int hash, String name) throws FHIRException {
3527        switch (hash) {
3528        case 3373707:  return getNameElement();
3529        case 1587405498:  return getDocumentationElement();
3530        default: return super.makeProperty(hash, name);
3531        }
3532
3533      }
3534
3535      @Override
3536      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
3537        switch (hash) {
3538        case 3373707: /*name*/ return new String[] {"code"};
3539        case 1587405498: /*documentation*/ return new String[] {"string"};
3540        default: return super.getTypesForProperty(hash, name);
3541        }
3542
3543      }
3544
3545      @Override
3546      public Base addChild(String name) throws FHIRException {
3547        if (name.equals("name")) {
3548          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.expansion.parameter.name");
3549        }
3550        else if (name.equals("documentation")) {
3551          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.expansion.parameter.documentation");
3552        }
3553        else
3554          return super.addChild(name);
3555      }
3556
3557      public TerminologyCapabilitiesExpansionParameterComponent copy() {
3558        TerminologyCapabilitiesExpansionParameterComponent dst = new TerminologyCapabilitiesExpansionParameterComponent();
3559        copyValues(dst);
3560        return dst;
3561      }
3562
3563      public void copyValues(TerminologyCapabilitiesExpansionParameterComponent dst) {
3564        super.copyValues(dst);
3565        dst.name = name == null ? null : name.copy();
3566        dst.documentation = documentation == null ? null : documentation.copy();
3567      }
3568
3569      @Override
3570      public boolean equalsDeep(Base other_) {
3571        if (!super.equalsDeep(other_))
3572          return false;
3573        if (!(other_ instanceof TerminologyCapabilitiesExpansionParameterComponent))
3574          return false;
3575        TerminologyCapabilitiesExpansionParameterComponent o = (TerminologyCapabilitiesExpansionParameterComponent) other_;
3576        return compareDeep(name, o.name, true) && compareDeep(documentation, o.documentation, true);
3577      }
3578
3579      @Override
3580      public boolean equalsShallow(Base other_) {
3581        if (!super.equalsShallow(other_))
3582          return false;
3583        if (!(other_ instanceof TerminologyCapabilitiesExpansionParameterComponent))
3584          return false;
3585        TerminologyCapabilitiesExpansionParameterComponent o = (TerminologyCapabilitiesExpansionParameterComponent) other_;
3586        return compareValues(name, o.name, true) && compareValues(documentation, o.documentation, true);
3587      }
3588
3589      public boolean isEmpty() {
3590        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, documentation);
3591      }
3592
3593  public String fhirType() {
3594    return "TerminologyCapabilities.expansion.parameter";
3595
3596  }
3597
3598  }
3599
3600    @Block()
3601    public static class TerminologyCapabilitiesValidateCodeComponent extends BackboneElement implements IBaseBackboneElement {
3602        /**
3603         * Whether translations are validated.
3604         */
3605        @Child(name = "translations", type = {BooleanType.class}, order=1, min=1, max=1, modifier=false, summary=false)
3606        @Description(shortDefinition="Whether translations are validated", formalDefinition="Whether translations are validated." )
3607        protected BooleanType translations;
3608
3609        private static final long serialVersionUID = -1212814906L;
3610
3611    /**
3612     * Constructor
3613     */
3614      public TerminologyCapabilitiesValidateCodeComponent() {
3615        super();
3616      }
3617
3618    /**
3619     * Constructor
3620     */
3621      public TerminologyCapabilitiesValidateCodeComponent(boolean translations) {
3622        super();
3623        this.setTranslations(translations);
3624      }
3625
3626        /**
3627         * @return {@link #translations} (Whether translations are validated.). This is the underlying object with id, value and extensions. The accessor "getTranslations" gives direct access to the value
3628         */
3629        public BooleanType getTranslationsElement() { 
3630          if (this.translations == null)
3631            if (Configuration.errorOnAutoCreate())
3632              throw new Error("Attempt to auto-create TerminologyCapabilitiesValidateCodeComponent.translations");
3633            else if (Configuration.doAutoCreate())
3634              this.translations = new BooleanType(); // bb
3635          return this.translations;
3636        }
3637
3638        public boolean hasTranslationsElement() { 
3639          return this.translations != null && !this.translations.isEmpty();
3640        }
3641
3642        public boolean hasTranslations() { 
3643          return this.translations != null && !this.translations.isEmpty();
3644        }
3645
3646        /**
3647         * @param value {@link #translations} (Whether translations are validated.). This is the underlying object with id, value and extensions. The accessor "getTranslations" gives direct access to the value
3648         */
3649        public TerminologyCapabilitiesValidateCodeComponent setTranslationsElement(BooleanType value) { 
3650          this.translations = value;
3651          return this;
3652        }
3653
3654        /**
3655         * @return Whether translations are validated.
3656         */
3657        public boolean getTranslations() { 
3658          return this.translations == null || this.translations.isEmpty() ? false : this.translations.getValue();
3659        }
3660
3661        /**
3662         * @param value Whether translations are validated.
3663         */
3664        public TerminologyCapabilitiesValidateCodeComponent setTranslations(boolean value) { 
3665            if (this.translations == null)
3666              this.translations = new BooleanType();
3667            this.translations.setValue(value);
3668          return this;
3669        }
3670
3671        protected void listChildren(List<Property> children) {
3672          super.listChildren(children);
3673          children.add(new Property("translations", "boolean", "Whether translations are validated.", 0, 1, translations));
3674        }
3675
3676        @Override
3677        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
3678          switch (_hash) {
3679          case -1225497630: /*translations*/  return new Property("translations", "boolean", "Whether translations are validated.", 0, 1, translations);
3680          default: return super.getNamedProperty(_hash, _name, _checkValid);
3681          }
3682
3683        }
3684
3685      @Override
3686      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3687        switch (hash) {
3688        case -1225497630: /*translations*/ return this.translations == null ? new Base[0] : new Base[] {this.translations}; // BooleanType
3689        default: return super.getProperty(hash, name, checkValid);
3690        }
3691
3692      }
3693
3694      @Override
3695      public Base setProperty(int hash, String name, Base value) throws FHIRException {
3696        switch (hash) {
3697        case -1225497630: // translations
3698          this.translations = TypeConvertor.castToBoolean(value); // BooleanType
3699          return value;
3700        default: return super.setProperty(hash, name, value);
3701        }
3702
3703      }
3704
3705      @Override
3706      public Base setProperty(String name, Base value) throws FHIRException {
3707        if (name.equals("translations")) {
3708          this.translations = TypeConvertor.castToBoolean(value); // BooleanType
3709        } else
3710          return super.setProperty(name, value);
3711        return value;
3712      }
3713
3714      @Override
3715      public Base makeProperty(int hash, String name) throws FHIRException {
3716        switch (hash) {
3717        case -1225497630:  return getTranslationsElement();
3718        default: return super.makeProperty(hash, name);
3719        }
3720
3721      }
3722
3723      @Override
3724      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
3725        switch (hash) {
3726        case -1225497630: /*translations*/ return new String[] {"boolean"};
3727        default: return super.getTypesForProperty(hash, name);
3728        }
3729
3730      }
3731
3732      @Override
3733      public Base addChild(String name) throws FHIRException {
3734        if (name.equals("translations")) {
3735          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.validateCode.translations");
3736        }
3737        else
3738          return super.addChild(name);
3739      }
3740
3741      public TerminologyCapabilitiesValidateCodeComponent copy() {
3742        TerminologyCapabilitiesValidateCodeComponent dst = new TerminologyCapabilitiesValidateCodeComponent();
3743        copyValues(dst);
3744        return dst;
3745      }
3746
3747      public void copyValues(TerminologyCapabilitiesValidateCodeComponent dst) {
3748        super.copyValues(dst);
3749        dst.translations = translations == null ? null : translations.copy();
3750      }
3751
3752      @Override
3753      public boolean equalsDeep(Base other_) {
3754        if (!super.equalsDeep(other_))
3755          return false;
3756        if (!(other_ instanceof TerminologyCapabilitiesValidateCodeComponent))
3757          return false;
3758        TerminologyCapabilitiesValidateCodeComponent o = (TerminologyCapabilitiesValidateCodeComponent) other_;
3759        return compareDeep(translations, o.translations, true);
3760      }
3761
3762      @Override
3763      public boolean equalsShallow(Base other_) {
3764        if (!super.equalsShallow(other_))
3765          return false;
3766        if (!(other_ instanceof TerminologyCapabilitiesValidateCodeComponent))
3767          return false;
3768        TerminologyCapabilitiesValidateCodeComponent o = (TerminologyCapabilitiesValidateCodeComponent) other_;
3769        return compareValues(translations, o.translations, true);
3770      }
3771
3772      public boolean isEmpty() {
3773        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(translations);
3774      }
3775
3776  public String fhirType() {
3777    return "TerminologyCapabilities.validateCode";
3778
3779  }
3780
3781  }
3782
3783    @Block()
3784    public static class TerminologyCapabilitiesTranslationComponent extends BackboneElement implements IBaseBackboneElement {
3785        /**
3786         * Whether the client must identify the map.
3787         */
3788        @Child(name = "needsMap", type = {BooleanType.class}, order=1, min=1, max=1, modifier=false, summary=false)
3789        @Description(shortDefinition="Whether the client must identify the map", formalDefinition="Whether the client must identify the map." )
3790        protected BooleanType needsMap;
3791
3792        private static final long serialVersionUID = -1727843575L;
3793
3794    /**
3795     * Constructor
3796     */
3797      public TerminologyCapabilitiesTranslationComponent() {
3798        super();
3799      }
3800
3801    /**
3802     * Constructor
3803     */
3804      public TerminologyCapabilitiesTranslationComponent(boolean needsMap) {
3805        super();
3806        this.setNeedsMap(needsMap);
3807      }
3808
3809        /**
3810         * @return {@link #needsMap} (Whether the client must identify the map.). This is the underlying object with id, value and extensions. The accessor "getNeedsMap" gives direct access to the value
3811         */
3812        public BooleanType getNeedsMapElement() { 
3813          if (this.needsMap == null)
3814            if (Configuration.errorOnAutoCreate())
3815              throw new Error("Attempt to auto-create TerminologyCapabilitiesTranslationComponent.needsMap");
3816            else if (Configuration.doAutoCreate())
3817              this.needsMap = new BooleanType(); // bb
3818          return this.needsMap;
3819        }
3820
3821        public boolean hasNeedsMapElement() { 
3822          return this.needsMap != null && !this.needsMap.isEmpty();
3823        }
3824
3825        public boolean hasNeedsMap() { 
3826          return this.needsMap != null && !this.needsMap.isEmpty();
3827        }
3828
3829        /**
3830         * @param value {@link #needsMap} (Whether the client must identify the map.). This is the underlying object with id, value and extensions. The accessor "getNeedsMap" gives direct access to the value
3831         */
3832        public TerminologyCapabilitiesTranslationComponent setNeedsMapElement(BooleanType value) { 
3833          this.needsMap = value;
3834          return this;
3835        }
3836
3837        /**
3838         * @return Whether the client must identify the map.
3839         */
3840        public boolean getNeedsMap() { 
3841          return this.needsMap == null || this.needsMap.isEmpty() ? false : this.needsMap.getValue();
3842        }
3843
3844        /**
3845         * @param value Whether the client must identify the map.
3846         */
3847        public TerminologyCapabilitiesTranslationComponent setNeedsMap(boolean value) { 
3848            if (this.needsMap == null)
3849              this.needsMap = new BooleanType();
3850            this.needsMap.setValue(value);
3851          return this;
3852        }
3853
3854        protected void listChildren(List<Property> children) {
3855          super.listChildren(children);
3856          children.add(new Property("needsMap", "boolean", "Whether the client must identify the map.", 0, 1, needsMap));
3857        }
3858
3859        @Override
3860        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
3861          switch (_hash) {
3862          case 866566527: /*needsMap*/  return new Property("needsMap", "boolean", "Whether the client must identify the map.", 0, 1, needsMap);
3863          default: return super.getNamedProperty(_hash, _name, _checkValid);
3864          }
3865
3866        }
3867
3868      @Override
3869      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3870        switch (hash) {
3871        case 866566527: /*needsMap*/ return this.needsMap == null ? new Base[0] : new Base[] {this.needsMap}; // BooleanType
3872        default: return super.getProperty(hash, name, checkValid);
3873        }
3874
3875      }
3876
3877      @Override
3878      public Base setProperty(int hash, String name, Base value) throws FHIRException {
3879        switch (hash) {
3880        case 866566527: // needsMap
3881          this.needsMap = TypeConvertor.castToBoolean(value); // BooleanType
3882          return value;
3883        default: return super.setProperty(hash, name, value);
3884        }
3885
3886      }
3887
3888      @Override
3889      public Base setProperty(String name, Base value) throws FHIRException {
3890        if (name.equals("needsMap")) {
3891          this.needsMap = TypeConvertor.castToBoolean(value); // BooleanType
3892        } else
3893          return super.setProperty(name, value);
3894        return value;
3895      }
3896
3897      @Override
3898      public Base makeProperty(int hash, String name) throws FHIRException {
3899        switch (hash) {
3900        case 866566527:  return getNeedsMapElement();
3901        default: return super.makeProperty(hash, name);
3902        }
3903
3904      }
3905
3906      @Override
3907      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
3908        switch (hash) {
3909        case 866566527: /*needsMap*/ return new String[] {"boolean"};
3910        default: return super.getTypesForProperty(hash, name);
3911        }
3912
3913      }
3914
3915      @Override
3916      public Base addChild(String name) throws FHIRException {
3917        if (name.equals("needsMap")) {
3918          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.translation.needsMap");
3919        }
3920        else
3921          return super.addChild(name);
3922      }
3923
3924      public TerminologyCapabilitiesTranslationComponent copy() {
3925        TerminologyCapabilitiesTranslationComponent dst = new TerminologyCapabilitiesTranslationComponent();
3926        copyValues(dst);
3927        return dst;
3928      }
3929
3930      public void copyValues(TerminologyCapabilitiesTranslationComponent dst) {
3931        super.copyValues(dst);
3932        dst.needsMap = needsMap == null ? null : needsMap.copy();
3933      }
3934
3935      @Override
3936      public boolean equalsDeep(Base other_) {
3937        if (!super.equalsDeep(other_))
3938          return false;
3939        if (!(other_ instanceof TerminologyCapabilitiesTranslationComponent))
3940          return false;
3941        TerminologyCapabilitiesTranslationComponent o = (TerminologyCapabilitiesTranslationComponent) other_;
3942        return compareDeep(needsMap, o.needsMap, true);
3943      }
3944
3945      @Override
3946      public boolean equalsShallow(Base other_) {
3947        if (!super.equalsShallow(other_))
3948          return false;
3949        if (!(other_ instanceof TerminologyCapabilitiesTranslationComponent))
3950          return false;
3951        TerminologyCapabilitiesTranslationComponent o = (TerminologyCapabilitiesTranslationComponent) other_;
3952        return compareValues(needsMap, o.needsMap, true);
3953      }
3954
3955      public boolean isEmpty() {
3956        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(needsMap);
3957      }
3958
3959  public String fhirType() {
3960    return "TerminologyCapabilities.translation";
3961
3962  }
3963
3964  }
3965
3966    @Block()
3967    public static class TerminologyCapabilitiesClosureComponent extends BackboneElement implements IBaseBackboneElement {
3968        /**
3969         * If cross-system closure is supported.
3970         */
3971        @Child(name = "translation", type = {BooleanType.class}, order=1, min=0, max=1, modifier=false, summary=false)
3972        @Description(shortDefinition="If cross-system closure is supported", formalDefinition="If cross-system closure is supported." )
3973        protected BooleanType translation;
3974
3975        private static final long serialVersionUID = 1900484343L;
3976
3977    /**
3978     * Constructor
3979     */
3980      public TerminologyCapabilitiesClosureComponent() {
3981        super();
3982      }
3983
3984        /**
3985         * @return {@link #translation} (If cross-system closure is supported.). This is the underlying object with id, value and extensions. The accessor "getTranslation" gives direct access to the value
3986         */
3987        public BooleanType getTranslationElement() { 
3988          if (this.translation == null)
3989            if (Configuration.errorOnAutoCreate())
3990              throw new Error("Attempt to auto-create TerminologyCapabilitiesClosureComponent.translation");
3991            else if (Configuration.doAutoCreate())
3992              this.translation = new BooleanType(); // bb
3993          return this.translation;
3994        }
3995
3996        public boolean hasTranslationElement() { 
3997          return this.translation != null && !this.translation.isEmpty();
3998        }
3999
4000        public boolean hasTranslation() { 
4001          return this.translation != null && !this.translation.isEmpty();
4002        }
4003
4004        /**
4005         * @param value {@link #translation} (If cross-system closure is supported.). This is the underlying object with id, value and extensions. The accessor "getTranslation" gives direct access to the value
4006         */
4007        public TerminologyCapabilitiesClosureComponent setTranslationElement(BooleanType value) { 
4008          this.translation = value;
4009          return this;
4010        }
4011
4012        /**
4013         * @return If cross-system closure is supported.
4014         */
4015        public boolean getTranslation() { 
4016          return this.translation == null || this.translation.isEmpty() ? false : this.translation.getValue();
4017        }
4018
4019        /**
4020         * @param value If cross-system closure is supported.
4021         */
4022        public TerminologyCapabilitiesClosureComponent setTranslation(boolean value) { 
4023            if (this.translation == null)
4024              this.translation = new BooleanType();
4025            this.translation.setValue(value);
4026          return this;
4027        }
4028
4029        protected void listChildren(List<Property> children) {
4030          super.listChildren(children);
4031          children.add(new Property("translation", "boolean", "If cross-system closure is supported.", 0, 1, translation));
4032        }
4033
4034        @Override
4035        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
4036          switch (_hash) {
4037          case -1840647503: /*translation*/  return new Property("translation", "boolean", "If cross-system closure is supported.", 0, 1, translation);
4038          default: return super.getNamedProperty(_hash, _name, _checkValid);
4039          }
4040
4041        }
4042
4043      @Override
4044      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
4045        switch (hash) {
4046        case -1840647503: /*translation*/ return this.translation == null ? new Base[0] : new Base[] {this.translation}; // BooleanType
4047        default: return super.getProperty(hash, name, checkValid);
4048        }
4049
4050      }
4051
4052      @Override
4053      public Base setProperty(int hash, String name, Base value) throws FHIRException {
4054        switch (hash) {
4055        case -1840647503: // translation
4056          this.translation = TypeConvertor.castToBoolean(value); // BooleanType
4057          return value;
4058        default: return super.setProperty(hash, name, value);
4059        }
4060
4061      }
4062
4063      @Override
4064      public Base setProperty(String name, Base value) throws FHIRException {
4065        if (name.equals("translation")) {
4066          this.translation = TypeConvertor.castToBoolean(value); // BooleanType
4067        } else
4068          return super.setProperty(name, value);
4069        return value;
4070      }
4071
4072      @Override
4073      public Base makeProperty(int hash, String name) throws FHIRException {
4074        switch (hash) {
4075        case -1840647503:  return getTranslationElement();
4076        default: return super.makeProperty(hash, name);
4077        }
4078
4079      }
4080
4081      @Override
4082      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
4083        switch (hash) {
4084        case -1840647503: /*translation*/ return new String[] {"boolean"};
4085        default: return super.getTypesForProperty(hash, name);
4086        }
4087
4088      }
4089
4090      @Override
4091      public Base addChild(String name) throws FHIRException {
4092        if (name.equals("translation")) {
4093          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.closure.translation");
4094        }
4095        else
4096          return super.addChild(name);
4097      }
4098
4099      public TerminologyCapabilitiesClosureComponent copy() {
4100        TerminologyCapabilitiesClosureComponent dst = new TerminologyCapabilitiesClosureComponent();
4101        copyValues(dst);
4102        return dst;
4103      }
4104
4105      public void copyValues(TerminologyCapabilitiesClosureComponent dst) {
4106        super.copyValues(dst);
4107        dst.translation = translation == null ? null : translation.copy();
4108      }
4109
4110      @Override
4111      public boolean equalsDeep(Base other_) {
4112        if (!super.equalsDeep(other_))
4113          return false;
4114        if (!(other_ instanceof TerminologyCapabilitiesClosureComponent))
4115          return false;
4116        TerminologyCapabilitiesClosureComponent o = (TerminologyCapabilitiesClosureComponent) other_;
4117        return compareDeep(translation, o.translation, true);
4118      }
4119
4120      @Override
4121      public boolean equalsShallow(Base other_) {
4122        if (!super.equalsShallow(other_))
4123          return false;
4124        if (!(other_ instanceof TerminologyCapabilitiesClosureComponent))
4125          return false;
4126        TerminologyCapabilitiesClosureComponent o = (TerminologyCapabilitiesClosureComponent) other_;
4127        return compareValues(translation, o.translation, true);
4128      }
4129
4130      public boolean isEmpty() {
4131        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(translation);
4132      }
4133
4134  public String fhirType() {
4135    return "TerminologyCapabilities.closure";
4136
4137  }
4138
4139  }
4140
4141    /**
4142     * An absolute URI that is used to identify this terminology capabilities when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which an authoritative instance of this terminology capabilities is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the terminology capabilities is stored on different servers.
4143     */
4144    @Child(name = "url", type = {UriType.class}, order=0, min=0, max=1, modifier=false, summary=true)
4145    @Description(shortDefinition="Canonical identifier for this terminology capabilities, represented as a URI (globally unique)", formalDefinition="An absolute URI that is used to identify this terminology capabilities when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which an authoritative instance of this terminology capabilities is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the terminology capabilities is stored on different servers." )
4146    protected UriType url;
4147
4148    /**
4149     * A formal identifier that is used to identify this terminology capabilities when it is represented in other formats, or referenced in a specification, model, design or an instance.
4150     */
4151    @Child(name = "identifier", type = {Identifier.class}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
4152    @Description(shortDefinition="Additional identifier for the terminology capabilities", formalDefinition="A formal identifier that is used to identify this terminology capabilities when it is represented in other formats, or referenced in a specification, model, design or an instance." )
4153    protected List<Identifier> identifier;
4154
4155    /**
4156     * The identifier that is used to identify this version of the terminology capabilities when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the terminology capabilities 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.
4157     */
4158    @Child(name = "version", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true)
4159    @Description(shortDefinition="Business version of the terminology capabilities", formalDefinition="The identifier that is used to identify this version of the terminology capabilities when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the terminology capabilities 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." )
4160    protected StringType version;
4161
4162    /**
4163     * A natural language name identifying the terminology capabilities. This name should be usable as an identifier for the module by machine processing applications such as code generation.
4164     */
4165    @Child(name = "name", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=true)
4166    @Description(shortDefinition="Name for this terminology capabilities (computer friendly)", formalDefinition="A natural language name identifying the terminology capabilities. This name should be usable as an identifier for the module by machine processing applications such as code generation." )
4167    protected StringType name;
4168
4169    /**
4170     * A short, descriptive, user-friendly title for the terminology capabilities.
4171     */
4172    @Child(name = "title", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=true)
4173    @Description(shortDefinition="Name for this terminology capabilities (human friendly)", formalDefinition="A short, descriptive, user-friendly title for the terminology capabilities." )
4174    protected StringType title;
4175
4176    /**
4177     * The status of this terminology capabilities. Enables tracking the life-cycle of the content.
4178     */
4179    @Child(name = "status", type = {CodeType.class}, order=5, min=1, max=1, modifier=true, summary=true)
4180    @Description(shortDefinition="draft | active | retired | unknown", formalDefinition="The status of this terminology capabilities. Enables tracking the life-cycle of the content." )
4181    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/publication-status")
4182    protected Enumeration<PublicationStatus> status;
4183
4184    /**
4185     * A Boolean value to indicate that this terminology capabilities is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.
4186     */
4187    @Child(name = "experimental", type = {BooleanType.class}, order=6, min=0, max=1, modifier=false, summary=true)
4188    @Description(shortDefinition="For testing purposes, not real usage", formalDefinition="A Boolean value to indicate that this terminology capabilities is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage." )
4189    protected BooleanType experimental;
4190
4191    /**
4192     * The date  (and optionally time) when the terminology capabilities was published. The date must change 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 terminology capabilities changes.
4193     */
4194    @Child(name = "date", type = {DateTimeType.class}, order=7, min=1, max=1, modifier=false, summary=true)
4195    @Description(shortDefinition="Date last changed", formalDefinition="The date  (and optionally time) when the terminology capabilities was published. The date must change 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 terminology capabilities changes." )
4196    protected DateTimeType date;
4197
4198    /**
4199     * The name of the organization or individual responsible for the release and ongoing maintenance of the terminology capabilities.
4200     */
4201    @Child(name = "publisher", type = {StringType.class}, order=8, min=0, max=1, modifier=false, summary=true)
4202    @Description(shortDefinition="Name of the publisher/steward (organization or individual)", formalDefinition="The name of the organization or individual responsible for the release and ongoing maintenance of the terminology capabilities." )
4203    protected StringType publisher;
4204
4205    /**
4206     * Contact details to assist a user in finding and communicating with the publisher.
4207     */
4208    @Child(name = "contact", type = {ContactDetail.class}, order=9, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
4209    @Description(shortDefinition="Contact details for the publisher", formalDefinition="Contact details to assist a user in finding and communicating with the publisher." )
4210    protected List<ContactDetail> contact;
4211
4212    /**
4213     * A free text natural language description of the terminology capabilities from a consumer's perspective. Typically, this is used when the capability statement describes a desired rather than an actual solution, for example as a formal expression of requirements as part of an RFP.
4214     */
4215    @Child(name = "description", type = {MarkdownType.class}, order=10, min=0, max=1, modifier=false, summary=false)
4216    @Description(shortDefinition="Natural language description of the terminology capabilities", formalDefinition="A free text natural language description of the terminology capabilities from a consumer's perspective. Typically, this is used when the capability statement describes a desired rather than an actual solution, for example as a formal expression of requirements as part of an RFP." )
4217    protected MarkdownType description;
4218
4219    /**
4220     * The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate terminology capabilities instances.
4221     */
4222    @Child(name = "useContext", type = {UsageContext.class}, order=11, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
4223    @Description(shortDefinition="The context that the content is intended to support", formalDefinition="The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate terminology capabilities instances." )
4224    protected List<UsageContext> useContext;
4225
4226    /**
4227     * A legal or geographic region in which the terminology capabilities is intended to be used.
4228     */
4229    @Child(name = "jurisdiction", type = {CodeableConcept.class}, order=12, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
4230    @Description(shortDefinition="Intended jurisdiction for terminology capabilities (if applicable)", formalDefinition="A legal or geographic region in which the terminology capabilities is intended to be used." )
4231    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/jurisdiction")
4232    protected List<CodeableConcept> jurisdiction;
4233
4234    /**
4235     * Explanation of why this terminology capabilities is needed and why it has been designed as it has.
4236     */
4237    @Child(name = "purpose", type = {MarkdownType.class}, order=13, min=0, max=1, modifier=false, summary=false)
4238    @Description(shortDefinition="Why this terminology capabilities is defined", formalDefinition="Explanation of why this terminology capabilities is needed and why it has been designed as it has." )
4239    protected MarkdownType purpose;
4240
4241    /**
4242     * A copyright statement relating to the terminology capabilities and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the terminology capabilities.
4243     */
4244    @Child(name = "copyright", type = {MarkdownType.class}, order=14, min=0, max=1, modifier=false, summary=true)
4245    @Description(shortDefinition="Use and/or publishing restrictions", formalDefinition="A copyright statement relating to the terminology capabilities and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the terminology capabilities." )
4246    protected MarkdownType copyright;
4247
4248    /**
4249     * The way that this statement is intended to be used, to describe an actual running instance of software, a particular product (kind, not instance of software) or a class of implementation (e.g. a desired purchase).
4250     */
4251    @Child(name = "kind", type = {CodeType.class}, order=15, min=1, max=1, modifier=false, summary=true)
4252    @Description(shortDefinition="instance | capability | requirements", formalDefinition="The way that this statement is intended to be used, to describe an actual running instance of software, a particular product (kind, not instance of software) or a class of implementation (e.g. a desired purchase)." )
4253    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/capability-statement-kind")
4254    protected Enumeration<CapabilityStatementKind> kind;
4255
4256    /**
4257     * Software that is covered by this terminology capability statement.  It is used when the statement describes the capabilities of a particular software version, independent of an installation.
4258     */
4259    @Child(name = "software", type = {}, order=16, min=0, max=1, modifier=false, summary=true)
4260    @Description(shortDefinition="Software that is covered by this terminology capability statement", formalDefinition="Software that is covered by this terminology capability statement.  It is used when the statement describes the capabilities of a particular software version, independent of an installation." )
4261    protected TerminologyCapabilitiesSoftwareComponent software;
4262
4263    /**
4264     * Identifies a specific implementation instance that is described by the terminology capability statement - i.e. a particular installation, rather than the capabilities of a software program.
4265     */
4266    @Child(name = "implementation", type = {}, order=17, min=0, max=1, modifier=false, summary=true)
4267    @Description(shortDefinition="If this describes a specific instance", formalDefinition="Identifies a specific implementation instance that is described by the terminology capability statement - i.e. a particular installation, rather than the capabilities of a software program." )
4268    protected TerminologyCapabilitiesImplementationComponent implementation;
4269
4270    /**
4271     * Whether the server supports lockedDate.
4272     */
4273    @Child(name = "lockedDate", type = {BooleanType.class}, order=18, min=0, max=1, modifier=false, summary=true)
4274    @Description(shortDefinition="Whether lockedDate is supported", formalDefinition="Whether the server supports lockedDate." )
4275    protected BooleanType lockedDate;
4276
4277    /**
4278     * Identifies a code system that is supported by the server. If there is a no code system URL, then this declares the general assumptions a client can make about support for any CodeSystem resource.
4279     */
4280    @Child(name = "codeSystem", type = {}, order=19, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
4281    @Description(shortDefinition="A code system supported by the server", formalDefinition="Identifies a code system that is supported by the server. If there is a no code system URL, then this declares the general assumptions a client can make about support for any CodeSystem resource." )
4282    protected List<TerminologyCapabilitiesCodeSystemComponent> codeSystem;
4283
4284    /**
4285     * Information about the [ValueSet/$expand](valueset-operation-expand.html) operation.
4286     */
4287    @Child(name = "expansion", type = {}, order=20, min=0, max=1, modifier=false, summary=false)
4288    @Description(shortDefinition="Information about the [ValueSet/$expand](valueset-operation-expand.html) operation", formalDefinition="Information about the [ValueSet/$expand](valueset-operation-expand.html) operation." )
4289    protected TerminologyCapabilitiesExpansionComponent expansion;
4290
4291    /**
4292     * The degree to which the server supports the code search parameter on ValueSet, if it is supported.
4293     */
4294    @Child(name = "codeSearch", type = {CodeType.class}, order=21, min=0, max=1, modifier=false, summary=false)
4295    @Description(shortDefinition="in-compose | in-expansion | in-compose-or-expansion", formalDefinition="The degree to which the server supports the code search parameter on ValueSet, if it is supported." )
4296    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/code-search-support")
4297    protected Enumeration<CodeSearchSupport> codeSearch;
4298
4299    /**
4300     * Information about the [ValueSet/$validate-code](valueset-operation-validate-code.html) operation.
4301     */
4302    @Child(name = "validateCode", type = {}, order=22, min=0, max=1, modifier=false, summary=false)
4303    @Description(shortDefinition="Information about the [ValueSet/$validate-code](valueset-operation-validate-code.html) operation", formalDefinition="Information about the [ValueSet/$validate-code](valueset-operation-validate-code.html) operation." )
4304    protected TerminologyCapabilitiesValidateCodeComponent validateCode;
4305
4306    /**
4307     * Information about the [ConceptMap/$translate](conceptmap-operation-translate.html) operation.
4308     */
4309    @Child(name = "translation", type = {}, order=23, min=0, max=1, modifier=false, summary=false)
4310    @Description(shortDefinition="Information about the [ConceptMap/$translate](conceptmap-operation-translate.html) operation", formalDefinition="Information about the [ConceptMap/$translate](conceptmap-operation-translate.html) operation." )
4311    protected TerminologyCapabilitiesTranslationComponent translation;
4312
4313    /**
4314     * Whether the $closure operation is supported.
4315     */
4316    @Child(name = "closure", type = {}, order=24, min=0, max=1, modifier=false, summary=false)
4317    @Description(shortDefinition="Information about the [ConceptMap/$closure](conceptmap-operation-closure.html) operation", formalDefinition="Whether the $closure operation is supported." )
4318    protected TerminologyCapabilitiesClosureComponent closure;
4319
4320    private static final long serialVersionUID = 1685724657L;
4321
4322  /**
4323   * Constructor
4324   */
4325    public TerminologyCapabilities() {
4326      super();
4327    }
4328
4329  /**
4330   * Constructor
4331   */
4332    public TerminologyCapabilities(PublicationStatus status, Date date, CapabilityStatementKind kind) {
4333      super();
4334      this.setStatus(status);
4335      this.setDate(date);
4336      this.setKind(kind);
4337    }
4338
4339    /**
4340     * @return {@link #url} (An absolute URI that is used to identify this terminology capabilities when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which an authoritative instance of this terminology capabilities is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the terminology capabilities is stored on different servers.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
4341     */
4342    public UriType getUrlElement() { 
4343      if (this.url == null)
4344        if (Configuration.errorOnAutoCreate())
4345          throw new Error("Attempt to auto-create TerminologyCapabilities.url");
4346        else if (Configuration.doAutoCreate())
4347          this.url = new UriType(); // bb
4348      return this.url;
4349    }
4350
4351    public boolean hasUrlElement() { 
4352      return this.url != null && !this.url.isEmpty();
4353    }
4354
4355    public boolean hasUrl() { 
4356      return this.url != null && !this.url.isEmpty();
4357    }
4358
4359    /**
4360     * @param value {@link #url} (An absolute URI that is used to identify this terminology capabilities when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which an authoritative instance of this terminology capabilities is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the terminology capabilities is stored on different servers.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
4361     */
4362    public TerminologyCapabilities setUrlElement(UriType value) { 
4363      this.url = value;
4364      return this;
4365    }
4366
4367    /**
4368     * @return An absolute URI that is used to identify this terminology capabilities when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which an authoritative instance of this terminology capabilities is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the terminology capabilities is stored on different servers.
4369     */
4370    public String getUrl() { 
4371      return this.url == null ? null : this.url.getValue();
4372    }
4373
4374    /**
4375     * @param value An absolute URI that is used to identify this terminology capabilities when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which an authoritative instance of this terminology capabilities is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the terminology capabilities is stored on different servers.
4376     */
4377    public TerminologyCapabilities setUrl(String value) { 
4378      if (Utilities.noString(value))
4379        this.url = null;
4380      else {
4381        if (this.url == null)
4382          this.url = new UriType();
4383        this.url.setValue(value);
4384      }
4385      return this;
4386    }
4387
4388    /**
4389     * @return {@link #identifier} (A formal identifier that is used to identify this terminology capabilities when it is represented in other formats, or referenced in a specification, model, design or an instance.)
4390     */
4391    public List<Identifier> getIdentifier() { 
4392      if (this.identifier == null)
4393        this.identifier = new ArrayList<Identifier>();
4394      return this.identifier;
4395    }
4396
4397    /**
4398     * @return Returns a reference to <code>this</code> for easy method chaining
4399     */
4400    public TerminologyCapabilities setIdentifier(List<Identifier> theIdentifier) { 
4401      this.identifier = theIdentifier;
4402      return this;
4403    }
4404
4405    public boolean hasIdentifier() { 
4406      if (this.identifier == null)
4407        return false;
4408      for (Identifier item : this.identifier)
4409        if (!item.isEmpty())
4410          return true;
4411      return false;
4412    }
4413
4414    public Identifier addIdentifier() { //3
4415      Identifier t = new Identifier();
4416      if (this.identifier == null)
4417        this.identifier = new ArrayList<Identifier>();
4418      this.identifier.add(t);
4419      return t;
4420    }
4421
4422    public TerminologyCapabilities addIdentifier(Identifier t) { //3
4423      if (t == null)
4424        return this;
4425      if (this.identifier == null)
4426        this.identifier = new ArrayList<Identifier>();
4427      this.identifier.add(t);
4428      return this;
4429    }
4430
4431    /**
4432     * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist {3}
4433     */
4434    public Identifier getIdentifierFirstRep() { 
4435      if (getIdentifier().isEmpty()) {
4436        addIdentifier();
4437      }
4438      return getIdentifier().get(0);
4439    }
4440
4441    /**
4442     * @return {@link #version} (The identifier that is used to identify this version of the terminology capabilities when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the terminology capabilities 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
4443     */
4444    public StringType getVersionElement() { 
4445      if (this.version == null)
4446        if (Configuration.errorOnAutoCreate())
4447          throw new Error("Attempt to auto-create TerminologyCapabilities.version");
4448        else if (Configuration.doAutoCreate())
4449          this.version = new StringType(); // bb
4450      return this.version;
4451    }
4452
4453    public boolean hasVersionElement() { 
4454      return this.version != null && !this.version.isEmpty();
4455    }
4456
4457    public boolean hasVersion() { 
4458      return this.version != null && !this.version.isEmpty();
4459    }
4460
4461    /**
4462     * @param value {@link #version} (The identifier that is used to identify this version of the terminology capabilities when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the terminology capabilities 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
4463     */
4464    public TerminologyCapabilities setVersionElement(StringType value) { 
4465      this.version = value;
4466      return this;
4467    }
4468
4469    /**
4470     * @return The identifier that is used to identify this version of the terminology capabilities when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the terminology capabilities 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.
4471     */
4472    public String getVersion() { 
4473      return this.version == null ? null : this.version.getValue();
4474    }
4475
4476    /**
4477     * @param value The identifier that is used to identify this version of the terminology capabilities when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the terminology capabilities 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.
4478     */
4479    public TerminologyCapabilities setVersion(String value) { 
4480      if (Utilities.noString(value))
4481        this.version = null;
4482      else {
4483        if (this.version == null)
4484          this.version = new StringType();
4485        this.version.setValue(value);
4486      }
4487      return this;
4488    }
4489
4490    /**
4491     * @return {@link #name} (A natural language name identifying the terminology capabilities. 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
4492     */
4493    public StringType getNameElement() { 
4494      if (this.name == null)
4495        if (Configuration.errorOnAutoCreate())
4496          throw new Error("Attempt to auto-create TerminologyCapabilities.name");
4497        else if (Configuration.doAutoCreate())
4498          this.name = new StringType(); // bb
4499      return this.name;
4500    }
4501
4502    public boolean hasNameElement() { 
4503      return this.name != null && !this.name.isEmpty();
4504    }
4505
4506    public boolean hasName() { 
4507      return this.name != null && !this.name.isEmpty();
4508    }
4509
4510    /**
4511     * @param value {@link #name} (A natural language name identifying the terminology capabilities. 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
4512     */
4513    public TerminologyCapabilities setNameElement(StringType value) { 
4514      this.name = value;
4515      return this;
4516    }
4517
4518    /**
4519     * @return A natural language name identifying the terminology capabilities. This name should be usable as an identifier for the module by machine processing applications such as code generation.
4520     */
4521    public String getName() { 
4522      return this.name == null ? null : this.name.getValue();
4523    }
4524
4525    /**
4526     * @param value A natural language name identifying the terminology capabilities. This name should be usable as an identifier for the module by machine processing applications such as code generation.
4527     */
4528    public TerminologyCapabilities setName(String value) { 
4529      if (Utilities.noString(value))
4530        this.name = null;
4531      else {
4532        if (this.name == null)
4533          this.name = new StringType();
4534        this.name.setValue(value);
4535      }
4536      return this;
4537    }
4538
4539    /**
4540     * @return {@link #title} (A short, descriptive, user-friendly title for the terminology capabilities.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
4541     */
4542    public StringType getTitleElement() { 
4543      if (this.title == null)
4544        if (Configuration.errorOnAutoCreate())
4545          throw new Error("Attempt to auto-create TerminologyCapabilities.title");
4546        else if (Configuration.doAutoCreate())
4547          this.title = new StringType(); // bb
4548      return this.title;
4549    }
4550
4551    public boolean hasTitleElement() { 
4552      return this.title != null && !this.title.isEmpty();
4553    }
4554
4555    public boolean hasTitle() { 
4556      return this.title != null && !this.title.isEmpty();
4557    }
4558
4559    /**
4560     * @param value {@link #title} (A short, descriptive, user-friendly title for the terminology capabilities.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
4561     */
4562    public TerminologyCapabilities setTitleElement(StringType value) { 
4563      this.title = value;
4564      return this;
4565    }
4566
4567    /**
4568     * @return A short, descriptive, user-friendly title for the terminology capabilities.
4569     */
4570    public String getTitle() { 
4571      return this.title == null ? null : this.title.getValue();
4572    }
4573
4574    /**
4575     * @param value A short, descriptive, user-friendly title for the terminology capabilities.
4576     */
4577    public TerminologyCapabilities setTitle(String value) { 
4578      if (Utilities.noString(value))
4579        this.title = null;
4580      else {
4581        if (this.title == null)
4582          this.title = new StringType();
4583        this.title.setValue(value);
4584      }
4585      return this;
4586    }
4587
4588    /**
4589     * @return {@link #status} (The status of this terminology capabilities. 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
4590     */
4591    public Enumeration<PublicationStatus> getStatusElement() { 
4592      if (this.status == null)
4593        if (Configuration.errorOnAutoCreate())
4594          throw new Error("Attempt to auto-create TerminologyCapabilities.status");
4595        else if (Configuration.doAutoCreate())
4596          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb
4597      return this.status;
4598    }
4599
4600    public boolean hasStatusElement() { 
4601      return this.status != null && !this.status.isEmpty();
4602    }
4603
4604    public boolean hasStatus() { 
4605      return this.status != null && !this.status.isEmpty();
4606    }
4607
4608    /**
4609     * @param value {@link #status} (The status of this terminology capabilities. 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
4610     */
4611    public TerminologyCapabilities setStatusElement(Enumeration<PublicationStatus> value) { 
4612      this.status = value;
4613      return this;
4614    }
4615
4616    /**
4617     * @return The status of this terminology capabilities. Enables tracking the life-cycle of the content.
4618     */
4619    public PublicationStatus getStatus() { 
4620      return this.status == null ? null : this.status.getValue();
4621    }
4622
4623    /**
4624     * @param value The status of this terminology capabilities. Enables tracking the life-cycle of the content.
4625     */
4626    public TerminologyCapabilities setStatus(PublicationStatus value) { 
4627        if (this.status == null)
4628          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory());
4629        this.status.setValue(value);
4630      return this;
4631    }
4632
4633    /**
4634     * @return {@link #experimental} (A Boolean value to indicate that this terminology capabilities 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
4635     */
4636    public BooleanType getExperimentalElement() { 
4637      if (this.experimental == null)
4638        if (Configuration.errorOnAutoCreate())
4639          throw new Error("Attempt to auto-create TerminologyCapabilities.experimental");
4640        else if (Configuration.doAutoCreate())
4641          this.experimental = new BooleanType(); // bb
4642      return this.experimental;
4643    }
4644
4645    public boolean hasExperimentalElement() { 
4646      return this.experimental != null && !this.experimental.isEmpty();
4647    }
4648
4649    public boolean hasExperimental() { 
4650      return this.experimental != null && !this.experimental.isEmpty();
4651    }
4652
4653    /**
4654     * @param value {@link #experimental} (A Boolean value to indicate that this terminology capabilities 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
4655     */
4656    public TerminologyCapabilities setExperimentalElement(BooleanType value) { 
4657      this.experimental = value;
4658      return this;
4659    }
4660
4661    /**
4662     * @return A Boolean value to indicate that this terminology capabilities is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.
4663     */
4664    public boolean getExperimental() { 
4665      return this.experimental == null || this.experimental.isEmpty() ? false : this.experimental.getValue();
4666    }
4667
4668    /**
4669     * @param value A Boolean value to indicate that this terminology capabilities is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.
4670     */
4671    public TerminologyCapabilities setExperimental(boolean value) { 
4672        if (this.experimental == null)
4673          this.experimental = new BooleanType();
4674        this.experimental.setValue(value);
4675      return this;
4676    }
4677
4678    /**
4679     * @return {@link #date} (The date  (and optionally time) when the terminology capabilities was published. The date must change 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 terminology capabilities changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
4680     */
4681    public DateTimeType getDateElement() { 
4682      if (this.date == null)
4683        if (Configuration.errorOnAutoCreate())
4684          throw new Error("Attempt to auto-create TerminologyCapabilities.date");
4685        else if (Configuration.doAutoCreate())
4686          this.date = new DateTimeType(); // bb
4687      return this.date;
4688    }
4689
4690    public boolean hasDateElement() { 
4691      return this.date != null && !this.date.isEmpty();
4692    }
4693
4694    public boolean hasDate() { 
4695      return this.date != null && !this.date.isEmpty();
4696    }
4697
4698    /**
4699     * @param value {@link #date} (The date  (and optionally time) when the terminology capabilities was published. The date must change 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 terminology capabilities changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
4700     */
4701    public TerminologyCapabilities setDateElement(DateTimeType value) { 
4702      this.date = value;
4703      return this;
4704    }
4705
4706    /**
4707     * @return The date  (and optionally time) when the terminology capabilities was published. The date must change 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 terminology capabilities changes.
4708     */
4709    public Date getDate() { 
4710      return this.date == null ? null : this.date.getValue();
4711    }
4712
4713    /**
4714     * @param value The date  (and optionally time) when the terminology capabilities was published. The date must change 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 terminology capabilities changes.
4715     */
4716    public TerminologyCapabilities setDate(Date value) { 
4717        if (this.date == null)
4718          this.date = new DateTimeType();
4719        this.date.setValue(value);
4720      return this;
4721    }
4722
4723    /**
4724     * @return {@link #publisher} (The name of the organization or individual responsible for the release and ongoing maintenance of the terminology capabilities.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
4725     */
4726    public StringType getPublisherElement() { 
4727      if (this.publisher == null)
4728        if (Configuration.errorOnAutoCreate())
4729          throw new Error("Attempt to auto-create TerminologyCapabilities.publisher");
4730        else if (Configuration.doAutoCreate())
4731          this.publisher = new StringType(); // bb
4732      return this.publisher;
4733    }
4734
4735    public boolean hasPublisherElement() { 
4736      return this.publisher != null && !this.publisher.isEmpty();
4737    }
4738
4739    public boolean hasPublisher() { 
4740      return this.publisher != null && !this.publisher.isEmpty();
4741    }
4742
4743    /**
4744     * @param value {@link #publisher} (The name of the organization or individual responsible for the release and ongoing maintenance of the terminology capabilities.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
4745     */
4746    public TerminologyCapabilities setPublisherElement(StringType value) { 
4747      this.publisher = value;
4748      return this;
4749    }
4750
4751    /**
4752     * @return The name of the organization or individual responsible for the release and ongoing maintenance of the terminology capabilities.
4753     */
4754    public String getPublisher() { 
4755      return this.publisher == null ? null : this.publisher.getValue();
4756    }
4757
4758    /**
4759     * @param value The name of the organization or individual responsible for the release and ongoing maintenance of the terminology capabilities.
4760     */
4761    public TerminologyCapabilities setPublisher(String value) { 
4762      if (Utilities.noString(value))
4763        this.publisher = null;
4764      else {
4765        if (this.publisher == null)
4766          this.publisher = new StringType();
4767        this.publisher.setValue(value);
4768      }
4769      return this;
4770    }
4771
4772    /**
4773     * @return {@link #contact} (Contact details to assist a user in finding and communicating with the publisher.)
4774     */
4775    public List<ContactDetail> getContact() { 
4776      if (this.contact == null)
4777        this.contact = new ArrayList<ContactDetail>();
4778      return this.contact;
4779    }
4780
4781    /**
4782     * @return Returns a reference to <code>this</code> for easy method chaining
4783     */
4784    public TerminologyCapabilities setContact(List<ContactDetail> theContact) { 
4785      this.contact = theContact;
4786      return this;
4787    }
4788
4789    public boolean hasContact() { 
4790      if (this.contact == null)
4791        return false;
4792      for (ContactDetail item : this.contact)
4793        if (!item.isEmpty())
4794          return true;
4795      return false;
4796    }
4797
4798    public ContactDetail addContact() { //3
4799      ContactDetail t = new ContactDetail();
4800      if (this.contact == null)
4801        this.contact = new ArrayList<ContactDetail>();
4802      this.contact.add(t);
4803      return t;
4804    }
4805
4806    public TerminologyCapabilities addContact(ContactDetail t) { //3
4807      if (t == null)
4808        return this;
4809      if (this.contact == null)
4810        this.contact = new ArrayList<ContactDetail>();
4811      this.contact.add(t);
4812      return this;
4813    }
4814
4815    /**
4816     * @return The first repetition of repeating field {@link #contact}, creating it if it does not already exist {3}
4817     */
4818    public ContactDetail getContactFirstRep() { 
4819      if (getContact().isEmpty()) {
4820        addContact();
4821      }
4822      return getContact().get(0);
4823    }
4824
4825    /**
4826     * @return {@link #description} (A free text natural language description of the terminology capabilities from a consumer's perspective. Typically, this is used when the capability statement describes a desired rather than an actual solution, for example as a formal expression of requirements as part of an RFP.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
4827     */
4828    public MarkdownType getDescriptionElement() { 
4829      if (this.description == null)
4830        if (Configuration.errorOnAutoCreate())
4831          throw new Error("Attempt to auto-create TerminologyCapabilities.description");
4832        else if (Configuration.doAutoCreate())
4833          this.description = new MarkdownType(); // bb
4834      return this.description;
4835    }
4836
4837    public boolean hasDescriptionElement() { 
4838      return this.description != null && !this.description.isEmpty();
4839    }
4840
4841    public boolean hasDescription() { 
4842      return this.description != null && !this.description.isEmpty();
4843    }
4844
4845    /**
4846     * @param value {@link #description} (A free text natural language description of the terminology capabilities from a consumer's perspective. Typically, this is used when the capability statement describes a desired rather than an actual solution, for example as a formal expression of requirements as part of an RFP.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
4847     */
4848    public TerminologyCapabilities setDescriptionElement(MarkdownType value) { 
4849      this.description = value;
4850      return this;
4851    }
4852
4853    /**
4854     * @return A free text natural language description of the terminology capabilities from a consumer's perspective. Typically, this is used when the capability statement describes a desired rather than an actual solution, for example as a formal expression of requirements as part of an RFP.
4855     */
4856    public String getDescription() { 
4857      return this.description == null ? null : this.description.getValue();
4858    }
4859
4860    /**
4861     * @param value A free text natural language description of the terminology capabilities from a consumer's perspective. Typically, this is used when the capability statement describes a desired rather than an actual solution, for example as a formal expression of requirements as part of an RFP.
4862     */
4863    public TerminologyCapabilities setDescription(String value) { 
4864      if (value == null)
4865        this.description = null;
4866      else {
4867        if (this.description == null)
4868          this.description = new MarkdownType();
4869        this.description.setValue(value);
4870      }
4871      return this;
4872    }
4873
4874    /**
4875     * @return {@link #useContext} (The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate terminology capabilities instances.)
4876     */
4877    public List<UsageContext> getUseContext() { 
4878      if (this.useContext == null)
4879        this.useContext = new ArrayList<UsageContext>();
4880      return this.useContext;
4881    }
4882
4883    /**
4884     * @return Returns a reference to <code>this</code> for easy method chaining
4885     */
4886    public TerminologyCapabilities setUseContext(List<UsageContext> theUseContext) { 
4887      this.useContext = theUseContext;
4888      return this;
4889    }
4890
4891    public boolean hasUseContext() { 
4892      if (this.useContext == null)
4893        return false;
4894      for (UsageContext item : this.useContext)
4895        if (!item.isEmpty())
4896          return true;
4897      return false;
4898    }
4899
4900    public UsageContext addUseContext() { //3
4901      UsageContext t = new UsageContext();
4902      if (this.useContext == null)
4903        this.useContext = new ArrayList<UsageContext>();
4904      this.useContext.add(t);
4905      return t;
4906    }
4907
4908    public TerminologyCapabilities addUseContext(UsageContext t) { //3
4909      if (t == null)
4910        return this;
4911      if (this.useContext == null)
4912        this.useContext = new ArrayList<UsageContext>();
4913      this.useContext.add(t);
4914      return this;
4915    }
4916
4917    /**
4918     * @return The first repetition of repeating field {@link #useContext}, creating it if it does not already exist {3}
4919     */
4920    public UsageContext getUseContextFirstRep() { 
4921      if (getUseContext().isEmpty()) {
4922        addUseContext();
4923      }
4924      return getUseContext().get(0);
4925    }
4926
4927    /**
4928     * @return {@link #jurisdiction} (A legal or geographic region in which the terminology capabilities is intended to be used.)
4929     */
4930    public List<CodeableConcept> getJurisdiction() { 
4931      if (this.jurisdiction == null)
4932        this.jurisdiction = new ArrayList<CodeableConcept>();
4933      return this.jurisdiction;
4934    }
4935
4936    /**
4937     * @return Returns a reference to <code>this</code> for easy method chaining
4938     */
4939    public TerminologyCapabilities setJurisdiction(List<CodeableConcept> theJurisdiction) { 
4940      this.jurisdiction = theJurisdiction;
4941      return this;
4942    }
4943
4944    public boolean hasJurisdiction() { 
4945      if (this.jurisdiction == null)
4946        return false;
4947      for (CodeableConcept item : this.jurisdiction)
4948        if (!item.isEmpty())
4949          return true;
4950      return false;
4951    }
4952
4953    public CodeableConcept addJurisdiction() { //3
4954      CodeableConcept t = new CodeableConcept();
4955      if (this.jurisdiction == null)
4956        this.jurisdiction = new ArrayList<CodeableConcept>();
4957      this.jurisdiction.add(t);
4958      return t;
4959    }
4960
4961    public TerminologyCapabilities addJurisdiction(CodeableConcept t) { //3
4962      if (t == null)
4963        return this;
4964      if (this.jurisdiction == null)
4965        this.jurisdiction = new ArrayList<CodeableConcept>();
4966      this.jurisdiction.add(t);
4967      return this;
4968    }
4969
4970    /**
4971     * @return The first repetition of repeating field {@link #jurisdiction}, creating it if it does not already exist {3}
4972     */
4973    public CodeableConcept getJurisdictionFirstRep() { 
4974      if (getJurisdiction().isEmpty()) {
4975        addJurisdiction();
4976      }
4977      return getJurisdiction().get(0);
4978    }
4979
4980    /**
4981     * @return {@link #purpose} (Explanation of why this terminology capabilities 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
4982     */
4983    public MarkdownType getPurposeElement() { 
4984      if (this.purpose == null)
4985        if (Configuration.errorOnAutoCreate())
4986          throw new Error("Attempt to auto-create TerminologyCapabilities.purpose");
4987        else if (Configuration.doAutoCreate())
4988          this.purpose = new MarkdownType(); // bb
4989      return this.purpose;
4990    }
4991
4992    public boolean hasPurposeElement() { 
4993      return this.purpose != null && !this.purpose.isEmpty();
4994    }
4995
4996    public boolean hasPurpose() { 
4997      return this.purpose != null && !this.purpose.isEmpty();
4998    }
4999
5000    /**
5001     * @param value {@link #purpose} (Explanation of why this terminology capabilities 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
5002     */
5003    public TerminologyCapabilities setPurposeElement(MarkdownType value) { 
5004      this.purpose = value;
5005      return this;
5006    }
5007
5008    /**
5009     * @return Explanation of why this terminology capabilities is needed and why it has been designed as it has.
5010     */
5011    public String getPurpose() { 
5012      return this.purpose == null ? null : this.purpose.getValue();
5013    }
5014
5015    /**
5016     * @param value Explanation of why this terminology capabilities is needed and why it has been designed as it has.
5017     */
5018    public TerminologyCapabilities setPurpose(String value) { 
5019      if (value == null)
5020        this.purpose = null;
5021      else {
5022        if (this.purpose == null)
5023          this.purpose = new MarkdownType();
5024        this.purpose.setValue(value);
5025      }
5026      return this;
5027    }
5028
5029    /**
5030     * @return {@link #copyright} (A copyright statement relating to the terminology capabilities and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the terminology capabilities.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value
5031     */
5032    public MarkdownType getCopyrightElement() { 
5033      if (this.copyright == null)
5034        if (Configuration.errorOnAutoCreate())
5035          throw new Error("Attempt to auto-create TerminologyCapabilities.copyright");
5036        else if (Configuration.doAutoCreate())
5037          this.copyright = new MarkdownType(); // bb
5038      return this.copyright;
5039    }
5040
5041    public boolean hasCopyrightElement() { 
5042      return this.copyright != null && !this.copyright.isEmpty();
5043    }
5044
5045    public boolean hasCopyright() { 
5046      return this.copyright != null && !this.copyright.isEmpty();
5047    }
5048
5049    /**
5050     * @param value {@link #copyright} (A copyright statement relating to the terminology capabilities and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the terminology capabilities.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value
5051     */
5052    public TerminologyCapabilities setCopyrightElement(MarkdownType value) { 
5053      this.copyright = value;
5054      return this;
5055    }
5056
5057    /**
5058     * @return A copyright statement relating to the terminology capabilities and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the terminology capabilities.
5059     */
5060    public String getCopyright() { 
5061      return this.copyright == null ? null : this.copyright.getValue();
5062    }
5063
5064    /**
5065     * @param value A copyright statement relating to the terminology capabilities and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the terminology capabilities.
5066     */
5067    public TerminologyCapabilities setCopyright(String value) { 
5068      if (value == null)
5069        this.copyright = null;
5070      else {
5071        if (this.copyright == null)
5072          this.copyright = new MarkdownType();
5073        this.copyright.setValue(value);
5074      }
5075      return this;
5076    }
5077
5078    /**
5079     * @return {@link #kind} (The way that this statement is intended to be used, to describe an actual running instance of software, a particular product (kind, not instance of software) or a class of implementation (e.g. a desired purchase).). This is the underlying object with id, value and extensions. The accessor "getKind" gives direct access to the value
5080     */
5081    public Enumeration<CapabilityStatementKind> getKindElement() { 
5082      if (this.kind == null)
5083        if (Configuration.errorOnAutoCreate())
5084          throw new Error("Attempt to auto-create TerminologyCapabilities.kind");
5085        else if (Configuration.doAutoCreate())
5086          this.kind = new Enumeration<CapabilityStatementKind>(new CapabilityStatementKindEnumFactory()); // bb
5087      return this.kind;
5088    }
5089
5090    public boolean hasKindElement() { 
5091      return this.kind != null && !this.kind.isEmpty();
5092    }
5093
5094    public boolean hasKind() { 
5095      return this.kind != null && !this.kind.isEmpty();
5096    }
5097
5098    /**
5099     * @param value {@link #kind} (The way that this statement is intended to be used, to describe an actual running instance of software, a particular product (kind, not instance of software) or a class of implementation (e.g. a desired purchase).). This is the underlying object with id, value and extensions. The accessor "getKind" gives direct access to the value
5100     */
5101    public TerminologyCapabilities setKindElement(Enumeration<CapabilityStatementKind> value) { 
5102      this.kind = value;
5103      return this;
5104    }
5105
5106    /**
5107     * @return The way that this statement is intended to be used, to describe an actual running instance of software, a particular product (kind, not instance of software) or a class of implementation (e.g. a desired purchase).
5108     */
5109    public CapabilityStatementKind getKind() { 
5110      return this.kind == null ? null : this.kind.getValue();
5111    }
5112
5113    /**
5114     * @param value The way that this statement is intended to be used, to describe an actual running instance of software, a particular product (kind, not instance of software) or a class of implementation (e.g. a desired purchase).
5115     */
5116    public TerminologyCapabilities setKind(CapabilityStatementKind value) { 
5117        if (this.kind == null)
5118          this.kind = new Enumeration<CapabilityStatementKind>(new CapabilityStatementKindEnumFactory());
5119        this.kind.setValue(value);
5120      return this;
5121    }
5122
5123    /**
5124     * @return {@link #software} (Software that is covered by this terminology capability statement.  It is used when the statement describes the capabilities of a particular software version, independent of an installation.)
5125     */
5126    public TerminologyCapabilitiesSoftwareComponent getSoftware() { 
5127      if (this.software == null)
5128        if (Configuration.errorOnAutoCreate())
5129          throw new Error("Attempt to auto-create TerminologyCapabilities.software");
5130        else if (Configuration.doAutoCreate())
5131          this.software = new TerminologyCapabilitiesSoftwareComponent(); // cc
5132      return this.software;
5133    }
5134
5135    public boolean hasSoftware() { 
5136      return this.software != null && !this.software.isEmpty();
5137    }
5138
5139    /**
5140     * @param value {@link #software} (Software that is covered by this terminology capability statement.  It is used when the statement describes the capabilities of a particular software version, independent of an installation.)
5141     */
5142    public TerminologyCapabilities setSoftware(TerminologyCapabilitiesSoftwareComponent value) { 
5143      this.software = value;
5144      return this;
5145    }
5146
5147    /**
5148     * @return {@link #implementation} (Identifies a specific implementation instance that is described by the terminology capability statement - i.e. a particular installation, rather than the capabilities of a software program.)
5149     */
5150    public TerminologyCapabilitiesImplementationComponent getImplementation() { 
5151      if (this.implementation == null)
5152        if (Configuration.errorOnAutoCreate())
5153          throw new Error("Attempt to auto-create TerminologyCapabilities.implementation");
5154        else if (Configuration.doAutoCreate())
5155          this.implementation = new TerminologyCapabilitiesImplementationComponent(); // cc
5156      return this.implementation;
5157    }
5158
5159    public boolean hasImplementation() { 
5160      return this.implementation != null && !this.implementation.isEmpty();
5161    }
5162
5163    /**
5164     * @param value {@link #implementation} (Identifies a specific implementation instance that is described by the terminology capability statement - i.e. a particular installation, rather than the capabilities of a software program.)
5165     */
5166    public TerminologyCapabilities setImplementation(TerminologyCapabilitiesImplementationComponent value) { 
5167      this.implementation = value;
5168      return this;
5169    }
5170
5171    /**
5172     * @return {@link #lockedDate} (Whether the server supports lockedDate.). This is the underlying object with id, value and extensions. The accessor "getLockedDate" gives direct access to the value
5173     */
5174    public BooleanType getLockedDateElement() { 
5175      if (this.lockedDate == null)
5176        if (Configuration.errorOnAutoCreate())
5177          throw new Error("Attempt to auto-create TerminologyCapabilities.lockedDate");
5178        else if (Configuration.doAutoCreate())
5179          this.lockedDate = new BooleanType(); // bb
5180      return this.lockedDate;
5181    }
5182
5183    public boolean hasLockedDateElement() { 
5184      return this.lockedDate != null && !this.lockedDate.isEmpty();
5185    }
5186
5187    public boolean hasLockedDate() { 
5188      return this.lockedDate != null && !this.lockedDate.isEmpty();
5189    }
5190
5191    /**
5192     * @param value {@link #lockedDate} (Whether the server supports lockedDate.). This is the underlying object with id, value and extensions. The accessor "getLockedDate" gives direct access to the value
5193     */
5194    public TerminologyCapabilities setLockedDateElement(BooleanType value) { 
5195      this.lockedDate = value;
5196      return this;
5197    }
5198
5199    /**
5200     * @return Whether the server supports lockedDate.
5201     */
5202    public boolean getLockedDate() { 
5203      return this.lockedDate == null || this.lockedDate.isEmpty() ? false : this.lockedDate.getValue();
5204    }
5205
5206    /**
5207     * @param value Whether the server supports lockedDate.
5208     */
5209    public TerminologyCapabilities setLockedDate(boolean value) { 
5210        if (this.lockedDate == null)
5211          this.lockedDate = new BooleanType();
5212        this.lockedDate.setValue(value);
5213      return this;
5214    }
5215
5216    /**
5217     * @return {@link #codeSystem} (Identifies a code system that is supported by the server. If there is a no code system URL, then this declares the general assumptions a client can make about support for any CodeSystem resource.)
5218     */
5219    public List<TerminologyCapabilitiesCodeSystemComponent> getCodeSystem() { 
5220      if (this.codeSystem == null)
5221        this.codeSystem = new ArrayList<TerminologyCapabilitiesCodeSystemComponent>();
5222      return this.codeSystem;
5223    }
5224
5225    /**
5226     * @return Returns a reference to <code>this</code> for easy method chaining
5227     */
5228    public TerminologyCapabilities setCodeSystem(List<TerminologyCapabilitiesCodeSystemComponent> theCodeSystem) { 
5229      this.codeSystem = theCodeSystem;
5230      return this;
5231    }
5232
5233    public boolean hasCodeSystem() { 
5234      if (this.codeSystem == null)
5235        return false;
5236      for (TerminologyCapabilitiesCodeSystemComponent item : this.codeSystem)
5237        if (!item.isEmpty())
5238          return true;
5239      return false;
5240    }
5241
5242    public TerminologyCapabilitiesCodeSystemComponent addCodeSystem() { //3
5243      TerminologyCapabilitiesCodeSystemComponent t = new TerminologyCapabilitiesCodeSystemComponent();
5244      if (this.codeSystem == null)
5245        this.codeSystem = new ArrayList<TerminologyCapabilitiesCodeSystemComponent>();
5246      this.codeSystem.add(t);
5247      return t;
5248    }
5249
5250    public TerminologyCapabilities addCodeSystem(TerminologyCapabilitiesCodeSystemComponent t) { //3
5251      if (t == null)
5252        return this;
5253      if (this.codeSystem == null)
5254        this.codeSystem = new ArrayList<TerminologyCapabilitiesCodeSystemComponent>();
5255      this.codeSystem.add(t);
5256      return this;
5257    }
5258
5259    /**
5260     * @return The first repetition of repeating field {@link #codeSystem}, creating it if it does not already exist {3}
5261     */
5262    public TerminologyCapabilitiesCodeSystemComponent getCodeSystemFirstRep() { 
5263      if (getCodeSystem().isEmpty()) {
5264        addCodeSystem();
5265      }
5266      return getCodeSystem().get(0);
5267    }
5268
5269    /**
5270     * @return {@link #expansion} (Information about the [ValueSet/$expand](valueset-operation-expand.html) operation.)
5271     */
5272    public TerminologyCapabilitiesExpansionComponent getExpansion() { 
5273      if (this.expansion == null)
5274        if (Configuration.errorOnAutoCreate())
5275          throw new Error("Attempt to auto-create TerminologyCapabilities.expansion");
5276        else if (Configuration.doAutoCreate())
5277          this.expansion = new TerminologyCapabilitiesExpansionComponent(); // cc
5278      return this.expansion;
5279    }
5280
5281    public boolean hasExpansion() { 
5282      return this.expansion != null && !this.expansion.isEmpty();
5283    }
5284
5285    /**
5286     * @param value {@link #expansion} (Information about the [ValueSet/$expand](valueset-operation-expand.html) operation.)
5287     */
5288    public TerminologyCapabilities setExpansion(TerminologyCapabilitiesExpansionComponent value) { 
5289      this.expansion = value;
5290      return this;
5291    }
5292
5293    /**
5294     * @return {@link #codeSearch} (The degree to which the server supports the code search parameter on ValueSet, if it is supported.). This is the underlying object with id, value and extensions. The accessor "getCodeSearch" gives direct access to the value
5295     */
5296    public Enumeration<CodeSearchSupport> getCodeSearchElement() { 
5297      if (this.codeSearch == null)
5298        if (Configuration.errorOnAutoCreate())
5299          throw new Error("Attempt to auto-create TerminologyCapabilities.codeSearch");
5300        else if (Configuration.doAutoCreate())
5301          this.codeSearch = new Enumeration<CodeSearchSupport>(new CodeSearchSupportEnumFactory()); // bb
5302      return this.codeSearch;
5303    }
5304
5305    public boolean hasCodeSearchElement() { 
5306      return this.codeSearch != null && !this.codeSearch.isEmpty();
5307    }
5308
5309    public boolean hasCodeSearch() { 
5310      return this.codeSearch != null && !this.codeSearch.isEmpty();
5311    }
5312
5313    /**
5314     * @param value {@link #codeSearch} (The degree to which the server supports the code search parameter on ValueSet, if it is supported.). This is the underlying object with id, value and extensions. The accessor "getCodeSearch" gives direct access to the value
5315     */
5316    public TerminologyCapabilities setCodeSearchElement(Enumeration<CodeSearchSupport> value) { 
5317      this.codeSearch = value;
5318      return this;
5319    }
5320
5321    /**
5322     * @return The degree to which the server supports the code search parameter on ValueSet, if it is supported.
5323     */
5324    public CodeSearchSupport getCodeSearch() { 
5325      return this.codeSearch == null ? null : this.codeSearch.getValue();
5326    }
5327
5328    /**
5329     * @param value The degree to which the server supports the code search parameter on ValueSet, if it is supported.
5330     */
5331    public TerminologyCapabilities setCodeSearch(CodeSearchSupport value) { 
5332      if (value == null)
5333        this.codeSearch = null;
5334      else {
5335        if (this.codeSearch == null)
5336          this.codeSearch = new Enumeration<CodeSearchSupport>(new CodeSearchSupportEnumFactory());
5337        this.codeSearch.setValue(value);
5338      }
5339      return this;
5340    }
5341
5342    /**
5343     * @return {@link #validateCode} (Information about the [ValueSet/$validate-code](valueset-operation-validate-code.html) operation.)
5344     */
5345    public TerminologyCapabilitiesValidateCodeComponent getValidateCode() { 
5346      if (this.validateCode == null)
5347        if (Configuration.errorOnAutoCreate())
5348          throw new Error("Attempt to auto-create TerminologyCapabilities.validateCode");
5349        else if (Configuration.doAutoCreate())
5350          this.validateCode = new TerminologyCapabilitiesValidateCodeComponent(); // cc
5351      return this.validateCode;
5352    }
5353
5354    public boolean hasValidateCode() { 
5355      return this.validateCode != null && !this.validateCode.isEmpty();
5356    }
5357
5358    /**
5359     * @param value {@link #validateCode} (Information about the [ValueSet/$validate-code](valueset-operation-validate-code.html) operation.)
5360     */
5361    public TerminologyCapabilities setValidateCode(TerminologyCapabilitiesValidateCodeComponent value) { 
5362      this.validateCode = value;
5363      return this;
5364    }
5365
5366    /**
5367     * @return {@link #translation} (Information about the [ConceptMap/$translate](conceptmap-operation-translate.html) operation.)
5368     */
5369    public TerminologyCapabilitiesTranslationComponent getTranslation() { 
5370      if (this.translation == null)
5371        if (Configuration.errorOnAutoCreate())
5372          throw new Error("Attempt to auto-create TerminologyCapabilities.translation");
5373        else if (Configuration.doAutoCreate())
5374          this.translation = new TerminologyCapabilitiesTranslationComponent(); // cc
5375      return this.translation;
5376    }
5377
5378    public boolean hasTranslation() { 
5379      return this.translation != null && !this.translation.isEmpty();
5380    }
5381
5382    /**
5383     * @param value {@link #translation} (Information about the [ConceptMap/$translate](conceptmap-operation-translate.html) operation.)
5384     */
5385    public TerminologyCapabilities setTranslation(TerminologyCapabilitiesTranslationComponent value) { 
5386      this.translation = value;
5387      return this;
5388    }
5389
5390    /**
5391     * @return {@link #closure} (Whether the $closure operation is supported.)
5392     */
5393    public TerminologyCapabilitiesClosureComponent getClosure() { 
5394      if (this.closure == null)
5395        if (Configuration.errorOnAutoCreate())
5396          throw new Error("Attempt to auto-create TerminologyCapabilities.closure");
5397        else if (Configuration.doAutoCreate())
5398          this.closure = new TerminologyCapabilitiesClosureComponent(); // cc
5399      return this.closure;
5400    }
5401
5402    public boolean hasClosure() { 
5403      return this.closure != null && !this.closure.isEmpty();
5404    }
5405
5406    /**
5407     * @param value {@link #closure} (Whether the $closure operation is supported.)
5408     */
5409    public TerminologyCapabilities setClosure(TerminologyCapabilitiesClosureComponent value) { 
5410      this.closure = value;
5411      return this;
5412    }
5413
5414    /**
5415     * not supported on this implementation
5416     */
5417    @Override
5418    public int getVersionAlgorithmMax() { 
5419      return 0;
5420    }
5421    /**
5422     * @return {@link #versionAlgorithm} (Indicates the mechanism used to compare versions to determine which is more current.)
5423     */
5424    public DataType getVersionAlgorithm() { 
5425      throw new Error("The resource type \"TerminologyCapabilities\" does not implement the property \"versionAlgorithm[x]\""); 
5426    }
5427    /**
5428     * @return {@link #versionAlgorithm} (Indicates the mechanism used to compare versions to determine which is more current.)
5429     */
5430    public StringType getVersionAlgorithmStringType() { 
5431      throw new Error("The resource type \"TerminologyCapabilities\" does not implement the property \"versionAlgorithm[x]\""); 
5432    }
5433    public boolean hasVersionAlgorithmStringType() { 
5434      return false;////K 
5435    }
5436    /**
5437     * @return {@link #versionAlgorithm} (Indicates the mechanism used to compare versions to determine which is more current.)
5438     */
5439    public Coding getVersionAlgorithmCoding() { 
5440      throw new Error("The resource type \"TerminologyCapabilities\" does not implement the property \"versionAlgorithm[x]\""); 
5441    }
5442    public boolean hasVersionAlgorithmCoding() { 
5443      return false;////K 
5444    }
5445    public boolean hasVersionAlgorithm() { 
5446      return false;
5447    }
5448    /**
5449     * @param value {@link #versionAlgorithm} (Indicates the mechanism used to compare versions to determine which is more current.)
5450     */
5451    public TerminologyCapabilities setVersionAlgorithm(DataType value) { 
5452      throw new Error("The resource type \"TerminologyCapabilities\" does not implement the property \"versionAlgorithm[x]\""); 
5453    }
5454
5455    /**
5456     * not supported on this implementation
5457     */
5458    @Override
5459    public int getCopyrightLabelMax() { 
5460      return 0;
5461    }
5462    /**
5463     * @return {@link #copyrightLabel} (A short string (<50 characters), suitable for inclusion in a page footer that identifies the copyright holder, effective period, and optionally whether rights are resctricted. (e.g. 'All rights reserved', 'Some rights reserved').). This is the underlying object with id, value and extensions. The accessor "getCopyrightLabel" gives direct access to the value
5464     */
5465    public StringType getCopyrightLabelElement() { 
5466      throw new Error("The resource type \"TerminologyCapabilities\" does not implement the property \"copyrightLabel\"");
5467    }
5468
5469    public boolean hasCopyrightLabelElement() { 
5470      return false;
5471    }
5472    public boolean hasCopyrightLabel() {
5473      return false;
5474    }
5475
5476    /**
5477     * @param value {@link #copyrightLabel} (A short string (<50 characters), suitable for inclusion in a page footer that identifies the copyright holder, effective period, and optionally whether rights are resctricted. (e.g. 'All rights reserved', 'Some rights reserved').). This is the underlying object with id, value and extensions. The accessor "getCopyrightLabel" gives direct access to the value
5478     */
5479    public TerminologyCapabilities setCopyrightLabelElement(StringType value) { 
5480      throw new Error("The resource type \"TerminologyCapabilities\" does not implement the property \"copyrightLabel\""); 
5481    }
5482    public String getCopyrightLabel() { 
5483      throw new Error("The resource type \"TerminologyCapabilities\" does not implement the property \"copyrightLabel\""); 
5484    }
5485    /**
5486     * @param value A short string (<50 characters), suitable for inclusion in a page footer that identifies the copyright holder, effective period, and optionally whether rights are resctricted. (e.g. 'All rights reserved', 'Some rights reserved').
5487     */
5488    public TerminologyCapabilities setCopyrightLabel(String value) { 
5489      throw new Error("The resource type \"TerminologyCapabilities\" does not implement the property \"copyrightLabel\""); 
5490    }
5491      protected void listChildren(List<Property> children) {
5492        super.listChildren(children);
5493        children.add(new Property("url", "uri", "An absolute URI that is used to identify this terminology capabilities when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which an authoritative instance of this terminology capabilities is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the terminology capabilities is stored on different servers.", 0, 1, url));
5494        children.add(new Property("identifier", "Identifier", "A formal identifier that is used to identify this terminology capabilities when it is represented in other formats, or referenced in a specification, model, design or an instance.", 0, java.lang.Integer.MAX_VALUE, identifier));
5495        children.add(new Property("version", "string", "The identifier that is used to identify this version of the terminology capabilities when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the terminology capabilities 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));
5496        children.add(new Property("name", "string", "A natural language name identifying the terminology capabilities. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name));
5497        children.add(new Property("title", "string", "A short, descriptive, user-friendly title for the terminology capabilities.", 0, 1, title));
5498        children.add(new Property("status", "code", "The status of this terminology capabilities. Enables tracking the life-cycle of the content.", 0, 1, status));
5499        children.add(new Property("experimental", "boolean", "A Boolean value to indicate that this terminology capabilities is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.", 0, 1, experimental));
5500        children.add(new Property("date", "dateTime", "The date  (and optionally time) when the terminology capabilities was published. The date must change 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 terminology capabilities changes.", 0, 1, date));
5501        children.add(new Property("publisher", "string", "The name of the organization or individual responsible for the release and ongoing maintenance of the terminology capabilities.", 0, 1, publisher));
5502        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));
5503        children.add(new Property("description", "markdown", "A free text natural language description of the terminology capabilities from a consumer's perspective. Typically, this is used when the capability statement describes a desired rather than an actual solution, for example as a formal expression of requirements as part of an RFP.", 0, 1, description));
5504        children.add(new Property("useContext", "UsageContext", "The content was developed with a focus and intent of supporting the contexts that are listed. These contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate terminology capabilities instances.", 0, java.lang.Integer.MAX_VALUE, useContext));
5505        children.add(new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the terminology capabilities is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction));
5506        children.add(new Property("purpose", "markdown", "Explanation of why this terminology capabilities is needed and why it has been designed as it has.", 0, 1, purpose));
5507        children.add(new Property("copyright", "markdown", "A copyright statement relating to the terminology capabilities and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the terminology capabilities.", 0, 1, copyright));
5508        children.add(new Property("kind", "code", "The way that this statement is intended to be used, to describe an actual running instance of software, a particular product (kind, not instance of software) or a class of implementation (e.g. a desired purchase).", 0, 1, kind));
5509        children.add(new Property("software", "", "Software that is covered by this terminology capability statement.  It is used when the statement describes the capabilities of a particular software version, independent of an installation.", 0, 1, software));
5510        children.add(new Property("implementation", "", "Identifies a specific implementation instance that is described by the terminology capability statement - i.e. a particular installation, rather than the capabilities of a software program.", 0, 1, implementation));
5511        children.add(new Property("lockedDate", "boolean", "Whether the server supports lockedDate.", 0, 1, lockedDate));
5512        children.add(new Property("codeSystem", "", "Identifies a code system that is supported by the server. If there is a no code system URL, then this declares the general assumptions a client can make about support for any CodeSystem resource.", 0, java.lang.Integer.MAX_VALUE, codeSystem));
5513        children.add(new Property("expansion", "", "Information about the [ValueSet/$expand](valueset-operation-expand.html) operation.", 0, 1, expansion));
5514        children.add(new Property("codeSearch", "code", "The degree to which the server supports the code search parameter on ValueSet, if it is supported.", 0, 1, codeSearch));
5515        children.add(new Property("validateCode", "", "Information about the [ValueSet/$validate-code](valueset-operation-validate-code.html) operation.", 0, 1, validateCode));
5516        children.add(new Property("translation", "", "Information about the [ConceptMap/$translate](conceptmap-operation-translate.html) operation.", 0, 1, translation));
5517        children.add(new Property("closure", "", "Whether the $closure operation is supported.", 0, 1, closure));
5518      }
5519
5520      @Override
5521      public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
5522        switch (_hash) {
5523        case 116079: /*url*/  return new Property("url", "uri", "An absolute URI that is used to identify this terminology capabilities when it is referenced in a specification, model, design or an instance; also called its canonical identifier. This SHOULD be globally unique and SHOULD be a literal address at which an authoritative instance of this terminology capabilities is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the terminology capabilities is stored on different servers.", 0, 1, url);
5524        case -1618432855: /*identifier*/  return new Property("identifier", "Identifier", "A formal identifier that is used to identify this terminology capabilities when it is represented in other formats, or referenced in a specification, model, design or an instance.", 0, java.lang.Integer.MAX_VALUE, identifier);
5525        case 351608024: /*version*/  return new Property("version", "string", "The identifier that is used to identify this version of the terminology capabilities when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the terminology capabilities 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);
5526        case 3373707: /*name*/  return new Property("name", "string", "A natural language name identifying the terminology capabilities. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name);
5527        case 110371416: /*title*/  return new Property("title", "string", "A short, descriptive, user-friendly title for the terminology capabilities.", 0, 1, title);
5528        case -892481550: /*status*/  return new Property("status", "code", "The status of this terminology capabilities. Enables tracking the life-cycle of the content.", 0, 1, status);
5529        case -404562712: /*experimental*/  return new Property("experimental", "boolean", "A Boolean value to indicate that this terminology capabilities is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.", 0, 1, experimental);
5530        case 3076014: /*date*/  return new Property("date", "dateTime", "The date  (and optionally time) when the terminology capabilities was published. The date must change 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 terminology capabilities changes.", 0, 1, date);
5531        case 1447404028: /*publisher*/  return new Property("publisher", "string", "The name of the organization or individual responsible for the release and ongoing maintenance of the terminology capabilities.", 0, 1, publisher);
5532        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);
5533        case -1724546052: /*description*/  return new Property("description", "markdown", "A free text natural language description of the terminology capabilities from a consumer's perspective. Typically, this is used when the capability statement describes a desired rather than an actual solution, for example as a formal expression of requirements as part of an RFP.", 0, 1, description);
5534        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 contexts may be general categories (gender, age, ...) or may be references to specific programs (insurance plans, studies, ...) and may be used to assist with indexing and searching for appropriate terminology capabilities instances.", 0, java.lang.Integer.MAX_VALUE, useContext);
5535        case -507075711: /*jurisdiction*/  return new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the terminology capabilities is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction);
5536        case -220463842: /*purpose*/  return new Property("purpose", "markdown", "Explanation of why this terminology capabilities is needed and why it has been designed as it has.", 0, 1, purpose);
5537        case 1522889671: /*copyright*/  return new Property("copyright", "markdown", "A copyright statement relating to the terminology capabilities and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the terminology capabilities.", 0, 1, copyright);
5538        case 3292052: /*kind*/  return new Property("kind", "code", "The way that this statement is intended to be used, to describe an actual running instance of software, a particular product (kind, not instance of software) or a class of implementation (e.g. a desired purchase).", 0, 1, kind);
5539        case 1319330215: /*software*/  return new Property("software", "", "Software that is covered by this terminology capability statement.  It is used when the statement describes the capabilities of a particular software version, independent of an installation.", 0, 1, software);
5540        case 1683336114: /*implementation*/  return new Property("implementation", "", "Identifies a specific implementation instance that is described by the terminology capability statement - i.e. a particular installation, rather than the capabilities of a software program.", 0, 1, implementation);
5541        case 1391591896: /*lockedDate*/  return new Property("lockedDate", "boolean", "Whether the server supports lockedDate.", 0, 1, lockedDate);
5542        case -916511108: /*codeSystem*/  return new Property("codeSystem", "", "Identifies a code system that is supported by the server. If there is a no code system URL, then this declares the general assumptions a client can make about support for any CodeSystem resource.", 0, java.lang.Integer.MAX_VALUE, codeSystem);
5543        case 17878207: /*expansion*/  return new Property("expansion", "", "Information about the [ValueSet/$expand](valueset-operation-expand.html) operation.", 0, 1, expansion);
5544        case -935519755: /*codeSearch*/  return new Property("codeSearch", "code", "The degree to which the server supports the code search parameter on ValueSet, if it is supported.", 0, 1, codeSearch);
5545        case 1080737827: /*validateCode*/  return new Property("validateCode", "", "Information about the [ValueSet/$validate-code](valueset-operation-validate-code.html) operation.", 0, 1, validateCode);
5546        case -1840647503: /*translation*/  return new Property("translation", "", "Information about the [ConceptMap/$translate](conceptmap-operation-translate.html) operation.", 0, 1, translation);
5547        case 866552379: /*closure*/  return new Property("closure", "", "Whether the $closure operation is supported.", 0, 1, closure);
5548        default: return super.getNamedProperty(_hash, _name, _checkValid);
5549        }
5550
5551      }
5552
5553      @Override
5554      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
5555        switch (hash) {
5556        case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType
5557        case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier
5558        case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType
5559        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
5560        case 110371416: /*title*/ return this.title == null ? new Base[0] : new Base[] {this.title}; // StringType
5561        case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<PublicationStatus>
5562        case -404562712: /*experimental*/ return this.experimental == null ? new Base[0] : new Base[] {this.experimental}; // BooleanType
5563        case 3076014: /*date*/ return this.date == null ? new Base[0] : new Base[] {this.date}; // DateTimeType
5564        case 1447404028: /*publisher*/ return this.publisher == null ? new Base[0] : new Base[] {this.publisher}; // StringType
5565        case 951526432: /*contact*/ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail
5566        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType
5567        case -669707736: /*useContext*/ return this.useContext == null ? new Base[0] : this.useContext.toArray(new Base[this.useContext.size()]); // UsageContext
5568        case -507075711: /*jurisdiction*/ return this.jurisdiction == null ? new Base[0] : this.jurisdiction.toArray(new Base[this.jurisdiction.size()]); // CodeableConcept
5569        case -220463842: /*purpose*/ return this.purpose == null ? new Base[0] : new Base[] {this.purpose}; // MarkdownType
5570        case 1522889671: /*copyright*/ return this.copyright == null ? new Base[0] : new Base[] {this.copyright}; // MarkdownType
5571        case 3292052: /*kind*/ return this.kind == null ? new Base[0] : new Base[] {this.kind}; // Enumeration<CapabilityStatementKind>
5572        case 1319330215: /*software*/ return this.software == null ? new Base[0] : new Base[] {this.software}; // TerminologyCapabilitiesSoftwareComponent
5573        case 1683336114: /*implementation*/ return this.implementation == null ? new Base[0] : new Base[] {this.implementation}; // TerminologyCapabilitiesImplementationComponent
5574        case 1391591896: /*lockedDate*/ return this.lockedDate == null ? new Base[0] : new Base[] {this.lockedDate}; // BooleanType
5575        case -916511108: /*codeSystem*/ return this.codeSystem == null ? new Base[0] : this.codeSystem.toArray(new Base[this.codeSystem.size()]); // TerminologyCapabilitiesCodeSystemComponent
5576        case 17878207: /*expansion*/ return this.expansion == null ? new Base[0] : new Base[] {this.expansion}; // TerminologyCapabilitiesExpansionComponent
5577        case -935519755: /*codeSearch*/ return this.codeSearch == null ? new Base[0] : new Base[] {this.codeSearch}; // Enumeration<CodeSearchSupport>
5578        case 1080737827: /*validateCode*/ return this.validateCode == null ? new Base[0] : new Base[] {this.validateCode}; // TerminologyCapabilitiesValidateCodeComponent
5579        case -1840647503: /*translation*/ return this.translation == null ? new Base[0] : new Base[] {this.translation}; // TerminologyCapabilitiesTranslationComponent
5580        case 866552379: /*closure*/ return this.closure == null ? new Base[0] : new Base[] {this.closure}; // TerminologyCapabilitiesClosureComponent
5581        default: return super.getProperty(hash, name, checkValid);
5582        }
5583
5584      }
5585
5586      @Override
5587      public Base setProperty(int hash, String name, Base value) throws FHIRException {
5588        switch (hash) {
5589        case 116079: // url
5590          this.url = TypeConvertor.castToUri(value); // UriType
5591          return value;
5592        case -1618432855: // identifier
5593          this.getIdentifier().add(TypeConvertor.castToIdentifier(value)); // Identifier
5594          return value;
5595        case 351608024: // version
5596          this.version = TypeConvertor.castToString(value); // StringType
5597          return value;
5598        case 3373707: // name
5599          this.name = TypeConvertor.castToString(value); // StringType
5600          return value;
5601        case 110371416: // title
5602          this.title = TypeConvertor.castToString(value); // StringType
5603          return value;
5604        case -892481550: // status
5605          value = new PublicationStatusEnumFactory().fromType(TypeConvertor.castToCode(value));
5606          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
5607          return value;
5608        case -404562712: // experimental
5609          this.experimental = TypeConvertor.castToBoolean(value); // BooleanType
5610          return value;
5611        case 3076014: // date
5612          this.date = TypeConvertor.castToDateTime(value); // DateTimeType
5613          return value;
5614        case 1447404028: // publisher
5615          this.publisher = TypeConvertor.castToString(value); // StringType
5616          return value;
5617        case 951526432: // contact
5618          this.getContact().add(TypeConvertor.castToContactDetail(value)); // ContactDetail
5619          return value;
5620        case -1724546052: // description
5621          this.description = TypeConvertor.castToMarkdown(value); // MarkdownType
5622          return value;
5623        case -669707736: // useContext
5624          this.getUseContext().add(TypeConvertor.castToUsageContext(value)); // UsageContext
5625          return value;
5626        case -507075711: // jurisdiction
5627          this.getJurisdiction().add(TypeConvertor.castToCodeableConcept(value)); // CodeableConcept
5628          return value;
5629        case -220463842: // purpose
5630          this.purpose = TypeConvertor.castToMarkdown(value); // MarkdownType
5631          return value;
5632        case 1522889671: // copyright
5633          this.copyright = TypeConvertor.castToMarkdown(value); // MarkdownType
5634          return value;
5635        case 3292052: // kind
5636          value = new CapabilityStatementKindEnumFactory().fromType(TypeConvertor.castToCode(value));
5637          this.kind = (Enumeration) value; // Enumeration<CapabilityStatementKind>
5638          return value;
5639        case 1319330215: // software
5640          this.software = (TerminologyCapabilitiesSoftwareComponent) value; // TerminologyCapabilitiesSoftwareComponent
5641          return value;
5642        case 1683336114: // implementation
5643          this.implementation = (TerminologyCapabilitiesImplementationComponent) value; // TerminologyCapabilitiesImplementationComponent
5644          return value;
5645        case 1391591896: // lockedDate
5646          this.lockedDate = TypeConvertor.castToBoolean(value); // BooleanType
5647          return value;
5648        case -916511108: // codeSystem
5649          this.getCodeSystem().add((TerminologyCapabilitiesCodeSystemComponent) value); // TerminologyCapabilitiesCodeSystemComponent
5650          return value;
5651        case 17878207: // expansion
5652          this.expansion = (TerminologyCapabilitiesExpansionComponent) value; // TerminologyCapabilitiesExpansionComponent
5653          return value;
5654        case -935519755: // codeSearch
5655          value = new CodeSearchSupportEnumFactory().fromType(TypeConvertor.castToCode(value));
5656          this.codeSearch = (Enumeration) value; // Enumeration<CodeSearchSupport>
5657          return value;
5658        case 1080737827: // validateCode
5659          this.validateCode = (TerminologyCapabilitiesValidateCodeComponent) value; // TerminologyCapabilitiesValidateCodeComponent
5660          return value;
5661        case -1840647503: // translation
5662          this.translation = (TerminologyCapabilitiesTranslationComponent) value; // TerminologyCapabilitiesTranslationComponent
5663          return value;
5664        case 866552379: // closure
5665          this.closure = (TerminologyCapabilitiesClosureComponent) value; // TerminologyCapabilitiesClosureComponent
5666          return value;
5667        default: return super.setProperty(hash, name, value);
5668        }
5669
5670      }
5671
5672      @Override
5673      public Base setProperty(String name, Base value) throws FHIRException {
5674        if (name.equals("url")) {
5675          this.url = TypeConvertor.castToUri(value); // UriType
5676        } else if (name.equals("identifier")) {
5677          this.getIdentifier().add(TypeConvertor.castToIdentifier(value));
5678        } else if (name.equals("version")) {
5679          this.version = TypeConvertor.castToString(value); // StringType
5680        } else if (name.equals("name")) {
5681          this.name = TypeConvertor.castToString(value); // StringType
5682        } else if (name.equals("title")) {
5683          this.title = TypeConvertor.castToString(value); // StringType
5684        } else if (name.equals("status")) {
5685          value = new PublicationStatusEnumFactory().fromType(TypeConvertor.castToCode(value));
5686          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
5687        } else if (name.equals("experimental")) {
5688          this.experimental = TypeConvertor.castToBoolean(value); // BooleanType
5689        } else if (name.equals("date")) {
5690          this.date = TypeConvertor.castToDateTime(value); // DateTimeType
5691        } else if (name.equals("publisher")) {
5692          this.publisher = TypeConvertor.castToString(value); // StringType
5693        } else if (name.equals("contact")) {
5694          this.getContact().add(TypeConvertor.castToContactDetail(value));
5695        } else if (name.equals("description")) {
5696          this.description = TypeConvertor.castToMarkdown(value); // MarkdownType
5697        } else if (name.equals("useContext")) {
5698          this.getUseContext().add(TypeConvertor.castToUsageContext(value));
5699        } else if (name.equals("jurisdiction")) {
5700          this.getJurisdiction().add(TypeConvertor.castToCodeableConcept(value));
5701        } else if (name.equals("purpose")) {
5702          this.purpose = TypeConvertor.castToMarkdown(value); // MarkdownType
5703        } else if (name.equals("copyright")) {
5704          this.copyright = TypeConvertor.castToMarkdown(value); // MarkdownType
5705        } else if (name.equals("kind")) {
5706          value = new CapabilityStatementKindEnumFactory().fromType(TypeConvertor.castToCode(value));
5707          this.kind = (Enumeration) value; // Enumeration<CapabilityStatementKind>
5708        } else if (name.equals("software")) {
5709          this.software = (TerminologyCapabilitiesSoftwareComponent) value; // TerminologyCapabilitiesSoftwareComponent
5710        } else if (name.equals("implementation")) {
5711          this.implementation = (TerminologyCapabilitiesImplementationComponent) value; // TerminologyCapabilitiesImplementationComponent
5712        } else if (name.equals("lockedDate")) {
5713          this.lockedDate = TypeConvertor.castToBoolean(value); // BooleanType
5714        } else if (name.equals("codeSystem")) {
5715          this.getCodeSystem().add((TerminologyCapabilitiesCodeSystemComponent) value);
5716        } else if (name.equals("expansion")) {
5717          this.expansion = (TerminologyCapabilitiesExpansionComponent) value; // TerminologyCapabilitiesExpansionComponent
5718        } else if (name.equals("codeSearch")) {
5719          value = new CodeSearchSupportEnumFactory().fromType(TypeConvertor.castToCode(value));
5720          this.codeSearch = (Enumeration) value; // Enumeration<CodeSearchSupport>
5721        } else if (name.equals("validateCode")) {
5722          this.validateCode = (TerminologyCapabilitiesValidateCodeComponent) value; // TerminologyCapabilitiesValidateCodeComponent
5723        } else if (name.equals("translation")) {
5724          this.translation = (TerminologyCapabilitiesTranslationComponent) value; // TerminologyCapabilitiesTranslationComponent
5725        } else if (name.equals("closure")) {
5726          this.closure = (TerminologyCapabilitiesClosureComponent) value; // TerminologyCapabilitiesClosureComponent
5727        } else
5728          return super.setProperty(name, value);
5729        return value;
5730      }
5731
5732      @Override
5733      public Base makeProperty(int hash, String name) throws FHIRException {
5734        switch (hash) {
5735        case 116079:  return getUrlElement();
5736        case -1618432855:  return addIdentifier(); 
5737        case 351608024:  return getVersionElement();
5738        case 3373707:  return getNameElement();
5739        case 110371416:  return getTitleElement();
5740        case -892481550:  return getStatusElement();
5741        case -404562712:  return getExperimentalElement();
5742        case 3076014:  return getDateElement();
5743        case 1447404028:  return getPublisherElement();
5744        case 951526432:  return addContact(); 
5745        case -1724546052:  return getDescriptionElement();
5746        case -669707736:  return addUseContext(); 
5747        case -507075711:  return addJurisdiction(); 
5748        case -220463842:  return getPurposeElement();
5749        case 1522889671:  return getCopyrightElement();
5750        case 3292052:  return getKindElement();
5751        case 1319330215:  return getSoftware();
5752        case 1683336114:  return getImplementation();
5753        case 1391591896:  return getLockedDateElement();
5754        case -916511108:  return addCodeSystem(); 
5755        case 17878207:  return getExpansion();
5756        case -935519755:  return getCodeSearchElement();
5757        case 1080737827:  return getValidateCode();
5758        case -1840647503:  return getTranslation();
5759        case 866552379:  return getClosure();
5760        default: return super.makeProperty(hash, name);
5761        }
5762
5763      }
5764
5765      @Override
5766      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
5767        switch (hash) {
5768        case 116079: /*url*/ return new String[] {"uri"};
5769        case -1618432855: /*identifier*/ return new String[] {"Identifier"};
5770        case 351608024: /*version*/ return new String[] {"string"};
5771        case 3373707: /*name*/ return new String[] {"string"};
5772        case 110371416: /*title*/ return new String[] {"string"};
5773        case -892481550: /*status*/ return new String[] {"code"};
5774        case -404562712: /*experimental*/ return new String[] {"boolean"};
5775        case 3076014: /*date*/ return new String[] {"dateTime"};
5776        case 1447404028: /*publisher*/ return new String[] {"string"};
5777        case 951526432: /*contact*/ return new String[] {"ContactDetail"};
5778        case -1724546052: /*description*/ return new String[] {"markdown"};
5779        case -669707736: /*useContext*/ return new String[] {"UsageContext"};
5780        case -507075711: /*jurisdiction*/ return new String[] {"CodeableConcept"};
5781        case -220463842: /*purpose*/ return new String[] {"markdown"};
5782        case 1522889671: /*copyright*/ return new String[] {"markdown"};
5783        case 3292052: /*kind*/ return new String[] {"code"};
5784        case 1319330215: /*software*/ return new String[] {};
5785        case 1683336114: /*implementation*/ return new String[] {};
5786        case 1391591896: /*lockedDate*/ return new String[] {"boolean"};
5787        case -916511108: /*codeSystem*/ return new String[] {};
5788        case 17878207: /*expansion*/ return new String[] {};
5789        case -935519755: /*codeSearch*/ return new String[] {"code"};
5790        case 1080737827: /*validateCode*/ return new String[] {};
5791        case -1840647503: /*translation*/ return new String[] {};
5792        case 866552379: /*closure*/ return new String[] {};
5793        default: return super.getTypesForProperty(hash, name);
5794        }
5795
5796      }
5797
5798      @Override
5799      public Base addChild(String name) throws FHIRException {
5800        if (name.equals("url")) {
5801          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.url");
5802        }
5803        else if (name.equals("identifier")) {
5804          return addIdentifier();
5805        }
5806        else if (name.equals("version")) {
5807          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.version");
5808        }
5809        else if (name.equals("name")) {
5810          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.name");
5811        }
5812        else if (name.equals("title")) {
5813          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.title");
5814        }
5815        else if (name.equals("status")) {
5816          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.status");
5817        }
5818        else if (name.equals("experimental")) {
5819          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.experimental");
5820        }
5821        else if (name.equals("date")) {
5822          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.date");
5823        }
5824        else if (name.equals("publisher")) {
5825          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.publisher");
5826        }
5827        else if (name.equals("contact")) {
5828          return addContact();
5829        }
5830        else if (name.equals("description")) {
5831          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.description");
5832        }
5833        else if (name.equals("useContext")) {
5834          return addUseContext();
5835        }
5836        else if (name.equals("jurisdiction")) {
5837          return addJurisdiction();
5838        }
5839        else if (name.equals("purpose")) {
5840          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.purpose");
5841        }
5842        else if (name.equals("copyright")) {
5843          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.copyright");
5844        }
5845        else if (name.equals("kind")) {
5846          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.kind");
5847        }
5848        else if (name.equals("software")) {
5849          this.software = new TerminologyCapabilitiesSoftwareComponent();
5850          return this.software;
5851        }
5852        else if (name.equals("implementation")) {
5853          this.implementation = new TerminologyCapabilitiesImplementationComponent();
5854          return this.implementation;
5855        }
5856        else if (name.equals("lockedDate")) {
5857          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.lockedDate");
5858        }
5859        else if (name.equals("codeSystem")) {
5860          return addCodeSystem();
5861        }
5862        else if (name.equals("expansion")) {
5863          this.expansion = new TerminologyCapabilitiesExpansionComponent();
5864          return this.expansion;
5865        }
5866        else if (name.equals("codeSearch")) {
5867          throw new FHIRException("Cannot call addChild on a primitive type TerminologyCapabilities.codeSearch");
5868        }
5869        else if (name.equals("validateCode")) {
5870          this.validateCode = new TerminologyCapabilitiesValidateCodeComponent();
5871          return this.validateCode;
5872        }
5873        else if (name.equals("translation")) {
5874          this.translation = new TerminologyCapabilitiesTranslationComponent();
5875          return this.translation;
5876        }
5877        else if (name.equals("closure")) {
5878          this.closure = new TerminologyCapabilitiesClosureComponent();
5879          return this.closure;
5880        }
5881        else
5882          return super.addChild(name);
5883      }
5884
5885  public String fhirType() {
5886    return "TerminologyCapabilities";
5887
5888  }
5889
5890      public TerminologyCapabilities copy() {
5891        TerminologyCapabilities dst = new TerminologyCapabilities();
5892        copyValues(dst);
5893        return dst;
5894      }
5895
5896      public void copyValues(TerminologyCapabilities dst) {
5897        super.copyValues(dst);
5898        dst.url = url == null ? null : url.copy();
5899        if (identifier != null) {
5900          dst.identifier = new ArrayList<Identifier>();
5901          for (Identifier i : identifier)
5902            dst.identifier.add(i.copy());
5903        };
5904        dst.version = version == null ? null : version.copy();
5905        dst.name = name == null ? null : name.copy();
5906        dst.title = title == null ? null : title.copy();
5907        dst.status = status == null ? null : status.copy();
5908        dst.experimental = experimental == null ? null : experimental.copy();
5909        dst.date = date == null ? null : date.copy();
5910        dst.publisher = publisher == null ? null : publisher.copy();
5911        if (contact != null) {
5912          dst.contact = new ArrayList<ContactDetail>();
5913          for (ContactDetail i : contact)
5914            dst.contact.add(i.copy());
5915        };
5916        dst.description = description == null ? null : description.copy();
5917        if (useContext != null) {
5918          dst.useContext = new ArrayList<UsageContext>();
5919          for (UsageContext i : useContext)
5920            dst.useContext.add(i.copy());
5921        };
5922        if (jurisdiction != null) {
5923          dst.jurisdiction = new ArrayList<CodeableConcept>();
5924          for (CodeableConcept i : jurisdiction)
5925            dst.jurisdiction.add(i.copy());
5926        };
5927        dst.purpose = purpose == null ? null : purpose.copy();
5928        dst.copyright = copyright == null ? null : copyright.copy();
5929        dst.kind = kind == null ? null : kind.copy();
5930        dst.software = software == null ? null : software.copy();
5931        dst.implementation = implementation == null ? null : implementation.copy();
5932        dst.lockedDate = lockedDate == null ? null : lockedDate.copy();
5933        if (codeSystem != null) {
5934          dst.codeSystem = new ArrayList<TerminologyCapabilitiesCodeSystemComponent>();
5935          for (TerminologyCapabilitiesCodeSystemComponent i : codeSystem)
5936            dst.codeSystem.add(i.copy());
5937        };
5938        dst.expansion = expansion == null ? null : expansion.copy();
5939        dst.codeSearch = codeSearch == null ? null : codeSearch.copy();
5940        dst.validateCode = validateCode == null ? null : validateCode.copy();
5941        dst.translation = translation == null ? null : translation.copy();
5942        dst.closure = closure == null ? null : closure.copy();
5943      }
5944
5945      protected TerminologyCapabilities typedCopy() {
5946        return copy();
5947      }
5948
5949      @Override
5950      public boolean equalsDeep(Base other_) {
5951        if (!super.equalsDeep(other_))
5952          return false;
5953        if (!(other_ instanceof TerminologyCapabilities))
5954          return false;
5955        TerminologyCapabilities o = (TerminologyCapabilities) other_;
5956        return compareDeep(url, o.url, true) && compareDeep(identifier, o.identifier, true) && compareDeep(version, o.version, true)
5957           && compareDeep(name, o.name, true) && compareDeep(title, o.title, true) && compareDeep(status, o.status, true)
5958           && compareDeep(experimental, o.experimental, true) && compareDeep(date, o.date, true) && compareDeep(publisher, o.publisher, true)
5959           && compareDeep(contact, o.contact, true) && compareDeep(description, o.description, true) && compareDeep(useContext, o.useContext, true)
5960           && compareDeep(jurisdiction, o.jurisdiction, true) && compareDeep(purpose, o.purpose, true) && compareDeep(copyright, o.copyright, true)
5961           && compareDeep(kind, o.kind, true) && compareDeep(software, o.software, true) && compareDeep(implementation, o.implementation, true)
5962           && compareDeep(lockedDate, o.lockedDate, true) && compareDeep(codeSystem, o.codeSystem, true) && compareDeep(expansion, o.expansion, true)
5963           && compareDeep(codeSearch, o.codeSearch, true) && compareDeep(validateCode, o.validateCode, true)
5964           && compareDeep(translation, o.translation, true) && compareDeep(closure, o.closure, true);
5965      }
5966
5967      @Override
5968      public boolean equalsShallow(Base other_) {
5969        if (!super.equalsShallow(other_))
5970          return false;
5971        if (!(other_ instanceof TerminologyCapabilities))
5972          return false;
5973        TerminologyCapabilities o = (TerminologyCapabilities) other_;
5974        return compareValues(url, o.url, true) && compareValues(version, o.version, true) && compareValues(name, o.name, true)
5975           && compareValues(title, o.title, true) && compareValues(status, o.status, true) && compareValues(experimental, o.experimental, true)
5976           && compareValues(date, o.date, true) && compareValues(publisher, o.publisher, true) && compareValues(description, o.description, true)
5977           && compareValues(purpose, o.purpose, true) && compareValues(copyright, o.copyright, true) && compareValues(kind, o.kind, true)
5978           && compareValues(lockedDate, o.lockedDate, true) && compareValues(codeSearch, o.codeSearch, true);
5979      }
5980
5981      public boolean isEmpty() {
5982        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(url, identifier, version
5983          , name, title, status, experimental, date, publisher, contact, description, useContext
5984          , jurisdiction, purpose, copyright, kind, software, implementation, lockedDate
5985          , codeSystem, expansion, codeSearch, validateCode, translation, closure);
5986      }
5987
5988  @Override
5989  public ResourceType getResourceType() {
5990    return ResourceType.TerminologyCapabilities;
5991   }
5992
5993 /**
5994   * Search parameter: <b>context-quantity</b>
5995   * <p>
5996   * Description: <b>Multiple Resources: 
5997
5998* [CapabilityStatement](capabilitystatement.html): A quantity- or range-valued use context assigned to the capability statement
5999* [CodeSystem](codesystem.html): A quantity- or range-valued use context assigned to the code system
6000* [CompartmentDefinition](compartmentdefinition.html): A quantity- or range-valued use context assigned to the compartment definition
6001* [ConceptMap](conceptmap.html): A quantity- or range-valued use context assigned to the concept map
6002* [GraphDefinition](graphdefinition.html): A quantity- or range-valued use context assigned to the graph definition
6003* [ImplementationGuide](implementationguide.html): A quantity- or range-valued use context assigned to the implementation guide
6004* [MessageDefinition](messagedefinition.html): A quantity- or range-valued use context assigned to the message definition
6005* [NamingSystem](namingsystem.html): A quantity- or range-valued use context assigned to the naming system
6006* [OperationDefinition](operationdefinition.html): A quantity- or range-valued use context assigned to the operation definition
6007* [SearchParameter](searchparameter.html): A quantity- or range-valued use context assigned to the search parameter
6008* [StructureDefinition](structuredefinition.html): A quantity- or range-valued use context assigned to the structure definition
6009* [StructureMap](structuremap.html): A quantity- or range-valued use context assigned to the structure map
6010* [TerminologyCapabilities](terminologycapabilities.html): A quantity- or range-valued use context assigned to the terminology capabilities
6011* [ValueSet](valueset.html): A quantity- or range-valued use context assigned to the value set
6012</b><br>
6013   * Type: <b>quantity</b><br>
6014   * Path: <b>(CapabilityStatement.useContext.value as Quantity) | (CapabilityStatement.useContext.value as Range) | (CodeSystem.useContext.value as Quantity) | (CodeSystem.useContext.value as Range) | (CompartmentDefinition.useContext.value as Quantity) | (CompartmentDefinition.useContext.value as Range) | (ConceptMap.useContext.value as Quantity) | (ConceptMap.useContext.value as Range) | (GraphDefinition.useContext.value as Quantity) | (GraphDefinition.useContext.value as Range) | (ImplementationGuide.useContext.value as Quantity) | (ImplementationGuide.useContext.value as Range) | (MessageDefinition.useContext.value as Quantity) | (MessageDefinition.useContext.value as Range) | (NamingSystem.useContext.value as Quantity) | (NamingSystem.useContext.value as Range) | (OperationDefinition.useContext.value as Quantity) | (OperationDefinition.useContext.value as Range) | (SearchParameter.useContext.value as Quantity) | (SearchParameter.useContext.value as Range) | (StructureDefinition.useContext.value as Quantity) | (StructureDefinition.useContext.value as Range) | (StructureMap.useContext.value as Quantity) | (StructureMap.useContext.value as Range) | (TerminologyCapabilities.useContext.value as Quantity) | (TerminologyCapabilities.useContext.value as Range) | (ValueSet.useContext.value as Quantity) | (ValueSet.useContext.value as Range)</b><br>
6015   * </p>
6016   */
6017  @SearchParamDefinition(name="context-quantity", path="(CapabilityStatement.useContext.value as Quantity) | (CapabilityStatement.useContext.value as Range) | (CodeSystem.useContext.value as Quantity) | (CodeSystem.useContext.value as Range) | (CompartmentDefinition.useContext.value as Quantity) | (CompartmentDefinition.useContext.value as Range) | (ConceptMap.useContext.value as Quantity) | (ConceptMap.useContext.value as Range) | (GraphDefinition.useContext.value as Quantity) | (GraphDefinition.useContext.value as Range) | (ImplementationGuide.useContext.value as Quantity) | (ImplementationGuide.useContext.value as Range) | (MessageDefinition.useContext.value as Quantity) | (MessageDefinition.useContext.value as Range) | (NamingSystem.useContext.value as Quantity) | (NamingSystem.useContext.value as Range) | (OperationDefinition.useContext.value as Quantity) | (OperationDefinition.useContext.value as Range) | (SearchParameter.useContext.value as Quantity) | (SearchParameter.useContext.value as Range) | (StructureDefinition.useContext.value as Quantity) | (StructureDefinition.useContext.value as Range) | (StructureMap.useContext.value as Quantity) | (StructureMap.useContext.value as Range) | (TerminologyCapabilities.useContext.value as Quantity) | (TerminologyCapabilities.useContext.value as Range) | (ValueSet.useContext.value as Quantity) | (ValueSet.useContext.value as Range)", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): A quantity- or range-valued use context assigned to the capability statement\r\n* [CodeSystem](codesystem.html): A quantity- or range-valued use context assigned to the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): A quantity- or range-valued use context assigned to the compartment definition\r\n* [ConceptMap](conceptmap.html): A quantity- or range-valued use context assigned to the concept map\r\n* [GraphDefinition](graphdefinition.html): A quantity- or range-valued use context assigned to the graph definition\r\n* [ImplementationGuide](implementationguide.html): A quantity- or range-valued use context assigned to the implementation guide\r\n* [MessageDefinition](messagedefinition.html): A quantity- or range-valued use context assigned to the message definition\r\n* [NamingSystem](namingsystem.html): A quantity- or range-valued use context assigned to the naming system\r\n* [OperationDefinition](operationdefinition.html): A quantity- or range-valued use context assigned to the operation definition\r\n* [SearchParameter](searchparameter.html): A quantity- or range-valued use context assigned to the search parameter\r\n* [StructureDefinition](structuredefinition.html): A quantity- or range-valued use context assigned to the structure definition\r\n* [StructureMap](structuremap.html): A quantity- or range-valued use context assigned to the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): A quantity- or range-valued use context assigned to the terminology capabilities\r\n* [ValueSet](valueset.html): A quantity- or range-valued use context assigned to the value set\r\n", type="quantity" )
6018  public static final String SP_CONTEXT_QUANTITY = "context-quantity";
6019 /**
6020   * <b>Fluent Client</b> search parameter constant for <b>context-quantity</b>
6021   * <p>
6022   * Description: <b>Multiple Resources: 
6023
6024* [CapabilityStatement](capabilitystatement.html): A quantity- or range-valued use context assigned to the capability statement
6025* [CodeSystem](codesystem.html): A quantity- or range-valued use context assigned to the code system
6026* [CompartmentDefinition](compartmentdefinition.html): A quantity- or range-valued use context assigned to the compartment definition
6027* [ConceptMap](conceptmap.html): A quantity- or range-valued use context assigned to the concept map
6028* [GraphDefinition](graphdefinition.html): A quantity- or range-valued use context assigned to the graph definition
6029* [ImplementationGuide](implementationguide.html): A quantity- or range-valued use context assigned to the implementation guide
6030* [MessageDefinition](messagedefinition.html): A quantity- or range-valued use context assigned to the message definition
6031* [NamingSystem](namingsystem.html): A quantity- or range-valued use context assigned to the naming system
6032* [OperationDefinition](operationdefinition.html): A quantity- or range-valued use context assigned to the operation definition
6033* [SearchParameter](searchparameter.html): A quantity- or range-valued use context assigned to the search parameter
6034* [StructureDefinition](structuredefinition.html): A quantity- or range-valued use context assigned to the structure definition
6035* [StructureMap](structuremap.html): A quantity- or range-valued use context assigned to the structure map
6036* [TerminologyCapabilities](terminologycapabilities.html): A quantity- or range-valued use context assigned to the terminology capabilities
6037* [ValueSet](valueset.html): A quantity- or range-valued use context assigned to the value set
6038</b><br>
6039   * Type: <b>quantity</b><br>
6040   * Path: <b>(CapabilityStatement.useContext.value as Quantity) | (CapabilityStatement.useContext.value as Range) | (CodeSystem.useContext.value as Quantity) | (CodeSystem.useContext.value as Range) | (CompartmentDefinition.useContext.value as Quantity) | (CompartmentDefinition.useContext.value as Range) | (ConceptMap.useContext.value as Quantity) | (ConceptMap.useContext.value as Range) | (GraphDefinition.useContext.value as Quantity) | (GraphDefinition.useContext.value as Range) | (ImplementationGuide.useContext.value as Quantity) | (ImplementationGuide.useContext.value as Range) | (MessageDefinition.useContext.value as Quantity) | (MessageDefinition.useContext.value as Range) | (NamingSystem.useContext.value as Quantity) | (NamingSystem.useContext.value as Range) | (OperationDefinition.useContext.value as Quantity) | (OperationDefinition.useContext.value as Range) | (SearchParameter.useContext.value as Quantity) | (SearchParameter.useContext.value as Range) | (StructureDefinition.useContext.value as Quantity) | (StructureDefinition.useContext.value as Range) | (StructureMap.useContext.value as Quantity) | (StructureMap.useContext.value as Range) | (TerminologyCapabilities.useContext.value as Quantity) | (TerminologyCapabilities.useContext.value as Range) | (ValueSet.useContext.value as Quantity) | (ValueSet.useContext.value as Range)</b><br>
6041   * </p>
6042   */
6043  public static final ca.uhn.fhir.rest.gclient.QuantityClientParam CONTEXT_QUANTITY = new ca.uhn.fhir.rest.gclient.QuantityClientParam(SP_CONTEXT_QUANTITY);
6044
6045 /**
6046   * Search parameter: <b>context-type-quantity</b>
6047   * <p>
6048   * Description: <b>Multiple Resources: 
6049
6050* [CapabilityStatement](capabilitystatement.html): A use context type and quantity- or range-based value assigned to the capability statement
6051* [CodeSystem](codesystem.html): A use context type and quantity- or range-based value assigned to the code system
6052* [CompartmentDefinition](compartmentdefinition.html): A use context type and quantity- or range-based value assigned to the compartment definition
6053* [ConceptMap](conceptmap.html): A use context type and quantity- or range-based value assigned to the concept map
6054* [GraphDefinition](graphdefinition.html): A use context type and quantity- or range-based value assigned to the graph definition
6055* [ImplementationGuide](implementationguide.html): A use context type and quantity- or range-based value assigned to the implementation guide
6056* [MessageDefinition](messagedefinition.html): A use context type and quantity- or range-based value assigned to the message definition
6057* [NamingSystem](namingsystem.html): A use context type and quantity- or range-based value assigned to the naming system
6058* [OperationDefinition](operationdefinition.html): A use context type and quantity- or range-based value assigned to the operation definition
6059* [SearchParameter](searchparameter.html): A use context type and quantity- or range-based value assigned to the search parameter
6060* [StructureDefinition](structuredefinition.html): A use context type and quantity- or range-based value assigned to the structure definition
6061* [StructureMap](structuremap.html): A use context type and quantity- or range-based value assigned to the structure map
6062* [TerminologyCapabilities](terminologycapabilities.html): A use context type and quantity- or range-based value assigned to the terminology capabilities
6063* [ValueSet](valueset.html): A use context type and quantity- or range-based value assigned to the value set
6064</b><br>
6065   * Type: <b>composite</b><br>
6066   * Path: <b>CapabilityStatement.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | ValueSet.useContext</b><br>
6067   * </p>
6068   */
6069  @SearchParamDefinition(name="context-type-quantity", path="CapabilityStatement.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | ValueSet.useContext", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): A use context type and quantity- or range-based value assigned to the capability statement\r\n* [CodeSystem](codesystem.html): A use context type and quantity- or range-based value assigned to the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): A use context type and quantity- or range-based value assigned to the compartment definition\r\n* [ConceptMap](conceptmap.html): A use context type and quantity- or range-based value assigned to the concept map\r\n* [GraphDefinition](graphdefinition.html): A use context type and quantity- or range-based value assigned to the graph definition\r\n* [ImplementationGuide](implementationguide.html): A use context type and quantity- or range-based value assigned to the implementation guide\r\n* [MessageDefinition](messagedefinition.html): A use context type and quantity- or range-based value assigned to the message definition\r\n* [NamingSystem](namingsystem.html): A use context type and quantity- or range-based value assigned to the naming system\r\n* [OperationDefinition](operationdefinition.html): A use context type and quantity- or range-based value assigned to the operation definition\r\n* [SearchParameter](searchparameter.html): A use context type and quantity- or range-based value assigned to the search parameter\r\n* [StructureDefinition](structuredefinition.html): A use context type and quantity- or range-based value assigned to the structure definition\r\n* [StructureMap](structuremap.html): A use context type and quantity- or range-based value assigned to the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): A use context type and quantity- or range-based value assigned to the terminology capabilities\r\n* [ValueSet](valueset.html): A use context type and quantity- or range-based value assigned to the value set\r\n", type="composite", compositeOf={"context-type", "context-quantity"} )
6070  public static final String SP_CONTEXT_TYPE_QUANTITY = "context-type-quantity";
6071 /**
6072   * <b>Fluent Client</b> search parameter constant for <b>context-type-quantity</b>
6073   * <p>
6074   * Description: <b>Multiple Resources: 
6075
6076* [CapabilityStatement](capabilitystatement.html): A use context type and quantity- or range-based value assigned to the capability statement
6077* [CodeSystem](codesystem.html): A use context type and quantity- or range-based value assigned to the code system
6078* [CompartmentDefinition](compartmentdefinition.html): A use context type and quantity- or range-based value assigned to the compartment definition
6079* [ConceptMap](conceptmap.html): A use context type and quantity- or range-based value assigned to the concept map
6080* [GraphDefinition](graphdefinition.html): A use context type and quantity- or range-based value assigned to the graph definition
6081* [ImplementationGuide](implementationguide.html): A use context type and quantity- or range-based value assigned to the implementation guide
6082* [MessageDefinition](messagedefinition.html): A use context type and quantity- or range-based value assigned to the message definition
6083* [NamingSystem](namingsystem.html): A use context type and quantity- or range-based value assigned to the naming system
6084* [OperationDefinition](operationdefinition.html): A use context type and quantity- or range-based value assigned to the operation definition
6085* [SearchParameter](searchparameter.html): A use context type and quantity- or range-based value assigned to the search parameter
6086* [StructureDefinition](structuredefinition.html): A use context type and quantity- or range-based value assigned to the structure definition
6087* [StructureMap](structuremap.html): A use context type and quantity- or range-based value assigned to the structure map
6088* [TerminologyCapabilities](terminologycapabilities.html): A use context type and quantity- or range-based value assigned to the terminology capabilities
6089* [ValueSet](valueset.html): A use context type and quantity- or range-based value assigned to the value set
6090</b><br>
6091   * Type: <b>composite</b><br>
6092   * Path: <b>CapabilityStatement.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | ValueSet.useContext</b><br>
6093   * </p>
6094   */
6095  public static final ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.QuantityClientParam> CONTEXT_TYPE_QUANTITY = new ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.QuantityClientParam>(SP_CONTEXT_TYPE_QUANTITY);
6096
6097 /**
6098   * Search parameter: <b>context-type-value</b>
6099   * <p>
6100   * Description: <b>Multiple Resources: 
6101
6102* [CapabilityStatement](capabilitystatement.html): A use context type and value assigned to the capability statement
6103* [CodeSystem](codesystem.html): A use context type and value assigned to the code system
6104* [CompartmentDefinition](compartmentdefinition.html): A use context type and value assigned to the compartment definition
6105* [ConceptMap](conceptmap.html): A use context type and value assigned to the concept map
6106* [GraphDefinition](graphdefinition.html): A use context type and value assigned to the graph definition
6107* [ImplementationGuide](implementationguide.html): A use context type and value assigned to the implementation guide
6108* [MessageDefinition](messagedefinition.html): A use context type and value assigned to the message definition
6109* [NamingSystem](namingsystem.html): A use context type and value assigned to the naming system
6110* [OperationDefinition](operationdefinition.html): A use context type and value assigned to the operation definition
6111* [SearchParameter](searchparameter.html): A use context type and value assigned to the search parameter
6112* [StructureDefinition](structuredefinition.html): A use context type and value assigned to the structure definition
6113* [StructureMap](structuremap.html): A use context type and value assigned to the structure map
6114* [TerminologyCapabilities](terminologycapabilities.html): A use context type and value assigned to the terminology capabilities
6115* [ValueSet](valueset.html): A use context type and value assigned to the value set
6116</b><br>
6117   * Type: <b>composite</b><br>
6118   * Path: <b>CapabilityStatement.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | ValueSet.useContext</b><br>
6119   * </p>
6120   */
6121  @SearchParamDefinition(name="context-type-value", path="CapabilityStatement.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | ValueSet.useContext", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): A use context type and value assigned to the capability statement\r\n* [CodeSystem](codesystem.html): A use context type and value assigned to the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): A use context type and value assigned to the compartment definition\r\n* [ConceptMap](conceptmap.html): A use context type and value assigned to the concept map\r\n* [GraphDefinition](graphdefinition.html): A use context type and value assigned to the graph definition\r\n* [ImplementationGuide](implementationguide.html): A use context type and value assigned to the implementation guide\r\n* [MessageDefinition](messagedefinition.html): A use context type and value assigned to the message definition\r\n* [NamingSystem](namingsystem.html): A use context type and value assigned to the naming system\r\n* [OperationDefinition](operationdefinition.html): A use context type and value assigned to the operation definition\r\n* [SearchParameter](searchparameter.html): A use context type and value assigned to the search parameter\r\n* [StructureDefinition](structuredefinition.html): A use context type and value assigned to the structure definition\r\n* [StructureMap](structuremap.html): A use context type and value assigned to the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): A use context type and value assigned to the terminology capabilities\r\n* [ValueSet](valueset.html): A use context type and value assigned to the value set\r\n", type="composite", compositeOf={"context-type", "context"} )
6122  public static final String SP_CONTEXT_TYPE_VALUE = "context-type-value";
6123 /**
6124   * <b>Fluent Client</b> search parameter constant for <b>context-type-value</b>
6125   * <p>
6126   * Description: <b>Multiple Resources: 
6127
6128* [CapabilityStatement](capabilitystatement.html): A use context type and value assigned to the capability statement
6129* [CodeSystem](codesystem.html): A use context type and value assigned to the code system
6130* [CompartmentDefinition](compartmentdefinition.html): A use context type and value assigned to the compartment definition
6131* [ConceptMap](conceptmap.html): A use context type and value assigned to the concept map
6132* [GraphDefinition](graphdefinition.html): A use context type and value assigned to the graph definition
6133* [ImplementationGuide](implementationguide.html): A use context type and value assigned to the implementation guide
6134* [MessageDefinition](messagedefinition.html): A use context type and value assigned to the message definition
6135* [NamingSystem](namingsystem.html): A use context type and value assigned to the naming system
6136* [OperationDefinition](operationdefinition.html): A use context type and value assigned to the operation definition
6137* [SearchParameter](searchparameter.html): A use context type and value assigned to the search parameter
6138* [StructureDefinition](structuredefinition.html): A use context type and value assigned to the structure definition
6139* [StructureMap](structuremap.html): A use context type and value assigned to the structure map
6140* [TerminologyCapabilities](terminologycapabilities.html): A use context type and value assigned to the terminology capabilities
6141* [ValueSet](valueset.html): A use context type and value assigned to the value set
6142</b><br>
6143   * Type: <b>composite</b><br>
6144   * Path: <b>CapabilityStatement.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | ValueSet.useContext</b><br>
6145   * </p>
6146   */
6147  public static final ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.TokenClientParam> CONTEXT_TYPE_VALUE = new ca.uhn.fhir.rest.gclient.CompositeClientParam<ca.uhn.fhir.rest.gclient.TokenClientParam, ca.uhn.fhir.rest.gclient.TokenClientParam>(SP_CONTEXT_TYPE_VALUE);
6148
6149 /**
6150   * Search parameter: <b>context-type</b>
6151   * <p>
6152   * Description: <b>Multiple Resources: 
6153
6154* [CapabilityStatement](capabilitystatement.html): A type of use context assigned to the capability statement
6155* [CodeSystem](codesystem.html): A type of use context assigned to the code system
6156* [CompartmentDefinition](compartmentdefinition.html): A type of use context assigned to the compartment definition
6157* [ConceptMap](conceptmap.html): A type of use context assigned to the concept map
6158* [GraphDefinition](graphdefinition.html): A type of use context assigned to the graph definition
6159* [ImplementationGuide](implementationguide.html): A type of use context assigned to the implementation guide
6160* [MessageDefinition](messagedefinition.html): A type of use context assigned to the message definition
6161* [NamingSystem](namingsystem.html): A type of use context assigned to the naming system
6162* [OperationDefinition](operationdefinition.html): A type of use context assigned to the operation definition
6163* [SearchParameter](searchparameter.html): A type of use context assigned to the search parameter
6164* [StructureDefinition](structuredefinition.html): A type of use context assigned to the structure definition
6165* [StructureMap](structuremap.html): A type of use context assigned to the structure map
6166* [TerminologyCapabilities](terminologycapabilities.html): A type of use context assigned to the terminology capabilities
6167* [ValueSet](valueset.html): A type of use context assigned to the value set
6168</b><br>
6169   * Type: <b>token</b><br>
6170   * Path: <b>CapabilityStatement.useContext.code | CodeSystem.useContext.code | CompartmentDefinition.useContext.code | ConceptMap.useContext.code | GraphDefinition.useContext.code | ImplementationGuide.useContext.code | MessageDefinition.useContext.code | NamingSystem.useContext.code | OperationDefinition.useContext.code | SearchParameter.useContext.code | StructureDefinition.useContext.code | StructureMap.useContext.code | TerminologyCapabilities.useContext.code | ValueSet.useContext.code</b><br>
6171   * </p>
6172   */
6173  @SearchParamDefinition(name="context-type", path="CapabilityStatement.useContext.code | CodeSystem.useContext.code | CompartmentDefinition.useContext.code | ConceptMap.useContext.code | GraphDefinition.useContext.code | ImplementationGuide.useContext.code | MessageDefinition.useContext.code | NamingSystem.useContext.code | OperationDefinition.useContext.code | SearchParameter.useContext.code | StructureDefinition.useContext.code | StructureMap.useContext.code | TerminologyCapabilities.useContext.code | ValueSet.useContext.code", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): A type of use context assigned to the capability statement\r\n* [CodeSystem](codesystem.html): A type of use context assigned to the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): A type of use context assigned to the compartment definition\r\n* [ConceptMap](conceptmap.html): A type of use context assigned to the concept map\r\n* [GraphDefinition](graphdefinition.html): A type of use context assigned to the graph definition\r\n* [ImplementationGuide](implementationguide.html): A type of use context assigned to the implementation guide\r\n* [MessageDefinition](messagedefinition.html): A type of use context assigned to the message definition\r\n* [NamingSystem](namingsystem.html): A type of use context assigned to the naming system\r\n* [OperationDefinition](operationdefinition.html): A type of use context assigned to the operation definition\r\n* [SearchParameter](searchparameter.html): A type of use context assigned to the search parameter\r\n* [StructureDefinition](structuredefinition.html): A type of use context assigned to the structure definition\r\n* [StructureMap](structuremap.html): A type of use context assigned to the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): A type of use context assigned to the terminology capabilities\r\n* [ValueSet](valueset.html): A type of use context assigned to the value set\r\n", type="token" )
6174  public static final String SP_CONTEXT_TYPE = "context-type";
6175 /**
6176   * <b>Fluent Client</b> search parameter constant for <b>context-type</b>
6177   * <p>
6178   * Description: <b>Multiple Resources: 
6179
6180* [CapabilityStatement](capabilitystatement.html): A type of use context assigned to the capability statement
6181* [CodeSystem](codesystem.html): A type of use context assigned to the code system
6182* [CompartmentDefinition](compartmentdefinition.html): A type of use context assigned to the compartment definition
6183* [ConceptMap](conceptmap.html): A type of use context assigned to the concept map
6184* [GraphDefinition](graphdefinition.html): A type of use context assigned to the graph definition
6185* [ImplementationGuide](implementationguide.html): A type of use context assigned to the implementation guide
6186* [MessageDefinition](messagedefinition.html): A type of use context assigned to the message definition
6187* [NamingSystem](namingsystem.html): A type of use context assigned to the naming system
6188* [OperationDefinition](operationdefinition.html): A type of use context assigned to the operation definition
6189* [SearchParameter](searchparameter.html): A type of use context assigned to the search parameter
6190* [StructureDefinition](structuredefinition.html): A type of use context assigned to the structure definition
6191* [StructureMap](structuremap.html): A type of use context assigned to the structure map
6192* [TerminologyCapabilities](terminologycapabilities.html): A type of use context assigned to the terminology capabilities
6193* [ValueSet](valueset.html): A type of use context assigned to the value set
6194</b><br>
6195   * Type: <b>token</b><br>
6196   * Path: <b>CapabilityStatement.useContext.code | CodeSystem.useContext.code | CompartmentDefinition.useContext.code | ConceptMap.useContext.code | GraphDefinition.useContext.code | ImplementationGuide.useContext.code | MessageDefinition.useContext.code | NamingSystem.useContext.code | OperationDefinition.useContext.code | SearchParameter.useContext.code | StructureDefinition.useContext.code | StructureMap.useContext.code | TerminologyCapabilities.useContext.code | ValueSet.useContext.code</b><br>
6197   * </p>
6198   */
6199  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT_TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT_TYPE);
6200
6201 /**
6202   * Search parameter: <b>context</b>
6203   * <p>
6204   * Description: <b>Multiple Resources: 
6205
6206* [CapabilityStatement](capabilitystatement.html): A use context assigned to the capability statement
6207* [CodeSystem](codesystem.html): A use context assigned to the code system
6208* [CompartmentDefinition](compartmentdefinition.html): A use context assigned to the compartment definition
6209* [ConceptMap](conceptmap.html): A use context assigned to the concept map
6210* [GraphDefinition](graphdefinition.html): A use context assigned to the graph definition
6211* [ImplementationGuide](implementationguide.html): A use context assigned to the implementation guide
6212* [MessageDefinition](messagedefinition.html): A use context assigned to the message definition
6213* [NamingSystem](namingsystem.html): A use context assigned to the naming system
6214* [OperationDefinition](operationdefinition.html): A use context assigned to the operation definition
6215* [SearchParameter](searchparameter.html): A use context assigned to the search parameter
6216* [StructureDefinition](structuredefinition.html): A use context assigned to the structure definition
6217* [StructureMap](structuremap.html): A use context assigned to the structure map
6218* [TerminologyCapabilities](terminologycapabilities.html): A use context assigned to the terminology capabilities
6219* [ValueSet](valueset.html): A use context assigned to the value set
6220</b><br>
6221   * Type: <b>token</b><br>
6222   * Path: <b>(CapabilityStatement.useContext.value as CodeableConcept) | (CodeSystem.useContext.value as CodeableConcept) | (CompartmentDefinition.useContext.value as CodeableConcept) | (ConceptMap.useContext.value as CodeableConcept) | (GraphDefinition.useContext.value as CodeableConcept) | (ImplementationGuide.useContext.value as CodeableConcept) | (MessageDefinition.useContext.value as CodeableConcept) | (NamingSystem.useContext.value as CodeableConcept) | (OperationDefinition.useContext.value as CodeableConcept) | (SearchParameter.useContext.value as CodeableConcept) | (StructureDefinition.useContext.value as CodeableConcept) | (StructureMap.useContext.value as CodeableConcept) | (TerminologyCapabilities.useContext.value as CodeableConcept) | (ValueSet.useContext.value as CodeableConcept)</b><br>
6223   * </p>
6224   */
6225  @SearchParamDefinition(name="context", path="(CapabilityStatement.useContext.value as CodeableConcept) | (CodeSystem.useContext.value as CodeableConcept) | (CompartmentDefinition.useContext.value as CodeableConcept) | (ConceptMap.useContext.value as CodeableConcept) | (GraphDefinition.useContext.value as CodeableConcept) | (ImplementationGuide.useContext.value as CodeableConcept) | (MessageDefinition.useContext.value as CodeableConcept) | (NamingSystem.useContext.value as CodeableConcept) | (OperationDefinition.useContext.value as CodeableConcept) | (SearchParameter.useContext.value as CodeableConcept) | (StructureDefinition.useContext.value as CodeableConcept) | (StructureMap.useContext.value as CodeableConcept) | (TerminologyCapabilities.useContext.value as CodeableConcept) | (ValueSet.useContext.value as CodeableConcept)", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): A use context assigned to the capability statement\r\n* [CodeSystem](codesystem.html): A use context assigned to the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): A use context assigned to the compartment definition\r\n* [ConceptMap](conceptmap.html): A use context assigned to the concept map\r\n* [GraphDefinition](graphdefinition.html): A use context assigned to the graph definition\r\n* [ImplementationGuide](implementationguide.html): A use context assigned to the implementation guide\r\n* [MessageDefinition](messagedefinition.html): A use context assigned to the message definition\r\n* [NamingSystem](namingsystem.html): A use context assigned to the naming system\r\n* [OperationDefinition](operationdefinition.html): A use context assigned to the operation definition\r\n* [SearchParameter](searchparameter.html): A use context assigned to the search parameter\r\n* [StructureDefinition](structuredefinition.html): A use context assigned to the structure definition\r\n* [StructureMap](structuremap.html): A use context assigned to the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): A use context assigned to the terminology capabilities\r\n* [ValueSet](valueset.html): A use context assigned to the value set\r\n", type="token" )
6226  public static final String SP_CONTEXT = "context";
6227 /**
6228   * <b>Fluent Client</b> search parameter constant for <b>context</b>
6229   * <p>
6230   * Description: <b>Multiple Resources: 
6231
6232* [CapabilityStatement](capabilitystatement.html): A use context assigned to the capability statement
6233* [CodeSystem](codesystem.html): A use context assigned to the code system
6234* [CompartmentDefinition](compartmentdefinition.html): A use context assigned to the compartment definition
6235* [ConceptMap](conceptmap.html): A use context assigned to the concept map
6236* [GraphDefinition](graphdefinition.html): A use context assigned to the graph definition
6237* [ImplementationGuide](implementationguide.html): A use context assigned to the implementation guide
6238* [MessageDefinition](messagedefinition.html): A use context assigned to the message definition
6239* [NamingSystem](namingsystem.html): A use context assigned to the naming system
6240* [OperationDefinition](operationdefinition.html): A use context assigned to the operation definition
6241* [SearchParameter](searchparameter.html): A use context assigned to the search parameter
6242* [StructureDefinition](structuredefinition.html): A use context assigned to the structure definition
6243* [StructureMap](structuremap.html): A use context assigned to the structure map
6244* [TerminologyCapabilities](terminologycapabilities.html): A use context assigned to the terminology capabilities
6245* [ValueSet](valueset.html): A use context assigned to the value set
6246</b><br>
6247   * Type: <b>token</b><br>
6248   * Path: <b>(CapabilityStatement.useContext.value as CodeableConcept) | (CodeSystem.useContext.value as CodeableConcept) | (CompartmentDefinition.useContext.value as CodeableConcept) | (ConceptMap.useContext.value as CodeableConcept) | (GraphDefinition.useContext.value as CodeableConcept) | (ImplementationGuide.useContext.value as CodeableConcept) | (MessageDefinition.useContext.value as CodeableConcept) | (NamingSystem.useContext.value as CodeableConcept) | (OperationDefinition.useContext.value as CodeableConcept) | (SearchParameter.useContext.value as CodeableConcept) | (StructureDefinition.useContext.value as CodeableConcept) | (StructureMap.useContext.value as CodeableConcept) | (TerminologyCapabilities.useContext.value as CodeableConcept) | (ValueSet.useContext.value as CodeableConcept)</b><br>
6249   * </p>
6250   */
6251  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT);
6252
6253 /**
6254   * Search parameter: <b>date</b>
6255   * <p>
6256   * Description: <b>Multiple Resources: 
6257
6258* [CapabilityStatement](capabilitystatement.html): The capability statement publication date
6259* [CodeSystem](codesystem.html): The code system publication date
6260* [CompartmentDefinition](compartmentdefinition.html): The compartment definition publication date
6261* [ConceptMap](conceptmap.html): The concept map publication date
6262* [GraphDefinition](graphdefinition.html): The graph definition publication date
6263* [ImplementationGuide](implementationguide.html): The implementation guide publication date
6264* [MessageDefinition](messagedefinition.html): The message definition publication date
6265* [NamingSystem](namingsystem.html): The naming system publication date
6266* [OperationDefinition](operationdefinition.html): The operation definition publication date
6267* [SearchParameter](searchparameter.html): The search parameter publication date
6268* [StructureDefinition](structuredefinition.html): The structure definition publication date
6269* [StructureMap](structuremap.html): The structure map publication date
6270* [TerminologyCapabilities](terminologycapabilities.html): The terminology capabilities publication date
6271* [ValueSet](valueset.html): The value set publication date
6272</b><br>
6273   * Type: <b>date</b><br>
6274   * Path: <b>CapabilityStatement.date | CodeSystem.date | CompartmentDefinition.date | ConceptMap.date | GraphDefinition.date | ImplementationGuide.date | MessageDefinition.date | NamingSystem.date | OperationDefinition.date | SearchParameter.date | StructureDefinition.date | StructureMap.date | TerminologyCapabilities.date | ValueSet.date</b><br>
6275   * </p>
6276   */
6277  @SearchParamDefinition(name="date", path="CapabilityStatement.date | CodeSystem.date | CompartmentDefinition.date | ConceptMap.date | GraphDefinition.date | ImplementationGuide.date | MessageDefinition.date | NamingSystem.date | OperationDefinition.date | SearchParameter.date | StructureDefinition.date | StructureMap.date | TerminologyCapabilities.date | ValueSet.date", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): The capability statement publication date\r\n* [CodeSystem](codesystem.html): The code system publication date\r\n* [CompartmentDefinition](compartmentdefinition.html): The compartment definition publication date\r\n* [ConceptMap](conceptmap.html): The concept map publication date\r\n* [GraphDefinition](graphdefinition.html): The graph definition publication date\r\n* [ImplementationGuide](implementationguide.html): The implementation guide publication date\r\n* [MessageDefinition](messagedefinition.html): The message definition publication date\r\n* [NamingSystem](namingsystem.html): The naming system publication date\r\n* [OperationDefinition](operationdefinition.html): The operation definition publication date\r\n* [SearchParameter](searchparameter.html): The search parameter publication date\r\n* [StructureDefinition](structuredefinition.html): The structure definition publication date\r\n* [StructureMap](structuremap.html): The structure map publication date\r\n* [TerminologyCapabilities](terminologycapabilities.html): The terminology capabilities publication date\r\n* [ValueSet](valueset.html): The value set publication date\r\n", type="date" )
6278  public static final String SP_DATE = "date";
6279 /**
6280   * <b>Fluent Client</b> search parameter constant for <b>date</b>
6281   * <p>
6282   * Description: <b>Multiple Resources: 
6283
6284* [CapabilityStatement](capabilitystatement.html): The capability statement publication date
6285* [CodeSystem](codesystem.html): The code system publication date
6286* [CompartmentDefinition](compartmentdefinition.html): The compartment definition publication date
6287* [ConceptMap](conceptmap.html): The concept map publication date
6288* [GraphDefinition](graphdefinition.html): The graph definition publication date
6289* [ImplementationGuide](implementationguide.html): The implementation guide publication date
6290* [MessageDefinition](messagedefinition.html): The message definition publication date
6291* [NamingSystem](namingsystem.html): The naming system publication date
6292* [OperationDefinition](operationdefinition.html): The operation definition publication date
6293* [SearchParameter](searchparameter.html): The search parameter publication date
6294* [StructureDefinition](structuredefinition.html): The structure definition publication date
6295* [StructureMap](structuremap.html): The structure map publication date
6296* [TerminologyCapabilities](terminologycapabilities.html): The terminology capabilities publication date
6297* [ValueSet](valueset.html): The value set publication date
6298</b><br>
6299   * Type: <b>date</b><br>
6300   * Path: <b>CapabilityStatement.date | CodeSystem.date | CompartmentDefinition.date | ConceptMap.date | GraphDefinition.date | ImplementationGuide.date | MessageDefinition.date | NamingSystem.date | OperationDefinition.date | SearchParameter.date | StructureDefinition.date | StructureMap.date | TerminologyCapabilities.date | ValueSet.date</b><br>
6301   * </p>
6302   */
6303  public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_DATE);
6304
6305 /**
6306   * Search parameter: <b>description</b>
6307   * <p>
6308   * Description: <b>Multiple Resources: 
6309
6310* [CapabilityStatement](capabilitystatement.html): The description of the capability statement
6311* [CodeSystem](codesystem.html): The description of the code system
6312* [CompartmentDefinition](compartmentdefinition.html): The description of the compartment definition
6313* [ConceptMap](conceptmap.html): The description of the concept map
6314* [GraphDefinition](graphdefinition.html): The description of the graph definition
6315* [ImplementationGuide](implementationguide.html): The description of the implementation guide
6316* [MessageDefinition](messagedefinition.html): The description of the message definition
6317* [NamingSystem](namingsystem.html): The description of the naming system
6318* [OperationDefinition](operationdefinition.html): The description of the operation definition
6319* [SearchParameter](searchparameter.html): The description of the search parameter
6320* [StructureDefinition](structuredefinition.html): The description of the structure definition
6321* [StructureMap](structuremap.html): The description of the structure map
6322* [TerminologyCapabilities](terminologycapabilities.html): The description of the terminology capabilities
6323* [ValueSet](valueset.html): The description of the value set
6324</b><br>
6325   * Type: <b>string</b><br>
6326   * Path: <b>CapabilityStatement.description | CodeSystem.description | CompartmentDefinition.description | ConceptMap.description | GraphDefinition.description | ImplementationGuide.description | MessageDefinition.description | NamingSystem.description | OperationDefinition.description | SearchParameter.description | StructureDefinition.description | StructureMap.description | TerminologyCapabilities.description | ValueSet.description</b><br>
6327   * </p>
6328   */
6329  @SearchParamDefinition(name="description", path="CapabilityStatement.description | CodeSystem.description | CompartmentDefinition.description | ConceptMap.description | GraphDefinition.description | ImplementationGuide.description | MessageDefinition.description | NamingSystem.description | OperationDefinition.description | SearchParameter.description | StructureDefinition.description | StructureMap.description | TerminologyCapabilities.description | ValueSet.description", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): The description of the capability statement\r\n* [CodeSystem](codesystem.html): The description of the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): The description of the compartment definition\r\n* [ConceptMap](conceptmap.html): The description of the concept map\r\n* [GraphDefinition](graphdefinition.html): The description of the graph definition\r\n* [ImplementationGuide](implementationguide.html): The description of the implementation guide\r\n* [MessageDefinition](messagedefinition.html): The description of the message definition\r\n* [NamingSystem](namingsystem.html): The description of the naming system\r\n* [OperationDefinition](operationdefinition.html): The description of the operation definition\r\n* [SearchParameter](searchparameter.html): The description of the search parameter\r\n* [StructureDefinition](structuredefinition.html): The description of the structure definition\r\n* [StructureMap](structuremap.html): The description of the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): The description of the terminology capabilities\r\n* [ValueSet](valueset.html): The description of the value set\r\n", type="string" )
6330  public static final String SP_DESCRIPTION = "description";
6331 /**
6332   * <b>Fluent Client</b> search parameter constant for <b>description</b>
6333   * <p>
6334   * Description: <b>Multiple Resources: 
6335
6336* [CapabilityStatement](capabilitystatement.html): The description of the capability statement
6337* [CodeSystem](codesystem.html): The description of the code system
6338* [CompartmentDefinition](compartmentdefinition.html): The description of the compartment definition
6339* [ConceptMap](conceptmap.html): The description of the concept map
6340* [GraphDefinition](graphdefinition.html): The description of the graph definition
6341* [ImplementationGuide](implementationguide.html): The description of the implementation guide
6342* [MessageDefinition](messagedefinition.html): The description of the message definition
6343* [NamingSystem](namingsystem.html): The description of the naming system
6344* [OperationDefinition](operationdefinition.html): The description of the operation definition
6345* [SearchParameter](searchparameter.html): The description of the search parameter
6346* [StructureDefinition](structuredefinition.html): The description of the structure definition
6347* [StructureMap](structuremap.html): The description of the structure map
6348* [TerminologyCapabilities](terminologycapabilities.html): The description of the terminology capabilities
6349* [ValueSet](valueset.html): The description of the value set
6350</b><br>
6351   * Type: <b>string</b><br>
6352   * Path: <b>CapabilityStatement.description | CodeSystem.description | CompartmentDefinition.description | ConceptMap.description | GraphDefinition.description | ImplementationGuide.description | MessageDefinition.description | NamingSystem.description | OperationDefinition.description | SearchParameter.description | StructureDefinition.description | StructureMap.description | TerminologyCapabilities.description | ValueSet.description</b><br>
6353   * </p>
6354   */
6355  public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_DESCRIPTION);
6356
6357 /**
6358   * Search parameter: <b>identifier</b>
6359   * <p>
6360   * Description: <b>Multiple Resources: 
6361
6362* [CodeSystem](codesystem.html): External identifier for the code system
6363* [ConceptMap](conceptmap.html): External identifier for the concept map
6364* [MessageDefinition](messagedefinition.html): External identifier for the message definition
6365* [NamingSystem](namingsystem.html): External identifier for the naming system
6366* [StructureDefinition](structuredefinition.html): External identifier for the structure definition
6367* [StructureMap](structuremap.html): External identifier for the structure map
6368* [TerminologyCapabilities](terminologycapabilities.html): External identifier for the terminology capabilities
6369* [ValueSet](valueset.html): External identifier for the value set
6370</b><br>
6371   * Type: <b>token</b><br>
6372   * Path: <b>CodeSystem.identifier | ConceptMap.identifier | MessageDefinition.identifier | NamingSystem.identifier | StructureDefinition.identifier | StructureMap.identifier | TerminologyCapabilities.identifier | ValueSet.identifier</b><br>
6373   * </p>
6374   */
6375  @SearchParamDefinition(name="identifier", path="CodeSystem.identifier | ConceptMap.identifier | MessageDefinition.identifier | NamingSystem.identifier | StructureDefinition.identifier | StructureMap.identifier | TerminologyCapabilities.identifier | ValueSet.identifier", description="Multiple Resources: \r\n\r\n* [CodeSystem](codesystem.html): External identifier for the code system\r\n* [ConceptMap](conceptmap.html): External identifier for the concept map\r\n* [MessageDefinition](messagedefinition.html): External identifier for the message definition\r\n* [NamingSystem](namingsystem.html): External identifier for the naming system\r\n* [StructureDefinition](structuredefinition.html): External identifier for the structure definition\r\n* [StructureMap](structuremap.html): External identifier for the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): External identifier for the terminology capabilities\r\n* [ValueSet](valueset.html): External identifier for the value set\r\n", type="token" )
6376  public static final String SP_IDENTIFIER = "identifier";
6377 /**
6378   * <b>Fluent Client</b> search parameter constant for <b>identifier</b>
6379   * <p>
6380   * Description: <b>Multiple Resources: 
6381
6382* [CodeSystem](codesystem.html): External identifier for the code system
6383* [ConceptMap](conceptmap.html): External identifier for the concept map
6384* [MessageDefinition](messagedefinition.html): External identifier for the message definition
6385* [NamingSystem](namingsystem.html): External identifier for the naming system
6386* [StructureDefinition](structuredefinition.html): External identifier for the structure definition
6387* [StructureMap](structuremap.html): External identifier for the structure map
6388* [TerminologyCapabilities](terminologycapabilities.html): External identifier for the terminology capabilities
6389* [ValueSet](valueset.html): External identifier for the value set
6390</b><br>
6391   * Type: <b>token</b><br>
6392   * Path: <b>CodeSystem.identifier | ConceptMap.identifier | MessageDefinition.identifier | NamingSystem.identifier | StructureDefinition.identifier | StructureMap.identifier | TerminologyCapabilities.identifier | ValueSet.identifier</b><br>
6393   * </p>
6394   */
6395  public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER);
6396
6397 /**
6398   * Search parameter: <b>jurisdiction</b>
6399   * <p>
6400   * Description: <b>Multiple Resources: 
6401
6402* [CapabilityStatement](capabilitystatement.html): Intended jurisdiction for the capability statement
6403* [CodeSystem](codesystem.html): Intended jurisdiction for the code system
6404* [ConceptMap](conceptmap.html): Intended jurisdiction for the concept map
6405* [GraphDefinition](graphdefinition.html): Intended jurisdiction for the graph definition
6406* [ImplementationGuide](implementationguide.html): Intended jurisdiction for the implementation guide
6407* [MessageDefinition](messagedefinition.html): Intended jurisdiction for the message definition
6408* [NamingSystem](namingsystem.html): Intended jurisdiction for the naming system
6409* [OperationDefinition](operationdefinition.html): Intended jurisdiction for the operation definition
6410* [SearchParameter](searchparameter.html): Intended jurisdiction for the search parameter
6411* [StructureDefinition](structuredefinition.html): Intended jurisdiction for the structure definition
6412* [StructureMap](structuremap.html): Intended jurisdiction for the structure map
6413* [TerminologyCapabilities](terminologycapabilities.html): Intended jurisdiction for the terminology capabilities
6414* [ValueSet](valueset.html): Intended jurisdiction for the value set
6415</b><br>
6416   * Type: <b>token</b><br>
6417   * Path: <b>CapabilityStatement.jurisdiction | CodeSystem.jurisdiction | ConceptMap.jurisdiction | GraphDefinition.jurisdiction | ImplementationGuide.jurisdiction | MessageDefinition.jurisdiction | NamingSystem.jurisdiction | OperationDefinition.jurisdiction | SearchParameter.jurisdiction | StructureDefinition.jurisdiction | StructureMap.jurisdiction | TerminologyCapabilities.jurisdiction | ValueSet.jurisdiction</b><br>
6418   * </p>
6419   */
6420  @SearchParamDefinition(name="jurisdiction", path="CapabilityStatement.jurisdiction | CodeSystem.jurisdiction | ConceptMap.jurisdiction | GraphDefinition.jurisdiction | ImplementationGuide.jurisdiction | MessageDefinition.jurisdiction | NamingSystem.jurisdiction | OperationDefinition.jurisdiction | SearchParameter.jurisdiction | StructureDefinition.jurisdiction | StructureMap.jurisdiction | TerminologyCapabilities.jurisdiction | ValueSet.jurisdiction", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): Intended jurisdiction for the capability statement\r\n* [CodeSystem](codesystem.html): Intended jurisdiction for the code system\r\n* [ConceptMap](conceptmap.html): Intended jurisdiction for the concept map\r\n* [GraphDefinition](graphdefinition.html): Intended jurisdiction for the graph definition\r\n* [ImplementationGuide](implementationguide.html): Intended jurisdiction for the implementation guide\r\n* [MessageDefinition](messagedefinition.html): Intended jurisdiction for the message definition\r\n* [NamingSystem](namingsystem.html): Intended jurisdiction for the naming system\r\n* [OperationDefinition](operationdefinition.html): Intended jurisdiction for the operation definition\r\n* [SearchParameter](searchparameter.html): Intended jurisdiction for the search parameter\r\n* [StructureDefinition](structuredefinition.html): Intended jurisdiction for the structure definition\r\n* [StructureMap](structuremap.html): Intended jurisdiction for the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): Intended jurisdiction for the terminology capabilities\r\n* [ValueSet](valueset.html): Intended jurisdiction for the value set\r\n", type="token" )
6421  public static final String SP_JURISDICTION = "jurisdiction";
6422 /**
6423   * <b>Fluent Client</b> search parameter constant for <b>jurisdiction</b>
6424   * <p>
6425   * Description: <b>Multiple Resources: 
6426
6427* [CapabilityStatement](capabilitystatement.html): Intended jurisdiction for the capability statement
6428* [CodeSystem](codesystem.html): Intended jurisdiction for the code system
6429* [ConceptMap](conceptmap.html): Intended jurisdiction for the concept map
6430* [GraphDefinition](graphdefinition.html): Intended jurisdiction for the graph definition
6431* [ImplementationGuide](implementationguide.html): Intended jurisdiction for the implementation guide
6432* [MessageDefinition](messagedefinition.html): Intended jurisdiction for the message definition
6433* [NamingSystem](namingsystem.html): Intended jurisdiction for the naming system
6434* [OperationDefinition](operationdefinition.html): Intended jurisdiction for the operation definition
6435* [SearchParameter](searchparameter.html): Intended jurisdiction for the search parameter
6436* [StructureDefinition](structuredefinition.html): Intended jurisdiction for the structure definition
6437* [StructureMap](structuremap.html): Intended jurisdiction for the structure map
6438* [TerminologyCapabilities](terminologycapabilities.html): Intended jurisdiction for the terminology capabilities
6439* [ValueSet](valueset.html): Intended jurisdiction for the value set
6440</b><br>
6441   * Type: <b>token</b><br>
6442   * Path: <b>CapabilityStatement.jurisdiction | CodeSystem.jurisdiction | ConceptMap.jurisdiction | GraphDefinition.jurisdiction | ImplementationGuide.jurisdiction | MessageDefinition.jurisdiction | NamingSystem.jurisdiction | OperationDefinition.jurisdiction | SearchParameter.jurisdiction | StructureDefinition.jurisdiction | StructureMap.jurisdiction | TerminologyCapabilities.jurisdiction | ValueSet.jurisdiction</b><br>
6443   * </p>
6444   */
6445  public static final ca.uhn.fhir.rest.gclient.TokenClientParam JURISDICTION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_JURISDICTION);
6446
6447 /**
6448   * Search parameter: <b>name</b>
6449   * <p>
6450   * Description: <b>Multiple Resources: 
6451
6452* [CapabilityStatement](capabilitystatement.html): Computationally friendly name of the capability statement
6453* [CodeSystem](codesystem.html): Computationally friendly name of the code system
6454* [CompartmentDefinition](compartmentdefinition.html): Computationally friendly name of the compartment definition
6455* [ConceptMap](conceptmap.html): Computationally friendly name of the concept map
6456* [GraphDefinition](graphdefinition.html): Computationally friendly name of the graph definition
6457* [ImplementationGuide](implementationguide.html): Computationally friendly name of the implementation guide
6458* [MessageDefinition](messagedefinition.html): Computationally friendly name of the message definition
6459* [NamingSystem](namingsystem.html): Computationally friendly name of the naming system
6460* [OperationDefinition](operationdefinition.html): Computationally friendly name of the operation definition
6461* [SearchParameter](searchparameter.html): Computationally friendly name of the search parameter
6462* [StructureDefinition](structuredefinition.html): Computationally friendly name of the structure definition
6463* [StructureMap](structuremap.html): Computationally friendly name of the structure map
6464* [TerminologyCapabilities](terminologycapabilities.html): Computationally friendly name of the terminology capabilities
6465* [ValueSet](valueset.html): Computationally friendly name of the value set
6466</b><br>
6467   * Type: <b>string</b><br>
6468   * Path: <b>CapabilityStatement.name | CodeSystem.name | CompartmentDefinition.name | ConceptMap.name | GraphDefinition.name | ImplementationGuide.name | MessageDefinition.name | NamingSystem.name | OperationDefinition.name | SearchParameter.name | StructureDefinition.name | StructureMap.name | TerminologyCapabilities.name | ValueSet.name</b><br>
6469   * </p>
6470   */
6471  @SearchParamDefinition(name="name", path="CapabilityStatement.name | CodeSystem.name | CompartmentDefinition.name | ConceptMap.name | GraphDefinition.name | ImplementationGuide.name | MessageDefinition.name | NamingSystem.name | OperationDefinition.name | SearchParameter.name | StructureDefinition.name | StructureMap.name | TerminologyCapabilities.name | ValueSet.name", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): Computationally friendly name of the capability statement\r\n* [CodeSystem](codesystem.html): Computationally friendly name of the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): Computationally friendly name of the compartment definition\r\n* [ConceptMap](conceptmap.html): Computationally friendly name of the concept map\r\n* [GraphDefinition](graphdefinition.html): Computationally friendly name of the graph definition\r\n* [ImplementationGuide](implementationguide.html): Computationally friendly name of the implementation guide\r\n* [MessageDefinition](messagedefinition.html): Computationally friendly name of the message definition\r\n* [NamingSystem](namingsystem.html): Computationally friendly name of the naming system\r\n* [OperationDefinition](operationdefinition.html): Computationally friendly name of the operation definition\r\n* [SearchParameter](searchparameter.html): Computationally friendly name of the search parameter\r\n* [StructureDefinition](structuredefinition.html): Computationally friendly name of the structure definition\r\n* [StructureMap](structuremap.html): Computationally friendly name of the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): Computationally friendly name of the terminology capabilities\r\n* [ValueSet](valueset.html): Computationally friendly name of the value set\r\n", type="string" )
6472  public static final String SP_NAME = "name";
6473 /**
6474   * <b>Fluent Client</b> search parameter constant for <b>name</b>
6475   * <p>
6476   * Description: <b>Multiple Resources: 
6477
6478* [CapabilityStatement](capabilitystatement.html): Computationally friendly name of the capability statement
6479* [CodeSystem](codesystem.html): Computationally friendly name of the code system
6480* [CompartmentDefinition](compartmentdefinition.html): Computationally friendly name of the compartment definition
6481* [ConceptMap](conceptmap.html): Computationally friendly name of the concept map
6482* [GraphDefinition](graphdefinition.html): Computationally friendly name of the graph definition
6483* [ImplementationGuide](implementationguide.html): Computationally friendly name of the implementation guide
6484* [MessageDefinition](messagedefinition.html): Computationally friendly name of the message definition
6485* [NamingSystem](namingsystem.html): Computationally friendly name of the naming system
6486* [OperationDefinition](operationdefinition.html): Computationally friendly name of the operation definition
6487* [SearchParameter](searchparameter.html): Computationally friendly name of the search parameter
6488* [StructureDefinition](structuredefinition.html): Computationally friendly name of the structure definition
6489* [StructureMap](structuremap.html): Computationally friendly name of the structure map
6490* [TerminologyCapabilities](terminologycapabilities.html): Computationally friendly name of the terminology capabilities
6491* [ValueSet](valueset.html): Computationally friendly name of the value set
6492</b><br>
6493   * Type: <b>string</b><br>
6494   * Path: <b>CapabilityStatement.name | CodeSystem.name | CompartmentDefinition.name | ConceptMap.name | GraphDefinition.name | ImplementationGuide.name | MessageDefinition.name | NamingSystem.name | OperationDefinition.name | SearchParameter.name | StructureDefinition.name | StructureMap.name | TerminologyCapabilities.name | ValueSet.name</b><br>
6495   * </p>
6496   */
6497  public static final ca.uhn.fhir.rest.gclient.StringClientParam NAME = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_NAME);
6498
6499 /**
6500   * Search parameter: <b>publisher</b>
6501   * <p>
6502   * Description: <b>Multiple Resources: 
6503
6504* [CapabilityStatement](capabilitystatement.html): Name of the publisher of the capability statement
6505* [CodeSystem](codesystem.html): Name of the publisher of the code system
6506* [CompartmentDefinition](compartmentdefinition.html): Name of the publisher of the compartment definition
6507* [ConceptMap](conceptmap.html): Name of the publisher of the concept map
6508* [GraphDefinition](graphdefinition.html): Name of the publisher of the graph definition
6509* [ImplementationGuide](implementationguide.html): Name of the publisher of the implementation guide
6510* [MessageDefinition](messagedefinition.html): Name of the publisher of the message definition
6511* [NamingSystem](namingsystem.html): Name of the publisher of the naming system
6512* [OperationDefinition](operationdefinition.html): Name of the publisher of the operation definition
6513* [SearchParameter](searchparameter.html): Name of the publisher of the search parameter
6514* [StructureDefinition](structuredefinition.html): Name of the publisher of the structure definition
6515* [StructureMap](structuremap.html): Name of the publisher of the structure map
6516* [TerminologyCapabilities](terminologycapabilities.html): Name of the publisher of the terminology capabilities
6517* [ValueSet](valueset.html): Name of the publisher of the value set
6518</b><br>
6519   * Type: <b>string</b><br>
6520   * Path: <b>CapabilityStatement.publisher | CodeSystem.publisher | CompartmentDefinition.publisher | ConceptMap.publisher | GraphDefinition.publisher | ImplementationGuide.publisher | MessageDefinition.publisher | NamingSystem.publisher | OperationDefinition.publisher | SearchParameter.publisher | StructureDefinition.publisher | StructureMap.publisher | TerminologyCapabilities.publisher | ValueSet.publisher</b><br>
6521   * </p>
6522   */
6523  @SearchParamDefinition(name="publisher", path="CapabilityStatement.publisher | CodeSystem.publisher | CompartmentDefinition.publisher | ConceptMap.publisher | GraphDefinition.publisher | ImplementationGuide.publisher | MessageDefinition.publisher | NamingSystem.publisher | OperationDefinition.publisher | SearchParameter.publisher | StructureDefinition.publisher | StructureMap.publisher | TerminologyCapabilities.publisher | ValueSet.publisher", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): Name of the publisher of the capability statement\r\n* [CodeSystem](codesystem.html): Name of the publisher of the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): Name of the publisher of the compartment definition\r\n* [ConceptMap](conceptmap.html): Name of the publisher of the concept map\r\n* [GraphDefinition](graphdefinition.html): Name of the publisher of the graph definition\r\n* [ImplementationGuide](implementationguide.html): Name of the publisher of the implementation guide\r\n* [MessageDefinition](messagedefinition.html): Name of the publisher of the message definition\r\n* [NamingSystem](namingsystem.html): Name of the publisher of the naming system\r\n* [OperationDefinition](operationdefinition.html): Name of the publisher of the operation definition\r\n* [SearchParameter](searchparameter.html): Name of the publisher of the search parameter\r\n* [StructureDefinition](structuredefinition.html): Name of the publisher of the structure definition\r\n* [StructureMap](structuremap.html): Name of the publisher of the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): Name of the publisher of the terminology capabilities\r\n* [ValueSet](valueset.html): Name of the publisher of the value set\r\n", type="string" )
6524  public static final String SP_PUBLISHER = "publisher";
6525 /**
6526   * <b>Fluent Client</b> search parameter constant for <b>publisher</b>
6527   * <p>
6528   * Description: <b>Multiple Resources: 
6529
6530* [CapabilityStatement](capabilitystatement.html): Name of the publisher of the capability statement
6531* [CodeSystem](codesystem.html): Name of the publisher of the code system
6532* [CompartmentDefinition](compartmentdefinition.html): Name of the publisher of the compartment definition
6533* [ConceptMap](conceptmap.html): Name of the publisher of the concept map
6534* [GraphDefinition](graphdefinition.html): Name of the publisher of the graph definition
6535* [ImplementationGuide](implementationguide.html): Name of the publisher of the implementation guide
6536* [MessageDefinition](messagedefinition.html): Name of the publisher of the message definition
6537* [NamingSystem](namingsystem.html): Name of the publisher of the naming system
6538* [OperationDefinition](operationdefinition.html): Name of the publisher of the operation definition
6539* [SearchParameter](searchparameter.html): Name of the publisher of the search parameter
6540* [StructureDefinition](structuredefinition.html): Name of the publisher of the structure definition
6541* [StructureMap](structuremap.html): Name of the publisher of the structure map
6542* [TerminologyCapabilities](terminologycapabilities.html): Name of the publisher of the terminology capabilities
6543* [ValueSet](valueset.html): Name of the publisher of the value set
6544</b><br>
6545   * Type: <b>string</b><br>
6546   * Path: <b>CapabilityStatement.publisher | CodeSystem.publisher | CompartmentDefinition.publisher | ConceptMap.publisher | GraphDefinition.publisher | ImplementationGuide.publisher | MessageDefinition.publisher | NamingSystem.publisher | OperationDefinition.publisher | SearchParameter.publisher | StructureDefinition.publisher | StructureMap.publisher | TerminologyCapabilities.publisher | ValueSet.publisher</b><br>
6547   * </p>
6548   */
6549  public static final ca.uhn.fhir.rest.gclient.StringClientParam PUBLISHER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_PUBLISHER);
6550
6551 /**
6552   * Search parameter: <b>status</b>
6553   * <p>
6554   * Description: <b>Multiple Resources: 
6555
6556* [CapabilityStatement](capabilitystatement.html): The current status of the capability statement
6557* [CodeSystem](codesystem.html): The current status of the code system
6558* [CompartmentDefinition](compartmentdefinition.html): The current status of the compartment definition
6559* [ConceptMap](conceptmap.html): The current status of the concept map
6560* [GraphDefinition](graphdefinition.html): The current status of the graph definition
6561* [ImplementationGuide](implementationguide.html): The current status of the implementation guide
6562* [MessageDefinition](messagedefinition.html): The current status of the message definition
6563* [NamingSystem](namingsystem.html): The current status of the naming system
6564* [OperationDefinition](operationdefinition.html): The current status of the operation definition
6565* [SearchParameter](searchparameter.html): The current status of the search parameter
6566* [StructureDefinition](structuredefinition.html): The current status of the structure definition
6567* [StructureMap](structuremap.html): The current status of the structure map
6568* [TerminologyCapabilities](terminologycapabilities.html): The current status of the terminology capabilities
6569* [ValueSet](valueset.html): The current status of the value set
6570</b><br>
6571   * Type: <b>token</b><br>
6572   * Path: <b>CapabilityStatement.status | CodeSystem.status | CompartmentDefinition.status | ConceptMap.status | GraphDefinition.status | ImplementationGuide.status | MessageDefinition.status | NamingSystem.status | OperationDefinition.status | SearchParameter.status | StructureDefinition.status | StructureMap.status | TerminologyCapabilities.status | ValueSet.status</b><br>
6573   * </p>
6574   */
6575  @SearchParamDefinition(name="status", path="CapabilityStatement.status | CodeSystem.status | CompartmentDefinition.status | ConceptMap.status | GraphDefinition.status | ImplementationGuide.status | MessageDefinition.status | NamingSystem.status | OperationDefinition.status | SearchParameter.status | StructureDefinition.status | StructureMap.status | TerminologyCapabilities.status | ValueSet.status", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): The current status of the capability statement\r\n* [CodeSystem](codesystem.html): The current status of the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): The current status of the compartment definition\r\n* [ConceptMap](conceptmap.html): The current status of the concept map\r\n* [GraphDefinition](graphdefinition.html): The current status of the graph definition\r\n* [ImplementationGuide](implementationguide.html): The current status of the implementation guide\r\n* [MessageDefinition](messagedefinition.html): The current status of the message definition\r\n* [NamingSystem](namingsystem.html): The current status of the naming system\r\n* [OperationDefinition](operationdefinition.html): The current status of the operation definition\r\n* [SearchParameter](searchparameter.html): The current status of the search parameter\r\n* [StructureDefinition](structuredefinition.html): The current status of the structure definition\r\n* [StructureMap](structuremap.html): The current status of the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): The current status of the terminology capabilities\r\n* [ValueSet](valueset.html): The current status of the value set\r\n", type="token" )
6576  public static final String SP_STATUS = "status";
6577 /**
6578   * <b>Fluent Client</b> search parameter constant for <b>status</b>
6579   * <p>
6580   * Description: <b>Multiple Resources: 
6581
6582* [CapabilityStatement](capabilitystatement.html): The current status of the capability statement
6583* [CodeSystem](codesystem.html): The current status of the code system
6584* [CompartmentDefinition](compartmentdefinition.html): The current status of the compartment definition
6585* [ConceptMap](conceptmap.html): The current status of the concept map
6586* [GraphDefinition](graphdefinition.html): The current status of the graph definition
6587* [ImplementationGuide](implementationguide.html): The current status of the implementation guide
6588* [MessageDefinition](messagedefinition.html): The current status of the message definition
6589* [NamingSystem](namingsystem.html): The current status of the naming system
6590* [OperationDefinition](operationdefinition.html): The current status of the operation definition
6591* [SearchParameter](searchparameter.html): The current status of the search parameter
6592* [StructureDefinition](structuredefinition.html): The current status of the structure definition
6593* [StructureMap](structuremap.html): The current status of the structure map
6594* [TerminologyCapabilities](terminologycapabilities.html): The current status of the terminology capabilities
6595* [ValueSet](valueset.html): The current status of the value set
6596</b><br>
6597   * Type: <b>token</b><br>
6598   * Path: <b>CapabilityStatement.status | CodeSystem.status | CompartmentDefinition.status | ConceptMap.status | GraphDefinition.status | ImplementationGuide.status | MessageDefinition.status | NamingSystem.status | OperationDefinition.status | SearchParameter.status | StructureDefinition.status | StructureMap.status | TerminologyCapabilities.status | ValueSet.status</b><br>
6599   * </p>
6600   */
6601  public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS);
6602
6603 /**
6604   * Search parameter: <b>title</b>
6605   * <p>
6606   * Description: <b>Multiple Resources: 
6607
6608* [CapabilityStatement](capabilitystatement.html): The human-friendly name of the capability statement
6609* [CodeSystem](codesystem.html): The human-friendly name of the code system
6610* [ConceptMap](conceptmap.html): The human-friendly name of the concept map
6611* [ImplementationGuide](implementationguide.html): The human-friendly name of the implementation guide
6612* [MessageDefinition](messagedefinition.html): The human-friendly name of the message definition
6613* [OperationDefinition](operationdefinition.html): The human-friendly name of the operation definition
6614* [StructureDefinition](structuredefinition.html): The human-friendly name of the structure definition
6615* [StructureMap](structuremap.html): The human-friendly name of the structure map
6616* [TerminologyCapabilities](terminologycapabilities.html): The human-friendly name of the terminology capabilities
6617* [ValueSet](valueset.html): The human-friendly name of the value set
6618</b><br>
6619   * Type: <b>string</b><br>
6620   * Path: <b>CapabilityStatement.title | CodeSystem.title | ConceptMap.title | ImplementationGuide.title | MessageDefinition.title | OperationDefinition.title | StructureDefinition.title | StructureMap.title | TerminologyCapabilities.title | ValueSet.title</b><br>
6621   * </p>
6622   */
6623  @SearchParamDefinition(name="title", path="CapabilityStatement.title | CodeSystem.title | ConceptMap.title | ImplementationGuide.title | MessageDefinition.title | OperationDefinition.title | StructureDefinition.title | StructureMap.title | TerminologyCapabilities.title | ValueSet.title", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): The human-friendly name of the capability statement\r\n* [CodeSystem](codesystem.html): The human-friendly name of the code system\r\n* [ConceptMap](conceptmap.html): The human-friendly name of the concept map\r\n* [ImplementationGuide](implementationguide.html): The human-friendly name of the implementation guide\r\n* [MessageDefinition](messagedefinition.html): The human-friendly name of the message definition\r\n* [OperationDefinition](operationdefinition.html): The human-friendly name of the operation definition\r\n* [StructureDefinition](structuredefinition.html): The human-friendly name of the structure definition\r\n* [StructureMap](structuremap.html): The human-friendly name of the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): The human-friendly name of the terminology capabilities\r\n* [ValueSet](valueset.html): The human-friendly name of the value set\r\n", type="string" )
6624  public static final String SP_TITLE = "title";
6625 /**
6626   * <b>Fluent Client</b> search parameter constant for <b>title</b>
6627   * <p>
6628   * Description: <b>Multiple Resources: 
6629
6630* [CapabilityStatement](capabilitystatement.html): The human-friendly name of the capability statement
6631* [CodeSystem](codesystem.html): The human-friendly name of the code system
6632* [ConceptMap](conceptmap.html): The human-friendly name of the concept map
6633* [ImplementationGuide](implementationguide.html): The human-friendly name of the implementation guide
6634* [MessageDefinition](messagedefinition.html): The human-friendly name of the message definition
6635* [OperationDefinition](operationdefinition.html): The human-friendly name of the operation definition
6636* [StructureDefinition](structuredefinition.html): The human-friendly name of the structure definition
6637* [StructureMap](structuremap.html): The human-friendly name of the structure map
6638* [TerminologyCapabilities](terminologycapabilities.html): The human-friendly name of the terminology capabilities
6639* [ValueSet](valueset.html): The human-friendly name of the value set
6640</b><br>
6641   * Type: <b>string</b><br>
6642   * Path: <b>CapabilityStatement.title | CodeSystem.title | ConceptMap.title | ImplementationGuide.title | MessageDefinition.title | OperationDefinition.title | StructureDefinition.title | StructureMap.title | TerminologyCapabilities.title | ValueSet.title</b><br>
6643   * </p>
6644   */
6645  public static final ca.uhn.fhir.rest.gclient.StringClientParam TITLE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_TITLE);
6646
6647 /**
6648   * Search parameter: <b>url</b>
6649   * <p>
6650   * Description: <b>Multiple Resources: 
6651
6652* [CapabilityStatement](capabilitystatement.html): The uri that identifies the capability statement
6653* [CodeSystem](codesystem.html): The uri that identifies the code system
6654* [CompartmentDefinition](compartmentdefinition.html): The uri that identifies the compartment definition
6655* [ConceptMap](conceptmap.html): The URI that identifies the concept map
6656* [GraphDefinition](graphdefinition.html): The uri that identifies the graph definition
6657* [ImplementationGuide](implementationguide.html): The uri that identifies the implementation guide
6658* [MessageDefinition](messagedefinition.html): The uri that identifies the message definition
6659* [NamingSystem](namingsystem.html): The uri that identifies the naming system
6660* [OperationDefinition](operationdefinition.html): The uri that identifies the operation definition
6661* [SearchParameter](searchparameter.html): The uri that identifies the search parameter
6662* [StructureDefinition](structuredefinition.html): The uri that identifies the structure definition
6663* [StructureMap](structuremap.html): The uri that identifies the structure map
6664* [TerminologyCapabilities](terminologycapabilities.html): The uri that identifies the terminology capabilities
6665* [ValueSet](valueset.html): The uri that identifies the value set
6666</b><br>
6667   * Type: <b>uri</b><br>
6668   * Path: <b>CapabilityStatement.url | CodeSystem.url | CompartmentDefinition.url | ConceptMap.url | GraphDefinition.url | ImplementationGuide.url | MessageDefinition.url | NamingSystem.url | OperationDefinition.url | SearchParameter.url | StructureDefinition.url | StructureMap.url | TerminologyCapabilities.url | ValueSet.url</b><br>
6669   * </p>
6670   */
6671  @SearchParamDefinition(name="url", path="CapabilityStatement.url | CodeSystem.url | CompartmentDefinition.url | ConceptMap.url | GraphDefinition.url | ImplementationGuide.url | MessageDefinition.url | NamingSystem.url | OperationDefinition.url | SearchParameter.url | StructureDefinition.url | StructureMap.url | TerminologyCapabilities.url | ValueSet.url", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): The uri that identifies the capability statement\r\n* [CodeSystem](codesystem.html): The uri that identifies the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): The uri that identifies the compartment definition\r\n* [ConceptMap](conceptmap.html): The URI that identifies the concept map\r\n* [GraphDefinition](graphdefinition.html): The uri that identifies the graph definition\r\n* [ImplementationGuide](implementationguide.html): The uri that identifies the implementation guide\r\n* [MessageDefinition](messagedefinition.html): The uri that identifies the message definition\r\n* [NamingSystem](namingsystem.html): The uri that identifies the naming system\r\n* [OperationDefinition](operationdefinition.html): The uri that identifies the operation definition\r\n* [SearchParameter](searchparameter.html): The uri that identifies the search parameter\r\n* [StructureDefinition](structuredefinition.html): The uri that identifies the structure definition\r\n* [StructureMap](structuremap.html): The uri that identifies the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): The uri that identifies the terminology capabilities\r\n* [ValueSet](valueset.html): The uri that identifies the value set\r\n", type="uri" )
6672  public static final String SP_URL = "url";
6673 /**
6674   * <b>Fluent Client</b> search parameter constant for <b>url</b>
6675   * <p>
6676   * Description: <b>Multiple Resources: 
6677
6678* [CapabilityStatement](capabilitystatement.html): The uri that identifies the capability statement
6679* [CodeSystem](codesystem.html): The uri that identifies the code system
6680* [CompartmentDefinition](compartmentdefinition.html): The uri that identifies the compartment definition
6681* [ConceptMap](conceptmap.html): The URI that identifies the concept map
6682* [GraphDefinition](graphdefinition.html): The uri that identifies the graph definition
6683* [ImplementationGuide](implementationguide.html): The uri that identifies the implementation guide
6684* [MessageDefinition](messagedefinition.html): The uri that identifies the message definition
6685* [NamingSystem](namingsystem.html): The uri that identifies the naming system
6686* [OperationDefinition](operationdefinition.html): The uri that identifies the operation definition
6687* [SearchParameter](searchparameter.html): The uri that identifies the search parameter
6688* [StructureDefinition](structuredefinition.html): The uri that identifies the structure definition
6689* [StructureMap](structuremap.html): The uri that identifies the structure map
6690* [TerminologyCapabilities](terminologycapabilities.html): The uri that identifies the terminology capabilities
6691* [ValueSet](valueset.html): The uri that identifies the value set
6692</b><br>
6693   * Type: <b>uri</b><br>
6694   * Path: <b>CapabilityStatement.url | CodeSystem.url | CompartmentDefinition.url | ConceptMap.url | GraphDefinition.url | ImplementationGuide.url | MessageDefinition.url | NamingSystem.url | OperationDefinition.url | SearchParameter.url | StructureDefinition.url | StructureMap.url | TerminologyCapabilities.url | ValueSet.url</b><br>
6695   * </p>
6696   */
6697  public static final ca.uhn.fhir.rest.gclient.UriClientParam URL = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_URL);
6698
6699 /**
6700   * Search parameter: <b>version</b>
6701   * <p>
6702   * Description: <b>Multiple Resources: 
6703
6704* [CapabilityStatement](capabilitystatement.html): The business version of the capability statement
6705* [CodeSystem](codesystem.html): The business version of the code system
6706* [CompartmentDefinition](compartmentdefinition.html): The business version of the compartment definition
6707* [ConceptMap](conceptmap.html): The business version of the concept map
6708* [GraphDefinition](graphdefinition.html): The business version of the graph definition
6709* [ImplementationGuide](implementationguide.html): The business version of the implementation guide
6710* [MessageDefinition](messagedefinition.html): The business version of the message definition
6711* [NamingSystem](namingsystem.html): The business version of the naming system
6712* [OperationDefinition](operationdefinition.html): The business version of the operation definition
6713* [SearchParameter](searchparameter.html): The business version of the search parameter
6714* [StructureDefinition](structuredefinition.html): The business version of the structure definition
6715* [StructureMap](structuremap.html): The business version of the structure map
6716* [TerminologyCapabilities](terminologycapabilities.html): The business version of the terminology capabilities
6717* [ValueSet](valueset.html): The business version of the value set
6718</b><br>
6719   * Type: <b>token</b><br>
6720   * Path: <b>CapabilityStatement.version | CodeSystem.version | CompartmentDefinition.version | ConceptMap.version | GraphDefinition.version | ImplementationGuide.version | MessageDefinition.version | NamingSystem.version | OperationDefinition.version | SearchParameter.version | StructureDefinition.version | StructureMap.version | TerminologyCapabilities.version | ValueSet.version</b><br>
6721   * </p>
6722   */
6723  @SearchParamDefinition(name="version", path="CapabilityStatement.version | CodeSystem.version | CompartmentDefinition.version | ConceptMap.version | GraphDefinition.version | ImplementationGuide.version | MessageDefinition.version | NamingSystem.version | OperationDefinition.version | SearchParameter.version | StructureDefinition.version | StructureMap.version | TerminologyCapabilities.version | ValueSet.version", description="Multiple Resources: \r\n\r\n* [CapabilityStatement](capabilitystatement.html): The business version of the capability statement\r\n* [CodeSystem](codesystem.html): The business version of the code system\r\n* [CompartmentDefinition](compartmentdefinition.html): The business version of the compartment definition\r\n* [ConceptMap](conceptmap.html): The business version of the concept map\r\n* [GraphDefinition](graphdefinition.html): The business version of the graph definition\r\n* [ImplementationGuide](implementationguide.html): The business version of the implementation guide\r\n* [MessageDefinition](messagedefinition.html): The business version of the message definition\r\n* [NamingSystem](namingsystem.html): The business version of the naming system\r\n* [OperationDefinition](operationdefinition.html): The business version of the operation definition\r\n* [SearchParameter](searchparameter.html): The business version of the search parameter\r\n* [StructureDefinition](structuredefinition.html): The business version of the structure definition\r\n* [StructureMap](structuremap.html): The business version of the structure map\r\n* [TerminologyCapabilities](terminologycapabilities.html): The business version of the terminology capabilities\r\n* [ValueSet](valueset.html): The business version of the value set\r\n", type="token" )
6724  public static final String SP_VERSION = "version";
6725 /**
6726   * <b>Fluent Client</b> search parameter constant for <b>version</b>
6727   * <p>
6728   * Description: <b>Multiple Resources: 
6729
6730* [CapabilityStatement](capabilitystatement.html): The business version of the capability statement
6731* [CodeSystem](codesystem.html): The business version of the code system
6732* [CompartmentDefinition](compartmentdefinition.html): The business version of the compartment definition
6733* [ConceptMap](conceptmap.html): The business version of the concept map
6734* [GraphDefinition](graphdefinition.html): The business version of the graph definition
6735* [ImplementationGuide](implementationguide.html): The business version of the implementation guide
6736* [MessageDefinition](messagedefinition.html): The business version of the message definition
6737* [NamingSystem](namingsystem.html): The business version of the naming system
6738* [OperationDefinition](operationdefinition.html): The business version of the operation definition
6739* [SearchParameter](searchparameter.html): The business version of the search parameter
6740* [StructureDefinition](structuredefinition.html): The business version of the structure definition
6741* [StructureMap](structuremap.html): The business version of the structure map
6742* [TerminologyCapabilities](terminologycapabilities.html): The business version of the terminology capabilities
6743* [ValueSet](valueset.html): The business version of the value set
6744</b><br>
6745   * Type: <b>token</b><br>
6746   * Path: <b>CapabilityStatement.version | CodeSystem.version | CompartmentDefinition.version | ConceptMap.version | GraphDefinition.version | ImplementationGuide.version | MessageDefinition.version | NamingSystem.version | OperationDefinition.version | SearchParameter.version | StructureDefinition.version | StructureMap.version | TerminologyCapabilities.version | ValueSet.version</b><br>
6747   * </p>
6748   */
6749  public static final ca.uhn.fhir.rest.gclient.TokenClientParam VERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_VERSION);
6750
6751
6752}
6753