001package org.hl7.fhir.r5.model;
002
003
004/*
005  Copyright (c) 2011+, HL7, Inc.
006  All rights reserved.
007  
008  Redistribution and use in source and binary forms, with or without modification, \
009  are permitted provided that the following conditions are met:
010  
011   * Redistributions of source code must retain the above copyright notice, this \
012     list of conditions and the following disclaimer.
013   * Redistributions in binary form must reproduce the above copyright notice, \
014     this list of conditions and the following disclaimer in the documentation \
015     and/or other materials provided with the distribution.
016   * Neither the name of HL7 nor the names of its contributors may be used to 
017     endorse or promote products derived from this software without specific 
018     prior written permission.
019  
020  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS \"AS IS\" AND \
021  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED \
022  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. \
023  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, \
024  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT \
025  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR \
026  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, \
027  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) \
028  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE \
029  POSSIBILITY OF SUCH DAMAGE.
030  */
031
032// Generated on Thu, Mar 23, 2023 19:59+1100 for FHIR v5.0.0
033
034import java.util.ArrayList;
035import java.util.Date;
036import java.util.List;
037import org.hl7.fhir.utilities.Utilities;
038import org.hl7.fhir.r5.model.Enumerations.*;
039import org.hl7.fhir.instance.model.api.IBaseBackboneElement;
040import org.hl7.fhir.exceptions.FHIRException;
041import org.hl7.fhir.instance.model.api.ICompositeType;
042import ca.uhn.fhir.model.api.annotation.ResourceDef;
043import ca.uhn.fhir.model.api.annotation.SearchParamDefinition;
044import org.hl7.fhir.instance.model.api.IBaseBackboneElement;
045import ca.uhn.fhir.model.api.annotation.Child;
046import ca.uhn.fhir.model.api.annotation.ChildOrder;
047import ca.uhn.fhir.model.api.annotation.Description;
048import ca.uhn.fhir.model.api.annotation.Block;
049
050/**
051 * A structured set of tests against a FHIR server or client implementation to determine compliance against the FHIR specification.
052 */
053@ResourceDef(name="TestScript", profile="http://hl7.org/fhir/StructureDefinition/TestScript")
054public class TestScript extends CanonicalResource {
055
056    public enum AssertionDirectionType {
057        /**
058         * The assertion is evaluated on the response. This is the default value.
059         */
060        RESPONSE, 
061        /**
062         * The assertion is evaluated on the request.
063         */
064        REQUEST, 
065        /**
066         * added to help the parsers with the generic types
067         */
068        NULL;
069        public static AssertionDirectionType fromCode(String codeString) throws FHIRException {
070            if (codeString == null || "".equals(codeString))
071                return null;
072        if ("response".equals(codeString))
073          return RESPONSE;
074        if ("request".equals(codeString))
075          return REQUEST;
076        if (Configuration.isAcceptInvalidEnums())
077          return null;
078        else
079          throw new FHIRException("Unknown AssertionDirectionType code '"+codeString+"'");
080        }
081        public String toCode() {
082          switch (this) {
083            case RESPONSE: return "response";
084            case REQUEST: return "request";
085            case NULL: return null;
086            default: return "?";
087          }
088        }
089        public String getSystem() {
090          switch (this) {
091            case RESPONSE: return "http://hl7.org/fhir/assert-direction-codes";
092            case REQUEST: return "http://hl7.org/fhir/assert-direction-codes";
093            case NULL: return null;
094            default: return "?";
095          }
096        }
097        public String getDefinition() {
098          switch (this) {
099            case RESPONSE: return "The assertion is evaluated on the response. This is the default value.";
100            case REQUEST: return "The assertion is evaluated on the request.";
101            case NULL: return null;
102            default: return "?";
103          }
104        }
105        public String getDisplay() {
106          switch (this) {
107            case RESPONSE: return "response";
108            case REQUEST: return "request";
109            case NULL: return null;
110            default: return "?";
111          }
112        }
113    }
114
115  public static class AssertionDirectionTypeEnumFactory implements EnumFactory<AssertionDirectionType> {
116    public AssertionDirectionType fromCode(String codeString) throws IllegalArgumentException {
117      if (codeString == null || "".equals(codeString))
118            if (codeString == null || "".equals(codeString))
119                return null;
120        if ("response".equals(codeString))
121          return AssertionDirectionType.RESPONSE;
122        if ("request".equals(codeString))
123          return AssertionDirectionType.REQUEST;
124        throw new IllegalArgumentException("Unknown AssertionDirectionType code '"+codeString+"'");
125        }
126        public Enumeration<AssertionDirectionType> fromType(PrimitiveType<?> code) throws FHIRException {
127          if (code == null)
128            return null;
129          if (code.isEmpty())
130            return new Enumeration<AssertionDirectionType>(this, AssertionDirectionType.NULL, code);
131          String codeString = ((PrimitiveType) code).asStringValue();
132          if (codeString == null || "".equals(codeString))
133            return new Enumeration<AssertionDirectionType>(this, AssertionDirectionType.NULL, code);
134        if ("response".equals(codeString))
135          return new Enumeration<AssertionDirectionType>(this, AssertionDirectionType.RESPONSE, code);
136        if ("request".equals(codeString))
137          return new Enumeration<AssertionDirectionType>(this, AssertionDirectionType.REQUEST, code);
138        throw new FHIRException("Unknown AssertionDirectionType code '"+codeString+"'");
139        }
140    public String toCode(AssertionDirectionType code) {
141      if (code == AssertionDirectionType.RESPONSE)
142        return "response";
143      if (code == AssertionDirectionType.REQUEST)
144        return "request";
145      return "?";
146      }
147    public String toSystem(AssertionDirectionType code) {
148      return code.getSystem();
149      }
150    }
151
152    public enum AssertionManualCompletionType {
153        /**
154         * Mark the currently waiting test failed and proceed with the next assert if the stopTestOnFail is false or the next test in the TestScript if the stopTestOnFail is true.
155         */
156        FAIL, 
157        /**
158         * Mark the currently waiting test passed (if the test is not failed already) and proceed with the next action in the TestScript.
159         */
160        PASS, 
161        /**
162         * Mark this assert as skipped and proceed with the next action in the TestScript.
163         */
164        SKIP, 
165        /**
166         * Stop execution of this TestScript. The overall status of this TestScript is evaluated based on the status of the completed tests.
167         */
168        STOP, 
169        /**
170         * added to help the parsers with the generic types
171         */
172        NULL;
173        public static AssertionManualCompletionType fromCode(String codeString) throws FHIRException {
174            if (codeString == null || "".equals(codeString))
175                return null;
176        if ("fail".equals(codeString))
177          return FAIL;
178        if ("pass".equals(codeString))
179          return PASS;
180        if ("skip".equals(codeString))
181          return SKIP;
182        if ("stop".equals(codeString))
183          return STOP;
184        if (Configuration.isAcceptInvalidEnums())
185          return null;
186        else
187          throw new FHIRException("Unknown AssertionManualCompletionType code '"+codeString+"'");
188        }
189        public String toCode() {
190          switch (this) {
191            case FAIL: return "fail";
192            case PASS: return "pass";
193            case SKIP: return "skip";
194            case STOP: return "stop";
195            case NULL: return null;
196            default: return "?";
197          }
198        }
199        public String getSystem() {
200          switch (this) {
201            case FAIL: return "http://hl7.org/fhir/assert-manual-completion-codes";
202            case PASS: return "http://hl7.org/fhir/assert-manual-completion-codes";
203            case SKIP: return "http://hl7.org/fhir/assert-manual-completion-codes";
204            case STOP: return "http://hl7.org/fhir/assert-manual-completion-codes";
205            case NULL: return null;
206            default: return "?";
207          }
208        }
209        public String getDefinition() {
210          switch (this) {
211            case FAIL: return "Mark the currently waiting test failed and proceed with the next assert if the stopTestOnFail is false or the next test in the TestScript if the stopTestOnFail is true.";
212            case PASS: return "Mark the currently waiting test passed (if the test is not failed already) and proceed with the next action in the TestScript.";
213            case SKIP: return "Mark this assert as skipped and proceed with the next action in the TestScript.";
214            case STOP: return "Stop execution of this TestScript. The overall status of this TestScript is evaluated based on the status of the completed tests.";
215            case NULL: return null;
216            default: return "?";
217          }
218        }
219        public String getDisplay() {
220          switch (this) {
221            case FAIL: return "Fail";
222            case PASS: return "Pass";
223            case SKIP: return "Skip";
224            case STOP: return "Stop";
225            case NULL: return null;
226            default: return "?";
227          }
228        }
229    }
230
231  public static class AssertionManualCompletionTypeEnumFactory implements EnumFactory<AssertionManualCompletionType> {
232    public AssertionManualCompletionType fromCode(String codeString) throws IllegalArgumentException {
233      if (codeString == null || "".equals(codeString))
234            if (codeString == null || "".equals(codeString))
235                return null;
236        if ("fail".equals(codeString))
237          return AssertionManualCompletionType.FAIL;
238        if ("pass".equals(codeString))
239          return AssertionManualCompletionType.PASS;
240        if ("skip".equals(codeString))
241          return AssertionManualCompletionType.SKIP;
242        if ("stop".equals(codeString))
243          return AssertionManualCompletionType.STOP;
244        throw new IllegalArgumentException("Unknown AssertionManualCompletionType code '"+codeString+"'");
245        }
246        public Enumeration<AssertionManualCompletionType> fromType(PrimitiveType<?> code) throws FHIRException {
247          if (code == null)
248            return null;
249          if (code.isEmpty())
250            return new Enumeration<AssertionManualCompletionType>(this, AssertionManualCompletionType.NULL, code);
251          String codeString = ((PrimitiveType) code).asStringValue();
252          if (codeString == null || "".equals(codeString))
253            return new Enumeration<AssertionManualCompletionType>(this, AssertionManualCompletionType.NULL, code);
254        if ("fail".equals(codeString))
255          return new Enumeration<AssertionManualCompletionType>(this, AssertionManualCompletionType.FAIL, code);
256        if ("pass".equals(codeString))
257          return new Enumeration<AssertionManualCompletionType>(this, AssertionManualCompletionType.PASS, code);
258        if ("skip".equals(codeString))
259          return new Enumeration<AssertionManualCompletionType>(this, AssertionManualCompletionType.SKIP, code);
260        if ("stop".equals(codeString))
261          return new Enumeration<AssertionManualCompletionType>(this, AssertionManualCompletionType.STOP, code);
262        throw new FHIRException("Unknown AssertionManualCompletionType code '"+codeString+"'");
263        }
264    public String toCode(AssertionManualCompletionType code) {
265      if (code == AssertionManualCompletionType.FAIL)
266        return "fail";
267      if (code == AssertionManualCompletionType.PASS)
268        return "pass";
269      if (code == AssertionManualCompletionType.SKIP)
270        return "skip";
271      if (code == AssertionManualCompletionType.STOP)
272        return "stop";
273      return "?";
274      }
275    public String toSystem(AssertionManualCompletionType code) {
276      return code.getSystem();
277      }
278    }
279
280    public enum AssertionOperatorType {
281        /**
282         * Default value. Equals comparison.
283         */
284        EQUALS, 
285        /**
286         * Not equals comparison.
287         */
288        NOTEQUALS, 
289        /**
290         * Compare value within a known set of values.
291         */
292        IN, 
293        /**
294         * Compare value not within a known set of values.
295         */
296        NOTIN, 
297        /**
298         * Compare value to be greater than a known value.
299         */
300        GREATERTHAN, 
301        /**
302         * Compare value to be less than a known value.
303         */
304        LESSTHAN, 
305        /**
306         * Compare value is empty.
307         */
308        EMPTY, 
309        /**
310         * Compare value is not empty.
311         */
312        NOTEMPTY, 
313        /**
314         * Compare value string contains a known value.
315         */
316        CONTAINS, 
317        /**
318         * Compare value string does not contain a known value.
319         */
320        NOTCONTAINS, 
321        /**
322         * Evaluate the FHIRPath expression as a boolean condition.
323         */
324        EVAL, 
325        /**
326         * Manually evaluate the condition described by this assert. The test engine SHALL pause and provide an input mechanism to set the outcome of this assert to 'pass', 'fail', 'skip' or 'stop'.
327         */
328        MANUALEVAL, 
329        /**
330         * added to help the parsers with the generic types
331         */
332        NULL;
333        public static AssertionOperatorType fromCode(String codeString) throws FHIRException {
334            if (codeString == null || "".equals(codeString))
335                return null;
336        if ("equals".equals(codeString))
337          return EQUALS;
338        if ("notEquals".equals(codeString))
339          return NOTEQUALS;
340        if ("in".equals(codeString))
341          return IN;
342        if ("notIn".equals(codeString))
343          return NOTIN;
344        if ("greaterThan".equals(codeString))
345          return GREATERTHAN;
346        if ("lessThan".equals(codeString))
347          return LESSTHAN;
348        if ("empty".equals(codeString))
349          return EMPTY;
350        if ("notEmpty".equals(codeString))
351          return NOTEMPTY;
352        if ("contains".equals(codeString))
353          return CONTAINS;
354        if ("notContains".equals(codeString))
355          return NOTCONTAINS;
356        if ("eval".equals(codeString))
357          return EVAL;
358        if ("manualEval".equals(codeString))
359          return MANUALEVAL;
360        if (Configuration.isAcceptInvalidEnums())
361          return null;
362        else
363          throw new FHIRException("Unknown AssertionOperatorType code '"+codeString+"'");
364        }
365        public String toCode() {
366          switch (this) {
367            case EQUALS: return "equals";
368            case NOTEQUALS: return "notEquals";
369            case IN: return "in";
370            case NOTIN: return "notIn";
371            case GREATERTHAN: return "greaterThan";
372            case LESSTHAN: return "lessThan";
373            case EMPTY: return "empty";
374            case NOTEMPTY: return "notEmpty";
375            case CONTAINS: return "contains";
376            case NOTCONTAINS: return "notContains";
377            case EVAL: return "eval";
378            case MANUALEVAL: return "manualEval";
379            case NULL: return null;
380            default: return "?";
381          }
382        }
383        public String getSystem() {
384          switch (this) {
385            case EQUALS: return "http://hl7.org/fhir/assert-operator-codes";
386            case NOTEQUALS: return "http://hl7.org/fhir/assert-operator-codes";
387            case IN: return "http://hl7.org/fhir/assert-operator-codes";
388            case NOTIN: return "http://hl7.org/fhir/assert-operator-codes";
389            case GREATERTHAN: return "http://hl7.org/fhir/assert-operator-codes";
390            case LESSTHAN: return "http://hl7.org/fhir/assert-operator-codes";
391            case EMPTY: return "http://hl7.org/fhir/assert-operator-codes";
392            case NOTEMPTY: return "http://hl7.org/fhir/assert-operator-codes";
393            case CONTAINS: return "http://hl7.org/fhir/assert-operator-codes";
394            case NOTCONTAINS: return "http://hl7.org/fhir/assert-operator-codes";
395            case EVAL: return "http://hl7.org/fhir/assert-operator-codes";
396            case MANUALEVAL: return "http://hl7.org/fhir/assert-operator-codes";
397            case NULL: return null;
398            default: return "?";
399          }
400        }
401        public String getDefinition() {
402          switch (this) {
403            case EQUALS: return "Default value. Equals comparison.";
404            case NOTEQUALS: return "Not equals comparison.";
405            case IN: return "Compare value within a known set of values.";
406            case NOTIN: return "Compare value not within a known set of values.";
407            case GREATERTHAN: return "Compare value to be greater than a known value.";
408            case LESSTHAN: return "Compare value to be less than a known value.";
409            case EMPTY: return "Compare value is empty.";
410            case NOTEMPTY: return "Compare value is not empty.";
411            case CONTAINS: return "Compare value string contains a known value.";
412            case NOTCONTAINS: return "Compare value string does not contain a known value.";
413            case EVAL: return "Evaluate the FHIRPath expression as a boolean condition.";
414            case MANUALEVAL: return "Manually evaluate the condition described by this assert. The test engine SHALL pause and provide an input mechanism to set the outcome of this assert to 'pass', 'fail', 'skip' or 'stop'.";
415            case NULL: return null;
416            default: return "?";
417          }
418        }
419        public String getDisplay() {
420          switch (this) {
421            case EQUALS: return "equals";
422            case NOTEQUALS: return "notEquals";
423            case IN: return "in";
424            case NOTIN: return "notIn";
425            case GREATERTHAN: return "greaterThan";
426            case LESSTHAN: return "lessThan";
427            case EMPTY: return "empty";
428            case NOTEMPTY: return "notEmpty";
429            case CONTAINS: return "contains";
430            case NOTCONTAINS: return "notContains";
431            case EVAL: return "evaluate";
432            case MANUALEVAL: return "manualEvaluate";
433            case NULL: return null;
434            default: return "?";
435          }
436        }
437    }
438
439  public static class AssertionOperatorTypeEnumFactory implements EnumFactory<AssertionOperatorType> {
440    public AssertionOperatorType fromCode(String codeString) throws IllegalArgumentException {
441      if (codeString == null || "".equals(codeString))
442            if (codeString == null || "".equals(codeString))
443                return null;
444        if ("equals".equals(codeString))
445          return AssertionOperatorType.EQUALS;
446        if ("notEquals".equals(codeString))
447          return AssertionOperatorType.NOTEQUALS;
448        if ("in".equals(codeString))
449          return AssertionOperatorType.IN;
450        if ("notIn".equals(codeString))
451          return AssertionOperatorType.NOTIN;
452        if ("greaterThan".equals(codeString))
453          return AssertionOperatorType.GREATERTHAN;
454        if ("lessThan".equals(codeString))
455          return AssertionOperatorType.LESSTHAN;
456        if ("empty".equals(codeString))
457          return AssertionOperatorType.EMPTY;
458        if ("notEmpty".equals(codeString))
459          return AssertionOperatorType.NOTEMPTY;
460        if ("contains".equals(codeString))
461          return AssertionOperatorType.CONTAINS;
462        if ("notContains".equals(codeString))
463          return AssertionOperatorType.NOTCONTAINS;
464        if ("eval".equals(codeString))
465          return AssertionOperatorType.EVAL;
466        if ("manualEval".equals(codeString))
467          return AssertionOperatorType.MANUALEVAL;
468        throw new IllegalArgumentException("Unknown AssertionOperatorType code '"+codeString+"'");
469        }
470        public Enumeration<AssertionOperatorType> fromType(PrimitiveType<?> code) throws FHIRException {
471          if (code == null)
472            return null;
473          if (code.isEmpty())
474            return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.NULL, code);
475          String codeString = ((PrimitiveType) code).asStringValue();
476          if (codeString == null || "".equals(codeString))
477            return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.NULL, code);
478        if ("equals".equals(codeString))
479          return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.EQUALS, code);
480        if ("notEquals".equals(codeString))
481          return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.NOTEQUALS, code);
482        if ("in".equals(codeString))
483          return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.IN, code);
484        if ("notIn".equals(codeString))
485          return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.NOTIN, code);
486        if ("greaterThan".equals(codeString))
487          return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.GREATERTHAN, code);
488        if ("lessThan".equals(codeString))
489          return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.LESSTHAN, code);
490        if ("empty".equals(codeString))
491          return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.EMPTY, code);
492        if ("notEmpty".equals(codeString))
493          return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.NOTEMPTY, code);
494        if ("contains".equals(codeString))
495          return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.CONTAINS, code);
496        if ("notContains".equals(codeString))
497          return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.NOTCONTAINS, code);
498        if ("eval".equals(codeString))
499          return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.EVAL, code);
500        if ("manualEval".equals(codeString))
501          return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.MANUALEVAL, code);
502        throw new FHIRException("Unknown AssertionOperatorType code '"+codeString+"'");
503        }
504    public String toCode(AssertionOperatorType code) {
505      if (code == AssertionOperatorType.EQUALS)
506        return "equals";
507      if (code == AssertionOperatorType.NOTEQUALS)
508        return "notEquals";
509      if (code == AssertionOperatorType.IN)
510        return "in";
511      if (code == AssertionOperatorType.NOTIN)
512        return "notIn";
513      if (code == AssertionOperatorType.GREATERTHAN)
514        return "greaterThan";
515      if (code == AssertionOperatorType.LESSTHAN)
516        return "lessThan";
517      if (code == AssertionOperatorType.EMPTY)
518        return "empty";
519      if (code == AssertionOperatorType.NOTEMPTY)
520        return "notEmpty";
521      if (code == AssertionOperatorType.CONTAINS)
522        return "contains";
523      if (code == AssertionOperatorType.NOTCONTAINS)
524        return "notContains";
525      if (code == AssertionOperatorType.EVAL)
526        return "eval";
527      if (code == AssertionOperatorType.MANUALEVAL)
528        return "manualEval";
529      return "?";
530      }
531    public String toSystem(AssertionOperatorType code) {
532      return code.getSystem();
533      }
534    }
535
536    public enum AssertionResponseTypes {
537        /**
538         * Response code is 100.
539         */
540        CONTINUE, 
541        /**
542         * Response code is 101.
543         */
544        SWITCHINGPROTOCOLS, 
545        /**
546         * Response code is 200.
547         */
548        OKAY, 
549        /**
550         * Response code is 201.
551         */
552        CREATED, 
553        /**
554         * Response code is 202.
555         */
556        ACCEPTED, 
557        /**
558         * Response code is 203.
559         */
560        NONAUTHORITATIVEINFORMATION, 
561        /**
562         * Response code is 204.
563         */
564        NOCONTENT, 
565        /**
566         * Response code is 205.
567         */
568        RESETCONTENT, 
569        /**
570         * Response code is 206.
571         */
572        PARTIALCONTENT, 
573        /**
574         * Response code is 300.
575         */
576        MULTIPLECHOICES, 
577        /**
578         * Response code is 301.
579         */
580        MOVEDPERMANENTLY, 
581        /**
582         * Response code is 302.
583         */
584        FOUND, 
585        /**
586         * Response code is 303.
587         */
588        SEEOTHER, 
589        /**
590         * Response code is 304.
591         */
592        NOTMODIFIED, 
593        /**
594         * Response code is 305.
595         */
596        USEPROXY, 
597        /**
598         * Response code is 307.
599         */
600        TEMPORARYREDIRECT, 
601        /**
602         * Response code is 308.
603         */
604        PERMANENTREDIRECT, 
605        /**
606         * Response code is 400.
607         */
608        BADREQUEST, 
609        /**
610         * Response code is 401.
611         */
612        UNAUTHORIZED, 
613        /**
614         * Response code is 402.
615         */
616        PAYMENTREQUIRED, 
617        /**
618         * Response code is 403.
619         */
620        FORBIDDEN, 
621        /**
622         * Response code is 404.
623         */
624        NOTFOUND, 
625        /**
626         * Response code is 405.
627         */
628        METHODNOTALLOWED, 
629        /**
630         * Response code is 406.
631         */
632        NOTACCEPTABLE, 
633        /**
634         * Response code is 407.
635         */
636        PROXYAUTHENTICATIONREQUIRED, 
637        /**
638         * Response code is 408.
639         */
640        REQUESTTIMEOUT, 
641        /**
642         * Response code is 409.
643         */
644        CONFLICT, 
645        /**
646         * Response code is 410.
647         */
648        GONE, 
649        /**
650         * Response code is 411.
651         */
652        LENGTHREQUIRED, 
653        /**
654         * Response code is 412.
655         */
656        PRECONDITIONFAILED, 
657        /**
658         * Response code is 413.
659         */
660        CONTENTTOOLARGE, 
661        /**
662         * Response code is 414.
663         */
664        URITOOLONG, 
665        /**
666         * Response code is 415.
667         */
668        UNSUPPORTEDMEDIATYPE, 
669        /**
670         * Response code is 416.
671         */
672        RANGENOTSATISFIABLE, 
673        /**
674         * Response code is 417.
675         */
676        EXPECTATIONFAILED, 
677        /**
678         * Response code is 421.
679         */
680        MISDIRECTEDREQUEST, 
681        /**
682         * Response code is 422.
683         */
684        UNPROCESSABLECONTENT, 
685        /**
686         * Response code is 426.
687         */
688        UPGRADEREQUIRED, 
689        /**
690         * Response code is 500.
691         */
692        INTERNALSERVERERROR, 
693        /**
694         * Response code is 501.
695         */
696        NOTIMPLEMENTED, 
697        /**
698         * Response code is 502.
699         */
700        BADGATEWAY, 
701        /**
702         * Response code is 503.
703         */
704        SERVICEUNAVAILABLE, 
705        /**
706         * Response code is 504.
707         */
708        GATEWAYTIMEOUT, 
709        /**
710         * Response code is 505.
711         */
712        HTTPVERSIONNOTSUPPORTED, 
713        /**
714         * added to help the parsers with the generic types
715         */
716        NULL;
717        public static AssertionResponseTypes fromCode(String codeString) throws FHIRException {
718            if (codeString == null || "".equals(codeString))
719                return null;
720        if ("continue".equals(codeString))
721          return CONTINUE;
722        if ("switchingProtocols".equals(codeString))
723          return SWITCHINGPROTOCOLS;
724        if ("okay".equals(codeString))
725          return OKAY;
726        if ("created".equals(codeString))
727          return CREATED;
728        if ("accepted".equals(codeString))
729          return ACCEPTED;
730        if ("nonAuthoritativeInformation".equals(codeString))
731          return NONAUTHORITATIVEINFORMATION;
732        if ("noContent".equals(codeString))
733          return NOCONTENT;
734        if ("resetContent".equals(codeString))
735          return RESETCONTENT;
736        if ("partialContent".equals(codeString))
737          return PARTIALCONTENT;
738        if ("multipleChoices".equals(codeString))
739          return MULTIPLECHOICES;
740        if ("movedPermanently".equals(codeString))
741          return MOVEDPERMANENTLY;
742        if ("found".equals(codeString))
743          return FOUND;
744        if ("seeOther".equals(codeString))
745          return SEEOTHER;
746        if ("notModified".equals(codeString))
747          return NOTMODIFIED;
748        if ("useProxy".equals(codeString))
749          return USEPROXY;
750        if ("temporaryRedirect".equals(codeString))
751          return TEMPORARYREDIRECT;
752        if ("permanentRedirect".equals(codeString))
753          return PERMANENTREDIRECT;
754        if ("badRequest".equals(codeString))
755          return BADREQUEST;
756        if ("unauthorized".equals(codeString))
757          return UNAUTHORIZED;
758        if ("paymentRequired".equals(codeString))
759          return PAYMENTREQUIRED;
760        if ("forbidden".equals(codeString))
761          return FORBIDDEN;
762        if ("notFound".equals(codeString))
763          return NOTFOUND;
764        if ("methodNotAllowed".equals(codeString))
765          return METHODNOTALLOWED;
766        if ("notAcceptable".equals(codeString))
767          return NOTACCEPTABLE;
768        if ("proxyAuthenticationRequired".equals(codeString))
769          return PROXYAUTHENTICATIONREQUIRED;
770        if ("requestTimeout".equals(codeString))
771          return REQUESTTIMEOUT;
772        if ("conflict".equals(codeString))
773          return CONFLICT;
774        if ("gone".equals(codeString))
775          return GONE;
776        if ("lengthRequired".equals(codeString))
777          return LENGTHREQUIRED;
778        if ("preconditionFailed".equals(codeString))
779          return PRECONDITIONFAILED;
780        if ("contentTooLarge".equals(codeString))
781          return CONTENTTOOLARGE;
782        if ("uriTooLong".equals(codeString))
783          return URITOOLONG;
784        if ("unsupportedMediaType".equals(codeString))
785          return UNSUPPORTEDMEDIATYPE;
786        if ("rangeNotSatisfiable".equals(codeString))
787          return RANGENOTSATISFIABLE;
788        if ("expectationFailed".equals(codeString))
789          return EXPECTATIONFAILED;
790        if ("misdirectedRequest".equals(codeString))
791          return MISDIRECTEDREQUEST;
792        if ("unprocessableContent".equals(codeString))
793          return UNPROCESSABLECONTENT;
794        if ("upgradeRequired".equals(codeString))
795          return UPGRADEREQUIRED;
796        if ("internalServerError".equals(codeString))
797          return INTERNALSERVERERROR;
798        if ("notImplemented".equals(codeString))
799          return NOTIMPLEMENTED;
800        if ("badGateway".equals(codeString))
801          return BADGATEWAY;
802        if ("serviceUnavailable".equals(codeString))
803          return SERVICEUNAVAILABLE;
804        if ("gatewayTimeout".equals(codeString))
805          return GATEWAYTIMEOUT;
806        if ("httpVersionNotSupported".equals(codeString))
807          return HTTPVERSIONNOTSUPPORTED;
808        if (Configuration.isAcceptInvalidEnums())
809          return null;
810        else
811          throw new FHIRException("Unknown AssertionResponseTypes code '"+codeString+"'");
812        }
813        public String toCode() {
814          switch (this) {
815            case CONTINUE: return "continue";
816            case SWITCHINGPROTOCOLS: return "switchingProtocols";
817            case OKAY: return "okay";
818            case CREATED: return "created";
819            case ACCEPTED: return "accepted";
820            case NONAUTHORITATIVEINFORMATION: return "nonAuthoritativeInformation";
821            case NOCONTENT: return "noContent";
822            case RESETCONTENT: return "resetContent";
823            case PARTIALCONTENT: return "partialContent";
824            case MULTIPLECHOICES: return "multipleChoices";
825            case MOVEDPERMANENTLY: return "movedPermanently";
826            case FOUND: return "found";
827            case SEEOTHER: return "seeOther";
828            case NOTMODIFIED: return "notModified";
829            case USEPROXY: return "useProxy";
830            case TEMPORARYREDIRECT: return "temporaryRedirect";
831            case PERMANENTREDIRECT: return "permanentRedirect";
832            case BADREQUEST: return "badRequest";
833            case UNAUTHORIZED: return "unauthorized";
834            case PAYMENTREQUIRED: return "paymentRequired";
835            case FORBIDDEN: return "forbidden";
836            case NOTFOUND: return "notFound";
837            case METHODNOTALLOWED: return "methodNotAllowed";
838            case NOTACCEPTABLE: return "notAcceptable";
839            case PROXYAUTHENTICATIONREQUIRED: return "proxyAuthenticationRequired";
840            case REQUESTTIMEOUT: return "requestTimeout";
841            case CONFLICT: return "conflict";
842            case GONE: return "gone";
843            case LENGTHREQUIRED: return "lengthRequired";
844            case PRECONDITIONFAILED: return "preconditionFailed";
845            case CONTENTTOOLARGE: return "contentTooLarge";
846            case URITOOLONG: return "uriTooLong";
847            case UNSUPPORTEDMEDIATYPE: return "unsupportedMediaType";
848            case RANGENOTSATISFIABLE: return "rangeNotSatisfiable";
849            case EXPECTATIONFAILED: return "expectationFailed";
850            case MISDIRECTEDREQUEST: return "misdirectedRequest";
851            case UNPROCESSABLECONTENT: return "unprocessableContent";
852            case UPGRADEREQUIRED: return "upgradeRequired";
853            case INTERNALSERVERERROR: return "internalServerError";
854            case NOTIMPLEMENTED: return "notImplemented";
855            case BADGATEWAY: return "badGateway";
856            case SERVICEUNAVAILABLE: return "serviceUnavailable";
857            case GATEWAYTIMEOUT: return "gatewayTimeout";
858            case HTTPVERSIONNOTSUPPORTED: return "httpVersionNotSupported";
859            case NULL: return null;
860            default: return "?";
861          }
862        }
863        public String getSystem() {
864          switch (this) {
865            case CONTINUE: return "http://hl7.org/fhir/assert-response-code-types";
866            case SWITCHINGPROTOCOLS: return "http://hl7.org/fhir/assert-response-code-types";
867            case OKAY: return "http://hl7.org/fhir/assert-response-code-types";
868            case CREATED: return "http://hl7.org/fhir/assert-response-code-types";
869            case ACCEPTED: return "http://hl7.org/fhir/assert-response-code-types";
870            case NONAUTHORITATIVEINFORMATION: return "http://hl7.org/fhir/assert-response-code-types";
871            case NOCONTENT: return "http://hl7.org/fhir/assert-response-code-types";
872            case RESETCONTENT: return "http://hl7.org/fhir/assert-response-code-types";
873            case PARTIALCONTENT: return "http://hl7.org/fhir/assert-response-code-types";
874            case MULTIPLECHOICES: return "http://hl7.org/fhir/assert-response-code-types";
875            case MOVEDPERMANENTLY: return "http://hl7.org/fhir/assert-response-code-types";
876            case FOUND: return "http://hl7.org/fhir/assert-response-code-types";
877            case SEEOTHER: return "http://hl7.org/fhir/assert-response-code-types";
878            case NOTMODIFIED: return "http://hl7.org/fhir/assert-response-code-types";
879            case USEPROXY: return "http://hl7.org/fhir/assert-response-code-types";
880            case TEMPORARYREDIRECT: return "http://hl7.org/fhir/assert-response-code-types";
881            case PERMANENTREDIRECT: return "http://hl7.org/fhir/assert-response-code-types";
882            case BADREQUEST: return "http://hl7.org/fhir/assert-response-code-types";
883            case UNAUTHORIZED: return "http://hl7.org/fhir/assert-response-code-types";
884            case PAYMENTREQUIRED: return "http://hl7.org/fhir/assert-response-code-types";
885            case FORBIDDEN: return "http://hl7.org/fhir/assert-response-code-types";
886            case NOTFOUND: return "http://hl7.org/fhir/assert-response-code-types";
887            case METHODNOTALLOWED: return "http://hl7.org/fhir/assert-response-code-types";
888            case NOTACCEPTABLE: return "http://hl7.org/fhir/assert-response-code-types";
889            case PROXYAUTHENTICATIONREQUIRED: return "http://hl7.org/fhir/assert-response-code-types";
890            case REQUESTTIMEOUT: return "http://hl7.org/fhir/assert-response-code-types";
891            case CONFLICT: return "http://hl7.org/fhir/assert-response-code-types";
892            case GONE: return "http://hl7.org/fhir/assert-response-code-types";
893            case LENGTHREQUIRED: return "http://hl7.org/fhir/assert-response-code-types";
894            case PRECONDITIONFAILED: return "http://hl7.org/fhir/assert-response-code-types";
895            case CONTENTTOOLARGE: return "http://hl7.org/fhir/assert-response-code-types";
896            case URITOOLONG: return "http://hl7.org/fhir/assert-response-code-types";
897            case UNSUPPORTEDMEDIATYPE: return "http://hl7.org/fhir/assert-response-code-types";
898            case RANGENOTSATISFIABLE: return "http://hl7.org/fhir/assert-response-code-types";
899            case EXPECTATIONFAILED: return "http://hl7.org/fhir/assert-response-code-types";
900            case MISDIRECTEDREQUEST: return "http://hl7.org/fhir/assert-response-code-types";
901            case UNPROCESSABLECONTENT: return "http://hl7.org/fhir/assert-response-code-types";
902            case UPGRADEREQUIRED: return "http://hl7.org/fhir/assert-response-code-types";
903            case INTERNALSERVERERROR: return "http://hl7.org/fhir/assert-response-code-types";
904            case NOTIMPLEMENTED: return "http://hl7.org/fhir/assert-response-code-types";
905            case BADGATEWAY: return "http://hl7.org/fhir/assert-response-code-types";
906            case SERVICEUNAVAILABLE: return "http://hl7.org/fhir/assert-response-code-types";
907            case GATEWAYTIMEOUT: return "http://hl7.org/fhir/assert-response-code-types";
908            case HTTPVERSIONNOTSUPPORTED: return "http://hl7.org/fhir/assert-response-code-types";
909            case NULL: return null;
910            default: return "?";
911          }
912        }
913        public String getDefinition() {
914          switch (this) {
915            case CONTINUE: return "Response code is 100.";
916            case SWITCHINGPROTOCOLS: return "Response code is 101.";
917            case OKAY: return "Response code is 200.";
918            case CREATED: return "Response code is 201.";
919            case ACCEPTED: return "Response code is 202.";
920            case NONAUTHORITATIVEINFORMATION: return "Response code is 203.";
921            case NOCONTENT: return "Response code is 204.";
922            case RESETCONTENT: return "Response code is 205.";
923            case PARTIALCONTENT: return "Response code is 206.";
924            case MULTIPLECHOICES: return "Response code is 300.";
925            case MOVEDPERMANENTLY: return "Response code is 301.";
926            case FOUND: return "Response code is 302.";
927            case SEEOTHER: return "Response code is 303.";
928            case NOTMODIFIED: return "Response code is 304.";
929            case USEPROXY: return "Response code is 305.";
930            case TEMPORARYREDIRECT: return "Response code is 307.";
931            case PERMANENTREDIRECT: return "Response code is 308.";
932            case BADREQUEST: return "Response code is 400.";
933            case UNAUTHORIZED: return "Response code is 401.";
934            case PAYMENTREQUIRED: return "Response code is 402.";
935            case FORBIDDEN: return "Response code is 403.";
936            case NOTFOUND: return "Response code is 404.";
937            case METHODNOTALLOWED: return "Response code is 405.";
938            case NOTACCEPTABLE: return "Response code is 406.";
939            case PROXYAUTHENTICATIONREQUIRED: return "Response code is 407.";
940            case REQUESTTIMEOUT: return "Response code is 408.";
941            case CONFLICT: return "Response code is 409.";
942            case GONE: return "Response code is 410.";
943            case LENGTHREQUIRED: return "Response code is 411.";
944            case PRECONDITIONFAILED: return "Response code is 412.";
945            case CONTENTTOOLARGE: return "Response code is 413.";
946            case URITOOLONG: return "Response code is 414.";
947            case UNSUPPORTEDMEDIATYPE: return "Response code is 415.";
948            case RANGENOTSATISFIABLE: return "Response code is 416.";
949            case EXPECTATIONFAILED: return "Response code is 417.";
950            case MISDIRECTEDREQUEST: return "Response code is 421.";
951            case UNPROCESSABLECONTENT: return "Response code is 422.";
952            case UPGRADEREQUIRED: return "Response code is 426.";
953            case INTERNALSERVERERROR: return "Response code is 500.";
954            case NOTIMPLEMENTED: return "Response code is 501.";
955            case BADGATEWAY: return "Response code is 502.";
956            case SERVICEUNAVAILABLE: return "Response code is 503.";
957            case GATEWAYTIMEOUT: return "Response code is 504.";
958            case HTTPVERSIONNOTSUPPORTED: return "Response code is 505.";
959            case NULL: return null;
960            default: return "?";
961          }
962        }
963        public String getDisplay() {
964          switch (this) {
965            case CONTINUE: return "Continue";
966            case SWITCHINGPROTOCOLS: return "Switching Protocols";
967            case OKAY: return "OK";
968            case CREATED: return "Created";
969            case ACCEPTED: return "Accepted";
970            case NONAUTHORITATIVEINFORMATION: return "Non-Authoritative Information";
971            case NOCONTENT: return "No Content";
972            case RESETCONTENT: return "Reset Content";
973            case PARTIALCONTENT: return "Partial Content";
974            case MULTIPLECHOICES: return "Multiple Choices";
975            case MOVEDPERMANENTLY: return "Moved Permanently";
976            case FOUND: return "Found";
977            case SEEOTHER: return "See Other";
978            case NOTMODIFIED: return "Not Modified";
979            case USEPROXY: return "Use Proxy";
980            case TEMPORARYREDIRECT: return "Temporary Redirect";
981            case PERMANENTREDIRECT: return "Permanent Redirect";
982            case BADREQUEST: return "Bad Request";
983            case UNAUTHORIZED: return "Unauthorized";
984            case PAYMENTREQUIRED: return "Payment Required";
985            case FORBIDDEN: return "Forbidden";
986            case NOTFOUND: return "Not Found";
987            case METHODNOTALLOWED: return "Method Not Allowed";
988            case NOTACCEPTABLE: return "Not Acceptable";
989            case PROXYAUTHENTICATIONREQUIRED: return "Proxy Authentication Required";
990            case REQUESTTIMEOUT: return "Request Timeout";
991            case CONFLICT: return "Conflict";
992            case GONE: return "Gone";
993            case LENGTHREQUIRED: return "Length Required";
994            case PRECONDITIONFAILED: return "Precondition Failed";
995            case CONTENTTOOLARGE: return "Content Too Large";
996            case URITOOLONG: return "URI Too Long";
997            case UNSUPPORTEDMEDIATYPE: return "Unsupported Media Type";
998            case RANGENOTSATISFIABLE: return "Range Not Satisfiable";
999            case EXPECTATIONFAILED: return "Expectation Failed";
1000            case MISDIRECTEDREQUEST: return "Misdirected Request";
1001            case UNPROCESSABLECONTENT: return "Unprocessable Content";
1002            case UPGRADEREQUIRED: return "Upgrade Required";
1003            case INTERNALSERVERERROR: return "Internal Server Error";
1004            case NOTIMPLEMENTED: return "Not Implemented";
1005            case BADGATEWAY: return "Bad Gateway";
1006            case SERVICEUNAVAILABLE: return "Service Unavailable";
1007            case GATEWAYTIMEOUT: return "Gateway Timeout";
1008            case HTTPVERSIONNOTSUPPORTED: return "HTTP Version Not Supported";
1009            case NULL: return null;
1010            default: return "?";
1011          }
1012        }
1013    }
1014
1015  public static class AssertionResponseTypesEnumFactory implements EnumFactory<AssertionResponseTypes> {
1016    public AssertionResponseTypes fromCode(String codeString) throws IllegalArgumentException {
1017      if (codeString == null || "".equals(codeString))
1018            if (codeString == null || "".equals(codeString))
1019                return null;
1020        if ("continue".equals(codeString))
1021          return AssertionResponseTypes.CONTINUE;
1022        if ("switchingProtocols".equals(codeString))
1023          return AssertionResponseTypes.SWITCHINGPROTOCOLS;
1024        if ("okay".equals(codeString))
1025          return AssertionResponseTypes.OKAY;
1026        if ("created".equals(codeString))
1027          return AssertionResponseTypes.CREATED;
1028        if ("accepted".equals(codeString))
1029          return AssertionResponseTypes.ACCEPTED;
1030        if ("nonAuthoritativeInformation".equals(codeString))
1031          return AssertionResponseTypes.NONAUTHORITATIVEINFORMATION;
1032        if ("noContent".equals(codeString))
1033          return AssertionResponseTypes.NOCONTENT;
1034        if ("resetContent".equals(codeString))
1035          return AssertionResponseTypes.RESETCONTENT;
1036        if ("partialContent".equals(codeString))
1037          return AssertionResponseTypes.PARTIALCONTENT;
1038        if ("multipleChoices".equals(codeString))
1039          return AssertionResponseTypes.MULTIPLECHOICES;
1040        if ("movedPermanently".equals(codeString))
1041          return AssertionResponseTypes.MOVEDPERMANENTLY;
1042        if ("found".equals(codeString))
1043          return AssertionResponseTypes.FOUND;
1044        if ("seeOther".equals(codeString))
1045          return AssertionResponseTypes.SEEOTHER;
1046        if ("notModified".equals(codeString))
1047          return AssertionResponseTypes.NOTMODIFIED;
1048        if ("useProxy".equals(codeString))
1049          return AssertionResponseTypes.USEPROXY;
1050        if ("temporaryRedirect".equals(codeString))
1051          return AssertionResponseTypes.TEMPORARYREDIRECT;
1052        if ("permanentRedirect".equals(codeString))
1053          return AssertionResponseTypes.PERMANENTREDIRECT;
1054        if ("badRequest".equals(codeString))
1055          return AssertionResponseTypes.BADREQUEST;
1056        if ("unauthorized".equals(codeString))
1057          return AssertionResponseTypes.UNAUTHORIZED;
1058        if ("paymentRequired".equals(codeString))
1059          return AssertionResponseTypes.PAYMENTREQUIRED;
1060        if ("forbidden".equals(codeString))
1061          return AssertionResponseTypes.FORBIDDEN;
1062        if ("notFound".equals(codeString))
1063          return AssertionResponseTypes.NOTFOUND;
1064        if ("methodNotAllowed".equals(codeString))
1065          return AssertionResponseTypes.METHODNOTALLOWED;
1066        if ("notAcceptable".equals(codeString))
1067          return AssertionResponseTypes.NOTACCEPTABLE;
1068        if ("proxyAuthenticationRequired".equals(codeString))
1069          return AssertionResponseTypes.PROXYAUTHENTICATIONREQUIRED;
1070        if ("requestTimeout".equals(codeString))
1071          return AssertionResponseTypes.REQUESTTIMEOUT;
1072        if ("conflict".equals(codeString))
1073          return AssertionResponseTypes.CONFLICT;
1074        if ("gone".equals(codeString))
1075          return AssertionResponseTypes.GONE;
1076        if ("lengthRequired".equals(codeString))
1077          return AssertionResponseTypes.LENGTHREQUIRED;
1078        if ("preconditionFailed".equals(codeString))
1079          return AssertionResponseTypes.PRECONDITIONFAILED;
1080        if ("contentTooLarge".equals(codeString))
1081          return AssertionResponseTypes.CONTENTTOOLARGE;
1082        if ("uriTooLong".equals(codeString))
1083          return AssertionResponseTypes.URITOOLONG;
1084        if ("unsupportedMediaType".equals(codeString))
1085          return AssertionResponseTypes.UNSUPPORTEDMEDIATYPE;
1086        if ("rangeNotSatisfiable".equals(codeString))
1087          return AssertionResponseTypes.RANGENOTSATISFIABLE;
1088        if ("expectationFailed".equals(codeString))
1089          return AssertionResponseTypes.EXPECTATIONFAILED;
1090        if ("misdirectedRequest".equals(codeString))
1091          return AssertionResponseTypes.MISDIRECTEDREQUEST;
1092        if ("unprocessableContent".equals(codeString))
1093          return AssertionResponseTypes.UNPROCESSABLECONTENT;
1094        if ("upgradeRequired".equals(codeString))
1095          return AssertionResponseTypes.UPGRADEREQUIRED;
1096        if ("internalServerError".equals(codeString))
1097          return AssertionResponseTypes.INTERNALSERVERERROR;
1098        if ("notImplemented".equals(codeString))
1099          return AssertionResponseTypes.NOTIMPLEMENTED;
1100        if ("badGateway".equals(codeString))
1101          return AssertionResponseTypes.BADGATEWAY;
1102        if ("serviceUnavailable".equals(codeString))
1103          return AssertionResponseTypes.SERVICEUNAVAILABLE;
1104        if ("gatewayTimeout".equals(codeString))
1105          return AssertionResponseTypes.GATEWAYTIMEOUT;
1106        if ("httpVersionNotSupported".equals(codeString))
1107          return AssertionResponseTypes.HTTPVERSIONNOTSUPPORTED;
1108        throw new IllegalArgumentException("Unknown AssertionResponseTypes code '"+codeString+"'");
1109        }
1110        public Enumeration<AssertionResponseTypes> fromType(PrimitiveType<?> code) throws FHIRException {
1111          if (code == null)
1112            return null;
1113          if (code.isEmpty())
1114            return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.NULL, code);
1115          String codeString = ((PrimitiveType) code).asStringValue();
1116          if (codeString == null || "".equals(codeString))
1117            return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.NULL, code);
1118        if ("continue".equals(codeString))
1119          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.CONTINUE, code);
1120        if ("switchingProtocols".equals(codeString))
1121          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.SWITCHINGPROTOCOLS, code);
1122        if ("okay".equals(codeString))
1123          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.OKAY, code);
1124        if ("created".equals(codeString))
1125          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.CREATED, code);
1126        if ("accepted".equals(codeString))
1127          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.ACCEPTED, code);
1128        if ("nonAuthoritativeInformation".equals(codeString))
1129          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.NONAUTHORITATIVEINFORMATION, code);
1130        if ("noContent".equals(codeString))
1131          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.NOCONTENT, code);
1132        if ("resetContent".equals(codeString))
1133          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.RESETCONTENT, code);
1134        if ("partialContent".equals(codeString))
1135          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.PARTIALCONTENT, code);
1136        if ("multipleChoices".equals(codeString))
1137          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.MULTIPLECHOICES, code);
1138        if ("movedPermanently".equals(codeString))
1139          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.MOVEDPERMANENTLY, code);
1140        if ("found".equals(codeString))
1141          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.FOUND, code);
1142        if ("seeOther".equals(codeString))
1143          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.SEEOTHER, code);
1144        if ("notModified".equals(codeString))
1145          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.NOTMODIFIED, code);
1146        if ("useProxy".equals(codeString))
1147          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.USEPROXY, code);
1148        if ("temporaryRedirect".equals(codeString))
1149          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.TEMPORARYREDIRECT, code);
1150        if ("permanentRedirect".equals(codeString))
1151          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.PERMANENTREDIRECT, code);
1152        if ("badRequest".equals(codeString))
1153          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.BADREQUEST, code);
1154        if ("unauthorized".equals(codeString))
1155          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.UNAUTHORIZED, code);
1156        if ("paymentRequired".equals(codeString))
1157          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.PAYMENTREQUIRED, code);
1158        if ("forbidden".equals(codeString))
1159          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.FORBIDDEN, code);
1160        if ("notFound".equals(codeString))
1161          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.NOTFOUND, code);
1162        if ("methodNotAllowed".equals(codeString))
1163          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.METHODNOTALLOWED, code);
1164        if ("notAcceptable".equals(codeString))
1165          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.NOTACCEPTABLE, code);
1166        if ("proxyAuthenticationRequired".equals(codeString))
1167          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.PROXYAUTHENTICATIONREQUIRED, code);
1168        if ("requestTimeout".equals(codeString))
1169          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.REQUESTTIMEOUT, code);
1170        if ("conflict".equals(codeString))
1171          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.CONFLICT, code);
1172        if ("gone".equals(codeString))
1173          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.GONE, code);
1174        if ("lengthRequired".equals(codeString))
1175          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.LENGTHREQUIRED, code);
1176        if ("preconditionFailed".equals(codeString))
1177          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.PRECONDITIONFAILED, code);
1178        if ("contentTooLarge".equals(codeString))
1179          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.CONTENTTOOLARGE, code);
1180        if ("uriTooLong".equals(codeString))
1181          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.URITOOLONG, code);
1182        if ("unsupportedMediaType".equals(codeString))
1183          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.UNSUPPORTEDMEDIATYPE, code);
1184        if ("rangeNotSatisfiable".equals(codeString))
1185          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.RANGENOTSATISFIABLE, code);
1186        if ("expectationFailed".equals(codeString))
1187          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.EXPECTATIONFAILED, code);
1188        if ("misdirectedRequest".equals(codeString))
1189          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.MISDIRECTEDREQUEST, code);
1190        if ("unprocessableContent".equals(codeString))
1191          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.UNPROCESSABLECONTENT, code);
1192        if ("upgradeRequired".equals(codeString))
1193          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.UPGRADEREQUIRED, code);
1194        if ("internalServerError".equals(codeString))
1195          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.INTERNALSERVERERROR, code);
1196        if ("notImplemented".equals(codeString))
1197          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.NOTIMPLEMENTED, code);
1198        if ("badGateway".equals(codeString))
1199          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.BADGATEWAY, code);
1200        if ("serviceUnavailable".equals(codeString))
1201          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.SERVICEUNAVAILABLE, code);
1202        if ("gatewayTimeout".equals(codeString))
1203          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.GATEWAYTIMEOUT, code);
1204        if ("httpVersionNotSupported".equals(codeString))
1205          return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.HTTPVERSIONNOTSUPPORTED, code);
1206        throw new FHIRException("Unknown AssertionResponseTypes code '"+codeString+"'");
1207        }
1208    public String toCode(AssertionResponseTypes code) {
1209      if (code == AssertionResponseTypes.CONTINUE)
1210        return "continue";
1211      if (code == AssertionResponseTypes.SWITCHINGPROTOCOLS)
1212        return "switchingProtocols";
1213      if (code == AssertionResponseTypes.OKAY)
1214        return "okay";
1215      if (code == AssertionResponseTypes.CREATED)
1216        return "created";
1217      if (code == AssertionResponseTypes.ACCEPTED)
1218        return "accepted";
1219      if (code == AssertionResponseTypes.NONAUTHORITATIVEINFORMATION)
1220        return "nonAuthoritativeInformation";
1221      if (code == AssertionResponseTypes.NOCONTENT)
1222        return "noContent";
1223      if (code == AssertionResponseTypes.RESETCONTENT)
1224        return "resetContent";
1225      if (code == AssertionResponseTypes.PARTIALCONTENT)
1226        return "partialContent";
1227      if (code == AssertionResponseTypes.MULTIPLECHOICES)
1228        return "multipleChoices";
1229      if (code == AssertionResponseTypes.MOVEDPERMANENTLY)
1230        return "movedPermanently";
1231      if (code == AssertionResponseTypes.FOUND)
1232        return "found";
1233      if (code == AssertionResponseTypes.SEEOTHER)
1234        return "seeOther";
1235      if (code == AssertionResponseTypes.NOTMODIFIED)
1236        return "notModified";
1237      if (code == AssertionResponseTypes.USEPROXY)
1238        return "useProxy";
1239      if (code == AssertionResponseTypes.TEMPORARYREDIRECT)
1240        return "temporaryRedirect";
1241      if (code == AssertionResponseTypes.PERMANENTREDIRECT)
1242        return "permanentRedirect";
1243      if (code == AssertionResponseTypes.BADREQUEST)
1244        return "badRequest";
1245      if (code == AssertionResponseTypes.UNAUTHORIZED)
1246        return "unauthorized";
1247      if (code == AssertionResponseTypes.PAYMENTREQUIRED)
1248        return "paymentRequired";
1249      if (code == AssertionResponseTypes.FORBIDDEN)
1250        return "forbidden";
1251      if (code == AssertionResponseTypes.NOTFOUND)
1252        return "notFound";
1253      if (code == AssertionResponseTypes.METHODNOTALLOWED)
1254        return "methodNotAllowed";
1255      if (code == AssertionResponseTypes.NOTACCEPTABLE)
1256        return "notAcceptable";
1257      if (code == AssertionResponseTypes.PROXYAUTHENTICATIONREQUIRED)
1258        return "proxyAuthenticationRequired";
1259      if (code == AssertionResponseTypes.REQUESTTIMEOUT)
1260        return "requestTimeout";
1261      if (code == AssertionResponseTypes.CONFLICT)
1262        return "conflict";
1263      if (code == AssertionResponseTypes.GONE)
1264        return "gone";
1265      if (code == AssertionResponseTypes.LENGTHREQUIRED)
1266        return "lengthRequired";
1267      if (code == AssertionResponseTypes.PRECONDITIONFAILED)
1268        return "preconditionFailed";
1269      if (code == AssertionResponseTypes.CONTENTTOOLARGE)
1270        return "contentTooLarge";
1271      if (code == AssertionResponseTypes.URITOOLONG)
1272        return "uriTooLong";
1273      if (code == AssertionResponseTypes.UNSUPPORTEDMEDIATYPE)
1274        return "unsupportedMediaType";
1275      if (code == AssertionResponseTypes.RANGENOTSATISFIABLE)
1276        return "rangeNotSatisfiable";
1277      if (code == AssertionResponseTypes.EXPECTATIONFAILED)
1278        return "expectationFailed";
1279      if (code == AssertionResponseTypes.MISDIRECTEDREQUEST)
1280        return "misdirectedRequest";
1281      if (code == AssertionResponseTypes.UNPROCESSABLECONTENT)
1282        return "unprocessableContent";
1283      if (code == AssertionResponseTypes.UPGRADEREQUIRED)
1284        return "upgradeRequired";
1285      if (code == AssertionResponseTypes.INTERNALSERVERERROR)
1286        return "internalServerError";
1287      if (code == AssertionResponseTypes.NOTIMPLEMENTED)
1288        return "notImplemented";
1289      if (code == AssertionResponseTypes.BADGATEWAY)
1290        return "badGateway";
1291      if (code == AssertionResponseTypes.SERVICEUNAVAILABLE)
1292        return "serviceUnavailable";
1293      if (code == AssertionResponseTypes.GATEWAYTIMEOUT)
1294        return "gatewayTimeout";
1295      if (code == AssertionResponseTypes.HTTPVERSIONNOTSUPPORTED)
1296        return "httpVersionNotSupported";
1297      return "?";
1298      }
1299    public String toSystem(AssertionResponseTypes code) {
1300      return code.getSystem();
1301      }
1302    }
1303
1304    public enum TestScriptRequestMethodCode {
1305        /**
1306         * HTTP DELETE operation.
1307         */
1308        DELETE, 
1309        /**
1310         * HTTP GET operation.
1311         */
1312        GET, 
1313        /**
1314         * HTTP OPTIONS operation.
1315         */
1316        OPTIONS, 
1317        /**
1318         * HTTP PATCH operation.
1319         */
1320        PATCH, 
1321        /**
1322         * HTTP POST operation.
1323         */
1324        POST, 
1325        /**
1326         * HTTP PUT operation.
1327         */
1328        PUT, 
1329        /**
1330         * HTTP HEAD operation.
1331         */
1332        HEAD, 
1333        /**
1334         * added to help the parsers with the generic types
1335         */
1336        NULL;
1337        public static TestScriptRequestMethodCode fromCode(String codeString) throws FHIRException {
1338            if (codeString == null || "".equals(codeString))
1339                return null;
1340        if ("delete".equals(codeString))
1341          return DELETE;
1342        if ("get".equals(codeString))
1343          return GET;
1344        if ("options".equals(codeString))
1345          return OPTIONS;
1346        if ("patch".equals(codeString))
1347          return PATCH;
1348        if ("post".equals(codeString))
1349          return POST;
1350        if ("put".equals(codeString))
1351          return PUT;
1352        if ("head".equals(codeString))
1353          return HEAD;
1354        if (Configuration.isAcceptInvalidEnums())
1355          return null;
1356        else
1357          throw new FHIRException("Unknown TestScriptRequestMethodCode code '"+codeString+"'");
1358        }
1359        public String toCode() {
1360          switch (this) {
1361            case DELETE: return "delete";
1362            case GET: return "get";
1363            case OPTIONS: return "options";
1364            case PATCH: return "patch";
1365            case POST: return "post";
1366            case PUT: return "put";
1367            case HEAD: return "head";
1368            case NULL: return null;
1369            default: return "?";
1370          }
1371        }
1372        public String getSystem() {
1373          switch (this) {
1374            case DELETE: return "http://hl7.org/fhir/http-operations";
1375            case GET: return "http://hl7.org/fhir/http-operations";
1376            case OPTIONS: return "http://hl7.org/fhir/http-operations";
1377            case PATCH: return "http://hl7.org/fhir/http-operations";
1378            case POST: return "http://hl7.org/fhir/http-operations";
1379            case PUT: return "http://hl7.org/fhir/http-operations";
1380            case HEAD: return "http://hl7.org/fhir/http-operations";
1381            case NULL: return null;
1382            default: return "?";
1383          }
1384        }
1385        public String getDefinition() {
1386          switch (this) {
1387            case DELETE: return "HTTP DELETE operation.";
1388            case GET: return "HTTP GET operation.";
1389            case OPTIONS: return "HTTP OPTIONS operation.";
1390            case PATCH: return "HTTP PATCH operation.";
1391            case POST: return "HTTP POST operation.";
1392            case PUT: return "HTTP PUT operation.";
1393            case HEAD: return "HTTP HEAD operation.";
1394            case NULL: return null;
1395            default: return "?";
1396          }
1397        }
1398        public String getDisplay() {
1399          switch (this) {
1400            case DELETE: return "DELETE";
1401            case GET: return "GET";
1402            case OPTIONS: return "OPTIONS";
1403            case PATCH: return "PATCH";
1404            case POST: return "POST";
1405            case PUT: return "PUT";
1406            case HEAD: return "HEAD";
1407            case NULL: return null;
1408            default: return "?";
1409          }
1410        }
1411    }
1412
1413  public static class TestScriptRequestMethodCodeEnumFactory implements EnumFactory<TestScriptRequestMethodCode> {
1414    public TestScriptRequestMethodCode fromCode(String codeString) throws IllegalArgumentException {
1415      if (codeString == null || "".equals(codeString))
1416            if (codeString == null || "".equals(codeString))
1417                return null;
1418        if ("delete".equals(codeString))
1419          return TestScriptRequestMethodCode.DELETE;
1420        if ("get".equals(codeString))
1421          return TestScriptRequestMethodCode.GET;
1422        if ("options".equals(codeString))
1423          return TestScriptRequestMethodCode.OPTIONS;
1424        if ("patch".equals(codeString))
1425          return TestScriptRequestMethodCode.PATCH;
1426        if ("post".equals(codeString))
1427          return TestScriptRequestMethodCode.POST;
1428        if ("put".equals(codeString))
1429          return TestScriptRequestMethodCode.PUT;
1430        if ("head".equals(codeString))
1431          return TestScriptRequestMethodCode.HEAD;
1432        throw new IllegalArgumentException("Unknown TestScriptRequestMethodCode code '"+codeString+"'");
1433        }
1434        public Enumeration<TestScriptRequestMethodCode> fromType(PrimitiveType<?> code) throws FHIRException {
1435          if (code == null)
1436            return null;
1437          if (code.isEmpty())
1438            return new Enumeration<TestScriptRequestMethodCode>(this, TestScriptRequestMethodCode.NULL, code);
1439          String codeString = ((PrimitiveType) code).asStringValue();
1440          if (codeString == null || "".equals(codeString))
1441            return new Enumeration<TestScriptRequestMethodCode>(this, TestScriptRequestMethodCode.NULL, code);
1442        if ("delete".equals(codeString))
1443          return new Enumeration<TestScriptRequestMethodCode>(this, TestScriptRequestMethodCode.DELETE, code);
1444        if ("get".equals(codeString))
1445          return new Enumeration<TestScriptRequestMethodCode>(this, TestScriptRequestMethodCode.GET, code);
1446        if ("options".equals(codeString))
1447          return new Enumeration<TestScriptRequestMethodCode>(this, TestScriptRequestMethodCode.OPTIONS, code);
1448        if ("patch".equals(codeString))
1449          return new Enumeration<TestScriptRequestMethodCode>(this, TestScriptRequestMethodCode.PATCH, code);
1450        if ("post".equals(codeString))
1451          return new Enumeration<TestScriptRequestMethodCode>(this, TestScriptRequestMethodCode.POST, code);
1452        if ("put".equals(codeString))
1453          return new Enumeration<TestScriptRequestMethodCode>(this, TestScriptRequestMethodCode.PUT, code);
1454        if ("head".equals(codeString))
1455          return new Enumeration<TestScriptRequestMethodCode>(this, TestScriptRequestMethodCode.HEAD, code);
1456        throw new FHIRException("Unknown TestScriptRequestMethodCode code '"+codeString+"'");
1457        }
1458    public String toCode(TestScriptRequestMethodCode code) {
1459      if (code == TestScriptRequestMethodCode.DELETE)
1460        return "delete";
1461      if (code == TestScriptRequestMethodCode.GET)
1462        return "get";
1463      if (code == TestScriptRequestMethodCode.OPTIONS)
1464        return "options";
1465      if (code == TestScriptRequestMethodCode.PATCH)
1466        return "patch";
1467      if (code == TestScriptRequestMethodCode.POST)
1468        return "post";
1469      if (code == TestScriptRequestMethodCode.PUT)
1470        return "put";
1471      if (code == TestScriptRequestMethodCode.HEAD)
1472        return "head";
1473      return "?";
1474      }
1475    public String toSystem(TestScriptRequestMethodCode code) {
1476      return code.getSystem();
1477      }
1478    }
1479
1480    @Block()
1481    public static class TestScriptOriginComponent extends BackboneElement implements IBaseBackboneElement {
1482        /**
1483         * Abstract name given to an origin server in this test script.  The name is provided as a number starting at 1.
1484         */
1485        @Child(name = "index", type = {IntegerType.class}, order=1, min=1, max=1, modifier=false, summary=false)
1486        @Description(shortDefinition="The index of the abstract origin server starting at 1", formalDefinition="Abstract name given to an origin server in this test script.  The name is provided as a number starting at 1." )
1487        protected IntegerType index;
1488
1489        /**
1490         * The type of origin profile the test system supports.
1491         */
1492        @Child(name = "profile", type = {Coding.class}, order=2, min=1, max=1, modifier=false, summary=false)
1493        @Description(shortDefinition="FHIR-Client | FHIR-SDC-FormFiller", formalDefinition="The type of origin profile the test system supports." )
1494        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/testscript-profile-origin-types")
1495        protected Coding profile;
1496
1497        /**
1498         * The explicit url path of the origin server used in this test script.
1499         */
1500        @Child(name = "url", type = {UrlType.class}, order=3, min=0, max=1, modifier=false, summary=false)
1501        @Description(shortDefinition="The url path of the origin server", formalDefinition="The explicit url path of the origin server used in this test script." )
1502        protected UrlType url;
1503
1504        private static final long serialVersionUID = -188072923L;
1505
1506    /**
1507     * Constructor
1508     */
1509      public TestScriptOriginComponent() {
1510        super();
1511      }
1512
1513    /**
1514     * Constructor
1515     */
1516      public TestScriptOriginComponent(int index, Coding profile) {
1517        super();
1518        this.setIndex(index);
1519        this.setProfile(profile);
1520      }
1521
1522        /**
1523         * @return {@link #index} (Abstract name given to an origin server in this test script.  The name is provided as a number starting at 1.). This is the underlying object with id, value and extensions. The accessor "getIndex" gives direct access to the value
1524         */
1525        public IntegerType getIndexElement() { 
1526          if (this.index == null)
1527            if (Configuration.errorOnAutoCreate())
1528              throw new Error("Attempt to auto-create TestScriptOriginComponent.index");
1529            else if (Configuration.doAutoCreate())
1530              this.index = new IntegerType(); // bb
1531          return this.index;
1532        }
1533
1534        public boolean hasIndexElement() { 
1535          return this.index != null && !this.index.isEmpty();
1536        }
1537
1538        public boolean hasIndex() { 
1539          return this.index != null && !this.index.isEmpty();
1540        }
1541
1542        /**
1543         * @param value {@link #index} (Abstract name given to an origin server in this test script.  The name is provided as a number starting at 1.). This is the underlying object with id, value and extensions. The accessor "getIndex" gives direct access to the value
1544         */
1545        public TestScriptOriginComponent setIndexElement(IntegerType value) { 
1546          this.index = value;
1547          return this;
1548        }
1549
1550        /**
1551         * @return Abstract name given to an origin server in this test script.  The name is provided as a number starting at 1.
1552         */
1553        public int getIndex() { 
1554          return this.index == null || this.index.isEmpty() ? 0 : this.index.getValue();
1555        }
1556
1557        /**
1558         * @param value Abstract name given to an origin server in this test script.  The name is provided as a number starting at 1.
1559         */
1560        public TestScriptOriginComponent setIndex(int value) { 
1561            if (this.index == null)
1562              this.index = new IntegerType();
1563            this.index.setValue(value);
1564          return this;
1565        }
1566
1567        /**
1568         * @return {@link #profile} (The type of origin profile the test system supports.)
1569         */
1570        public Coding getProfile() { 
1571          if (this.profile == null)
1572            if (Configuration.errorOnAutoCreate())
1573              throw new Error("Attempt to auto-create TestScriptOriginComponent.profile");
1574            else if (Configuration.doAutoCreate())
1575              this.profile = new Coding(); // cc
1576          return this.profile;
1577        }
1578
1579        public boolean hasProfile() { 
1580          return this.profile != null && !this.profile.isEmpty();
1581        }
1582
1583        /**
1584         * @param value {@link #profile} (The type of origin profile the test system supports.)
1585         */
1586        public TestScriptOriginComponent setProfile(Coding value) { 
1587          this.profile = value;
1588          return this;
1589        }
1590
1591        /**
1592         * @return {@link #url} (The explicit url path of the origin server used in this test script.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
1593         */
1594        public UrlType getUrlElement() { 
1595          if (this.url == null)
1596            if (Configuration.errorOnAutoCreate())
1597              throw new Error("Attempt to auto-create TestScriptOriginComponent.url");
1598            else if (Configuration.doAutoCreate())
1599              this.url = new UrlType(); // bb
1600          return this.url;
1601        }
1602
1603        public boolean hasUrlElement() { 
1604          return this.url != null && !this.url.isEmpty();
1605        }
1606
1607        public boolean hasUrl() { 
1608          return this.url != null && !this.url.isEmpty();
1609        }
1610
1611        /**
1612         * @param value {@link #url} (The explicit url path of the origin server used in this test script.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
1613         */
1614        public TestScriptOriginComponent setUrlElement(UrlType value) { 
1615          this.url = value;
1616          return this;
1617        }
1618
1619        /**
1620         * @return The explicit url path of the origin server used in this test script.
1621         */
1622        public String getUrl() { 
1623          return this.url == null ? null : this.url.getValue();
1624        }
1625
1626        /**
1627         * @param value The explicit url path of the origin server used in this test script.
1628         */
1629        public TestScriptOriginComponent setUrl(String value) { 
1630          if (Utilities.noString(value))
1631            this.url = null;
1632          else {
1633            if (this.url == null)
1634              this.url = new UrlType();
1635            this.url.setValue(value);
1636          }
1637          return this;
1638        }
1639
1640        protected void listChildren(List<Property> children) {
1641          super.listChildren(children);
1642          children.add(new Property("index", "integer", "Abstract name given to an origin server in this test script.  The name is provided as a number starting at 1.", 0, 1, index));
1643          children.add(new Property("profile", "Coding", "The type of origin profile the test system supports.", 0, 1, profile));
1644          children.add(new Property("url", "url", "The explicit url path of the origin server used in this test script.", 0, 1, url));
1645        }
1646
1647        @Override
1648        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1649          switch (_hash) {
1650          case 100346066: /*index*/  return new Property("index", "integer", "Abstract name given to an origin server in this test script.  The name is provided as a number starting at 1.", 0, 1, index);
1651          case -309425751: /*profile*/  return new Property("profile", "Coding", "The type of origin profile the test system supports.", 0, 1, profile);
1652          case 116079: /*url*/  return new Property("url", "url", "The explicit url path of the origin server used in this test script.", 0, 1, url);
1653          default: return super.getNamedProperty(_hash, _name, _checkValid);
1654          }
1655
1656        }
1657
1658      @Override
1659      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1660        switch (hash) {
1661        case 100346066: /*index*/ return this.index == null ? new Base[0] : new Base[] {this.index}; // IntegerType
1662        case -309425751: /*profile*/ return this.profile == null ? new Base[0] : new Base[] {this.profile}; // Coding
1663        case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UrlType
1664        default: return super.getProperty(hash, name, checkValid);
1665        }
1666
1667      }
1668
1669      @Override
1670      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1671        switch (hash) {
1672        case 100346066: // index
1673          this.index = TypeConvertor.castToInteger(value); // IntegerType
1674          return value;
1675        case -309425751: // profile
1676          this.profile = TypeConvertor.castToCoding(value); // Coding
1677          return value;
1678        case 116079: // url
1679          this.url = TypeConvertor.castToUrl(value); // UrlType
1680          return value;
1681        default: return super.setProperty(hash, name, value);
1682        }
1683
1684      }
1685
1686      @Override
1687      public Base setProperty(String name, Base value) throws FHIRException {
1688        if (name.equals("index")) {
1689          this.index = TypeConvertor.castToInteger(value); // IntegerType
1690        } else if (name.equals("profile")) {
1691          this.profile = TypeConvertor.castToCoding(value); // Coding
1692        } else if (name.equals("url")) {
1693          this.url = TypeConvertor.castToUrl(value); // UrlType
1694        } else
1695          return super.setProperty(name, value);
1696        return value;
1697      }
1698
1699      @Override
1700      public Base makeProperty(int hash, String name) throws FHIRException {
1701        switch (hash) {
1702        case 100346066:  return getIndexElement();
1703        case -309425751:  return getProfile();
1704        case 116079:  return getUrlElement();
1705        default: return super.makeProperty(hash, name);
1706        }
1707
1708      }
1709
1710      @Override
1711      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1712        switch (hash) {
1713        case 100346066: /*index*/ return new String[] {"integer"};
1714        case -309425751: /*profile*/ return new String[] {"Coding"};
1715        case 116079: /*url*/ return new String[] {"url"};
1716        default: return super.getTypesForProperty(hash, name);
1717        }
1718
1719      }
1720
1721      @Override
1722      public Base addChild(String name) throws FHIRException {
1723        if (name.equals("index")) {
1724          throw new FHIRException("Cannot call addChild on a singleton property TestScript.origin.index");
1725        }
1726        else if (name.equals("profile")) {
1727          this.profile = new Coding();
1728          return this.profile;
1729        }
1730        else if (name.equals("url")) {
1731          throw new FHIRException("Cannot call addChild on a singleton property TestScript.origin.url");
1732        }
1733        else
1734          return super.addChild(name);
1735      }
1736
1737      public TestScriptOriginComponent copy() {
1738        TestScriptOriginComponent dst = new TestScriptOriginComponent();
1739        copyValues(dst);
1740        return dst;
1741      }
1742
1743      public void copyValues(TestScriptOriginComponent dst) {
1744        super.copyValues(dst);
1745        dst.index = index == null ? null : index.copy();
1746        dst.profile = profile == null ? null : profile.copy();
1747        dst.url = url == null ? null : url.copy();
1748      }
1749
1750      @Override
1751      public boolean equalsDeep(Base other_) {
1752        if (!super.equalsDeep(other_))
1753          return false;
1754        if (!(other_ instanceof TestScriptOriginComponent))
1755          return false;
1756        TestScriptOriginComponent o = (TestScriptOriginComponent) other_;
1757        return compareDeep(index, o.index, true) && compareDeep(profile, o.profile, true) && compareDeep(url, o.url, true)
1758          ;
1759      }
1760
1761      @Override
1762      public boolean equalsShallow(Base other_) {
1763        if (!super.equalsShallow(other_))
1764          return false;
1765        if (!(other_ instanceof TestScriptOriginComponent))
1766          return false;
1767        TestScriptOriginComponent o = (TestScriptOriginComponent) other_;
1768        return compareValues(index, o.index, true) && compareValues(url, o.url, true);
1769      }
1770
1771      public boolean isEmpty() {
1772        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(index, profile, url);
1773      }
1774
1775  public String fhirType() {
1776    return "TestScript.origin";
1777
1778  }
1779
1780  }
1781
1782    @Block()
1783    public static class TestScriptDestinationComponent extends BackboneElement implements IBaseBackboneElement {
1784        /**
1785         * Abstract name given to a destination server in this test script.  The name is provided as a number starting at 1.
1786         */
1787        @Child(name = "index", type = {IntegerType.class}, order=1, min=1, max=1, modifier=false, summary=false)
1788        @Description(shortDefinition="The index of the abstract destination server starting at 1", formalDefinition="Abstract name given to a destination server in this test script.  The name is provided as a number starting at 1." )
1789        protected IntegerType index;
1790
1791        /**
1792         * The type of destination profile the test system supports.
1793         */
1794        @Child(name = "profile", type = {Coding.class}, order=2, min=1, max=1, modifier=false, summary=false)
1795        @Description(shortDefinition="FHIR-Server | FHIR-SDC-FormManager | FHIR-SDC-FormReceiver | FHIR-SDC-FormProcessor", formalDefinition="The type of destination profile the test system supports." )
1796        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/testscript-profile-destination-types")
1797        protected Coding profile;
1798
1799        /**
1800         * The explicit url path of the destination server used in this test script.
1801         */
1802        @Child(name = "url", type = {UrlType.class}, order=3, min=0, max=1, modifier=false, summary=false)
1803        @Description(shortDefinition="The url path of the destination server", formalDefinition="The explicit url path of the destination server used in this test script." )
1804        protected UrlType url;
1805
1806        private static final long serialVersionUID = -188072923L;
1807
1808    /**
1809     * Constructor
1810     */
1811      public TestScriptDestinationComponent() {
1812        super();
1813      }
1814
1815    /**
1816     * Constructor
1817     */
1818      public TestScriptDestinationComponent(int index, Coding profile) {
1819        super();
1820        this.setIndex(index);
1821        this.setProfile(profile);
1822      }
1823
1824        /**
1825         * @return {@link #index} (Abstract name given to a destination server in this test script.  The name is provided as a number starting at 1.). This is the underlying object with id, value and extensions. The accessor "getIndex" gives direct access to the value
1826         */
1827        public IntegerType getIndexElement() { 
1828          if (this.index == null)
1829            if (Configuration.errorOnAutoCreate())
1830              throw new Error("Attempt to auto-create TestScriptDestinationComponent.index");
1831            else if (Configuration.doAutoCreate())
1832              this.index = new IntegerType(); // bb
1833          return this.index;
1834        }
1835
1836        public boolean hasIndexElement() { 
1837          return this.index != null && !this.index.isEmpty();
1838        }
1839
1840        public boolean hasIndex() { 
1841          return this.index != null && !this.index.isEmpty();
1842        }
1843
1844        /**
1845         * @param value {@link #index} (Abstract name given to a destination server in this test script.  The name is provided as a number starting at 1.). This is the underlying object with id, value and extensions. The accessor "getIndex" gives direct access to the value
1846         */
1847        public TestScriptDestinationComponent setIndexElement(IntegerType value) { 
1848          this.index = value;
1849          return this;
1850        }
1851
1852        /**
1853         * @return Abstract name given to a destination server in this test script.  The name is provided as a number starting at 1.
1854         */
1855        public int getIndex() { 
1856          return this.index == null || this.index.isEmpty() ? 0 : this.index.getValue();
1857        }
1858
1859        /**
1860         * @param value Abstract name given to a destination server in this test script.  The name is provided as a number starting at 1.
1861         */
1862        public TestScriptDestinationComponent setIndex(int value) { 
1863            if (this.index == null)
1864              this.index = new IntegerType();
1865            this.index.setValue(value);
1866          return this;
1867        }
1868
1869        /**
1870         * @return {@link #profile} (The type of destination profile the test system supports.)
1871         */
1872        public Coding getProfile() { 
1873          if (this.profile == null)
1874            if (Configuration.errorOnAutoCreate())
1875              throw new Error("Attempt to auto-create TestScriptDestinationComponent.profile");
1876            else if (Configuration.doAutoCreate())
1877              this.profile = new Coding(); // cc
1878          return this.profile;
1879        }
1880
1881        public boolean hasProfile() { 
1882          return this.profile != null && !this.profile.isEmpty();
1883        }
1884
1885        /**
1886         * @param value {@link #profile} (The type of destination profile the test system supports.)
1887         */
1888        public TestScriptDestinationComponent setProfile(Coding value) { 
1889          this.profile = value;
1890          return this;
1891        }
1892
1893        /**
1894         * @return {@link #url} (The explicit url path of the destination server used in this test script.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
1895         */
1896        public UrlType getUrlElement() { 
1897          if (this.url == null)
1898            if (Configuration.errorOnAutoCreate())
1899              throw new Error("Attempt to auto-create TestScriptDestinationComponent.url");
1900            else if (Configuration.doAutoCreate())
1901              this.url = new UrlType(); // bb
1902          return this.url;
1903        }
1904
1905        public boolean hasUrlElement() { 
1906          return this.url != null && !this.url.isEmpty();
1907        }
1908
1909        public boolean hasUrl() { 
1910          return this.url != null && !this.url.isEmpty();
1911        }
1912
1913        /**
1914         * @param value {@link #url} (The explicit url path of the destination server used in this test script.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
1915         */
1916        public TestScriptDestinationComponent setUrlElement(UrlType value) { 
1917          this.url = value;
1918          return this;
1919        }
1920
1921        /**
1922         * @return The explicit url path of the destination server used in this test script.
1923         */
1924        public String getUrl() { 
1925          return this.url == null ? null : this.url.getValue();
1926        }
1927
1928        /**
1929         * @param value The explicit url path of the destination server used in this test script.
1930         */
1931        public TestScriptDestinationComponent setUrl(String value) { 
1932          if (Utilities.noString(value))
1933            this.url = null;
1934          else {
1935            if (this.url == null)
1936              this.url = new UrlType();
1937            this.url.setValue(value);
1938          }
1939          return this;
1940        }
1941
1942        protected void listChildren(List<Property> children) {
1943          super.listChildren(children);
1944          children.add(new Property("index", "integer", "Abstract name given to a destination server in this test script.  The name is provided as a number starting at 1.", 0, 1, index));
1945          children.add(new Property("profile", "Coding", "The type of destination profile the test system supports.", 0, 1, profile));
1946          children.add(new Property("url", "url", "The explicit url path of the destination server used in this test script.", 0, 1, url));
1947        }
1948
1949        @Override
1950        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1951          switch (_hash) {
1952          case 100346066: /*index*/  return new Property("index", "integer", "Abstract name given to a destination server in this test script.  The name is provided as a number starting at 1.", 0, 1, index);
1953          case -309425751: /*profile*/  return new Property("profile", "Coding", "The type of destination profile the test system supports.", 0, 1, profile);
1954          case 116079: /*url*/  return new Property("url", "url", "The explicit url path of the destination server used in this test script.", 0, 1, url);
1955          default: return super.getNamedProperty(_hash, _name, _checkValid);
1956          }
1957
1958        }
1959
1960      @Override
1961      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1962        switch (hash) {
1963        case 100346066: /*index*/ return this.index == null ? new Base[0] : new Base[] {this.index}; // IntegerType
1964        case -309425751: /*profile*/ return this.profile == null ? new Base[0] : new Base[] {this.profile}; // Coding
1965        case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UrlType
1966        default: return super.getProperty(hash, name, checkValid);
1967        }
1968
1969      }
1970
1971      @Override
1972      public Base setProperty(int hash, String name, Base value) throws FHIRException {
1973        switch (hash) {
1974        case 100346066: // index
1975          this.index = TypeConvertor.castToInteger(value); // IntegerType
1976          return value;
1977        case -309425751: // profile
1978          this.profile = TypeConvertor.castToCoding(value); // Coding
1979          return value;
1980        case 116079: // url
1981          this.url = TypeConvertor.castToUrl(value); // UrlType
1982          return value;
1983        default: return super.setProperty(hash, name, value);
1984        }
1985
1986      }
1987
1988      @Override
1989      public Base setProperty(String name, Base value) throws FHIRException {
1990        if (name.equals("index")) {
1991          this.index = TypeConvertor.castToInteger(value); // IntegerType
1992        } else if (name.equals("profile")) {
1993          this.profile = TypeConvertor.castToCoding(value); // Coding
1994        } else if (name.equals("url")) {
1995          this.url = TypeConvertor.castToUrl(value); // UrlType
1996        } else
1997          return super.setProperty(name, value);
1998        return value;
1999      }
2000
2001      @Override
2002      public Base makeProperty(int hash, String name) throws FHIRException {
2003        switch (hash) {
2004        case 100346066:  return getIndexElement();
2005        case -309425751:  return getProfile();
2006        case 116079:  return getUrlElement();
2007        default: return super.makeProperty(hash, name);
2008        }
2009
2010      }
2011
2012      @Override
2013      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2014        switch (hash) {
2015        case 100346066: /*index*/ return new String[] {"integer"};
2016        case -309425751: /*profile*/ return new String[] {"Coding"};
2017        case 116079: /*url*/ return new String[] {"url"};
2018        default: return super.getTypesForProperty(hash, name);
2019        }
2020
2021      }
2022
2023      @Override
2024      public Base addChild(String name) throws FHIRException {
2025        if (name.equals("index")) {
2026          throw new FHIRException("Cannot call addChild on a singleton property TestScript.destination.index");
2027        }
2028        else if (name.equals("profile")) {
2029          this.profile = new Coding();
2030          return this.profile;
2031        }
2032        else if (name.equals("url")) {
2033          throw new FHIRException("Cannot call addChild on a singleton property TestScript.destination.url");
2034        }
2035        else
2036          return super.addChild(name);
2037      }
2038
2039      public TestScriptDestinationComponent copy() {
2040        TestScriptDestinationComponent dst = new TestScriptDestinationComponent();
2041        copyValues(dst);
2042        return dst;
2043      }
2044
2045      public void copyValues(TestScriptDestinationComponent dst) {
2046        super.copyValues(dst);
2047        dst.index = index == null ? null : index.copy();
2048        dst.profile = profile == null ? null : profile.copy();
2049        dst.url = url == null ? null : url.copy();
2050      }
2051
2052      @Override
2053      public boolean equalsDeep(Base other_) {
2054        if (!super.equalsDeep(other_))
2055          return false;
2056        if (!(other_ instanceof TestScriptDestinationComponent))
2057          return false;
2058        TestScriptDestinationComponent o = (TestScriptDestinationComponent) other_;
2059        return compareDeep(index, o.index, true) && compareDeep(profile, o.profile, true) && compareDeep(url, o.url, true)
2060          ;
2061      }
2062
2063      @Override
2064      public boolean equalsShallow(Base other_) {
2065        if (!super.equalsShallow(other_))
2066          return false;
2067        if (!(other_ instanceof TestScriptDestinationComponent))
2068          return false;
2069        TestScriptDestinationComponent o = (TestScriptDestinationComponent) other_;
2070        return compareValues(index, o.index, true) && compareValues(url, o.url, true);
2071      }
2072
2073      public boolean isEmpty() {
2074        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(index, profile, url);
2075      }
2076
2077  public String fhirType() {
2078    return "TestScript.destination";
2079
2080  }
2081
2082  }
2083
2084    @Block()
2085    public static class TestScriptMetadataComponent extends BackboneElement implements IBaseBackboneElement {
2086        /**
2087         * A link to the FHIR specification that this test is covering.
2088         */
2089        @Child(name = "link", type = {}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2090        @Description(shortDefinition="Links to the FHIR specification", formalDefinition="A link to the FHIR specification that this test is covering." )
2091        protected List<TestScriptMetadataLinkComponent> link;
2092
2093        /**
2094         * Capabilities that must exist and are assumed to function correctly on the FHIR server being tested.
2095         */
2096        @Child(name = "capability", type = {}, order=2, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2097        @Description(shortDefinition="Capabilities  that are assumed to function correctly on the FHIR server being tested", formalDefinition="Capabilities that must exist and are assumed to function correctly on the FHIR server being tested." )
2098        protected List<TestScriptMetadataCapabilityComponent> capability;
2099
2100        private static final long serialVersionUID = 745183328L;
2101
2102    /**
2103     * Constructor
2104     */
2105      public TestScriptMetadataComponent() {
2106        super();
2107      }
2108
2109    /**
2110     * Constructor
2111     */
2112      public TestScriptMetadataComponent(TestScriptMetadataCapabilityComponent capability) {
2113        super();
2114        this.addCapability(capability);
2115      }
2116
2117        /**
2118         * @return {@link #link} (A link to the FHIR specification that this test is covering.)
2119         */
2120        public List<TestScriptMetadataLinkComponent> getLink() { 
2121          if (this.link == null)
2122            this.link = new ArrayList<TestScriptMetadataLinkComponent>();
2123          return this.link;
2124        }
2125
2126        /**
2127         * @return Returns a reference to <code>this</code> for easy method chaining
2128         */
2129        public TestScriptMetadataComponent setLink(List<TestScriptMetadataLinkComponent> theLink) { 
2130          this.link = theLink;
2131          return this;
2132        }
2133
2134        public boolean hasLink() { 
2135          if (this.link == null)
2136            return false;
2137          for (TestScriptMetadataLinkComponent item : this.link)
2138            if (!item.isEmpty())
2139              return true;
2140          return false;
2141        }
2142
2143        public TestScriptMetadataLinkComponent addLink() { //3
2144          TestScriptMetadataLinkComponent t = new TestScriptMetadataLinkComponent();
2145          if (this.link == null)
2146            this.link = new ArrayList<TestScriptMetadataLinkComponent>();
2147          this.link.add(t);
2148          return t;
2149        }
2150
2151        public TestScriptMetadataComponent addLink(TestScriptMetadataLinkComponent t) { //3
2152          if (t == null)
2153            return this;
2154          if (this.link == null)
2155            this.link = new ArrayList<TestScriptMetadataLinkComponent>();
2156          this.link.add(t);
2157          return this;
2158        }
2159
2160        /**
2161         * @return The first repetition of repeating field {@link #link}, creating it if it does not already exist {3}
2162         */
2163        public TestScriptMetadataLinkComponent getLinkFirstRep() { 
2164          if (getLink().isEmpty()) {
2165            addLink();
2166          }
2167          return getLink().get(0);
2168        }
2169
2170        /**
2171         * @return {@link #capability} (Capabilities that must exist and are assumed to function correctly on the FHIR server being tested.)
2172         */
2173        public List<TestScriptMetadataCapabilityComponent> getCapability() { 
2174          if (this.capability == null)
2175            this.capability = new ArrayList<TestScriptMetadataCapabilityComponent>();
2176          return this.capability;
2177        }
2178
2179        /**
2180         * @return Returns a reference to <code>this</code> for easy method chaining
2181         */
2182        public TestScriptMetadataComponent setCapability(List<TestScriptMetadataCapabilityComponent> theCapability) { 
2183          this.capability = theCapability;
2184          return this;
2185        }
2186
2187        public boolean hasCapability() { 
2188          if (this.capability == null)
2189            return false;
2190          for (TestScriptMetadataCapabilityComponent item : this.capability)
2191            if (!item.isEmpty())
2192              return true;
2193          return false;
2194        }
2195
2196        public TestScriptMetadataCapabilityComponent addCapability() { //3
2197          TestScriptMetadataCapabilityComponent t = new TestScriptMetadataCapabilityComponent();
2198          if (this.capability == null)
2199            this.capability = new ArrayList<TestScriptMetadataCapabilityComponent>();
2200          this.capability.add(t);
2201          return t;
2202        }
2203
2204        public TestScriptMetadataComponent addCapability(TestScriptMetadataCapabilityComponent t) { //3
2205          if (t == null)
2206            return this;
2207          if (this.capability == null)
2208            this.capability = new ArrayList<TestScriptMetadataCapabilityComponent>();
2209          this.capability.add(t);
2210          return this;
2211        }
2212
2213        /**
2214         * @return The first repetition of repeating field {@link #capability}, creating it if it does not already exist {3}
2215         */
2216        public TestScriptMetadataCapabilityComponent getCapabilityFirstRep() { 
2217          if (getCapability().isEmpty()) {
2218            addCapability();
2219          }
2220          return getCapability().get(0);
2221        }
2222
2223        protected void listChildren(List<Property> children) {
2224          super.listChildren(children);
2225          children.add(new Property("link", "", "A link to the FHIR specification that this test is covering.", 0, java.lang.Integer.MAX_VALUE, link));
2226          children.add(new Property("capability", "", "Capabilities that must exist and are assumed to function correctly on the FHIR server being tested.", 0, java.lang.Integer.MAX_VALUE, capability));
2227        }
2228
2229        @Override
2230        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2231          switch (_hash) {
2232          case 3321850: /*link*/  return new Property("link", "", "A link to the FHIR specification that this test is covering.", 0, java.lang.Integer.MAX_VALUE, link);
2233          case -783669992: /*capability*/  return new Property("capability", "", "Capabilities that must exist and are assumed to function correctly on the FHIR server being tested.", 0, java.lang.Integer.MAX_VALUE, capability);
2234          default: return super.getNamedProperty(_hash, _name, _checkValid);
2235          }
2236
2237        }
2238
2239      @Override
2240      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2241        switch (hash) {
2242        case 3321850: /*link*/ return this.link == null ? new Base[0] : this.link.toArray(new Base[this.link.size()]); // TestScriptMetadataLinkComponent
2243        case -783669992: /*capability*/ return this.capability == null ? new Base[0] : this.capability.toArray(new Base[this.capability.size()]); // TestScriptMetadataCapabilityComponent
2244        default: return super.getProperty(hash, name, checkValid);
2245        }
2246
2247      }
2248
2249      @Override
2250      public Base setProperty(int hash, String name, Base value) throws FHIRException {
2251        switch (hash) {
2252        case 3321850: // link
2253          this.getLink().add((TestScriptMetadataLinkComponent) value); // TestScriptMetadataLinkComponent
2254          return value;
2255        case -783669992: // capability
2256          this.getCapability().add((TestScriptMetadataCapabilityComponent) value); // TestScriptMetadataCapabilityComponent
2257          return value;
2258        default: return super.setProperty(hash, name, value);
2259        }
2260
2261      }
2262
2263      @Override
2264      public Base setProperty(String name, Base value) throws FHIRException {
2265        if (name.equals("link")) {
2266          this.getLink().add((TestScriptMetadataLinkComponent) value);
2267        } else if (name.equals("capability")) {
2268          this.getCapability().add((TestScriptMetadataCapabilityComponent) value);
2269        } else
2270          return super.setProperty(name, value);
2271        return value;
2272      }
2273
2274      @Override
2275      public Base makeProperty(int hash, String name) throws FHIRException {
2276        switch (hash) {
2277        case 3321850:  return addLink(); 
2278        case -783669992:  return addCapability(); 
2279        default: return super.makeProperty(hash, name);
2280        }
2281
2282      }
2283
2284      @Override
2285      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2286        switch (hash) {
2287        case 3321850: /*link*/ return new String[] {};
2288        case -783669992: /*capability*/ return new String[] {};
2289        default: return super.getTypesForProperty(hash, name);
2290        }
2291
2292      }
2293
2294      @Override
2295      public Base addChild(String name) throws FHIRException {
2296        if (name.equals("link")) {
2297          return addLink();
2298        }
2299        else if (name.equals("capability")) {
2300          return addCapability();
2301        }
2302        else
2303          return super.addChild(name);
2304      }
2305
2306      public TestScriptMetadataComponent copy() {
2307        TestScriptMetadataComponent dst = new TestScriptMetadataComponent();
2308        copyValues(dst);
2309        return dst;
2310      }
2311
2312      public void copyValues(TestScriptMetadataComponent dst) {
2313        super.copyValues(dst);
2314        if (link != null) {
2315          dst.link = new ArrayList<TestScriptMetadataLinkComponent>();
2316          for (TestScriptMetadataLinkComponent i : link)
2317            dst.link.add(i.copy());
2318        };
2319        if (capability != null) {
2320          dst.capability = new ArrayList<TestScriptMetadataCapabilityComponent>();
2321          for (TestScriptMetadataCapabilityComponent i : capability)
2322            dst.capability.add(i.copy());
2323        };
2324      }
2325
2326      @Override
2327      public boolean equalsDeep(Base other_) {
2328        if (!super.equalsDeep(other_))
2329          return false;
2330        if (!(other_ instanceof TestScriptMetadataComponent))
2331          return false;
2332        TestScriptMetadataComponent o = (TestScriptMetadataComponent) other_;
2333        return compareDeep(link, o.link, true) && compareDeep(capability, o.capability, true);
2334      }
2335
2336      @Override
2337      public boolean equalsShallow(Base other_) {
2338        if (!super.equalsShallow(other_))
2339          return false;
2340        if (!(other_ instanceof TestScriptMetadataComponent))
2341          return false;
2342        TestScriptMetadataComponent o = (TestScriptMetadataComponent) other_;
2343        return true;
2344      }
2345
2346      public boolean isEmpty() {
2347        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(link, capability);
2348      }
2349
2350  public String fhirType() {
2351    return "TestScript.metadata";
2352
2353  }
2354
2355  }
2356
2357    @Block()
2358    public static class TestScriptMetadataLinkComponent extends BackboneElement implements IBaseBackboneElement {
2359        /**
2360         * URL to a particular requirement or feature within the FHIR specification.
2361         */
2362        @Child(name = "url", type = {UriType.class}, order=1, min=1, max=1, modifier=false, summary=false)
2363        @Description(shortDefinition="URL to the specification", formalDefinition="URL to a particular requirement or feature within the FHIR specification." )
2364        protected UriType url;
2365
2366        /**
2367         * Short description of the link.
2368         */
2369        @Child(name = "description", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=false)
2370        @Description(shortDefinition="Short description", formalDefinition="Short description of the link." )
2371        protected StringType description;
2372
2373        private static final long serialVersionUID = 213372298L;
2374
2375    /**
2376     * Constructor
2377     */
2378      public TestScriptMetadataLinkComponent() {
2379        super();
2380      }
2381
2382    /**
2383     * Constructor
2384     */
2385      public TestScriptMetadataLinkComponent(String url) {
2386        super();
2387        this.setUrl(url);
2388      }
2389
2390        /**
2391         * @return {@link #url} (URL to a particular requirement or feature within the FHIR specification.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
2392         */
2393        public UriType getUrlElement() { 
2394          if (this.url == null)
2395            if (Configuration.errorOnAutoCreate())
2396              throw new Error("Attempt to auto-create TestScriptMetadataLinkComponent.url");
2397            else if (Configuration.doAutoCreate())
2398              this.url = new UriType(); // bb
2399          return this.url;
2400        }
2401
2402        public boolean hasUrlElement() { 
2403          return this.url != null && !this.url.isEmpty();
2404        }
2405
2406        public boolean hasUrl() { 
2407          return this.url != null && !this.url.isEmpty();
2408        }
2409
2410        /**
2411         * @param value {@link #url} (URL to a particular requirement or feature within the FHIR specification.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
2412         */
2413        public TestScriptMetadataLinkComponent setUrlElement(UriType value) { 
2414          this.url = value;
2415          return this;
2416        }
2417
2418        /**
2419         * @return URL to a particular requirement or feature within the FHIR specification.
2420         */
2421        public String getUrl() { 
2422          return this.url == null ? null : this.url.getValue();
2423        }
2424
2425        /**
2426         * @param value URL to a particular requirement or feature within the FHIR specification.
2427         */
2428        public TestScriptMetadataLinkComponent setUrl(String value) { 
2429            if (this.url == null)
2430              this.url = new UriType();
2431            this.url.setValue(value);
2432          return this;
2433        }
2434
2435        /**
2436         * @return {@link #description} (Short description of the link.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
2437         */
2438        public StringType getDescriptionElement() { 
2439          if (this.description == null)
2440            if (Configuration.errorOnAutoCreate())
2441              throw new Error("Attempt to auto-create TestScriptMetadataLinkComponent.description");
2442            else if (Configuration.doAutoCreate())
2443              this.description = new StringType(); // bb
2444          return this.description;
2445        }
2446
2447        public boolean hasDescriptionElement() { 
2448          return this.description != null && !this.description.isEmpty();
2449        }
2450
2451        public boolean hasDescription() { 
2452          return this.description != null && !this.description.isEmpty();
2453        }
2454
2455        /**
2456         * @param value {@link #description} (Short description of the link.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
2457         */
2458        public TestScriptMetadataLinkComponent setDescriptionElement(StringType value) { 
2459          this.description = value;
2460          return this;
2461        }
2462
2463        /**
2464         * @return Short description of the link.
2465         */
2466        public String getDescription() { 
2467          return this.description == null ? null : this.description.getValue();
2468        }
2469
2470        /**
2471         * @param value Short description of the link.
2472         */
2473        public TestScriptMetadataLinkComponent setDescription(String value) { 
2474          if (Utilities.noString(value))
2475            this.description = null;
2476          else {
2477            if (this.description == null)
2478              this.description = new StringType();
2479            this.description.setValue(value);
2480          }
2481          return this;
2482        }
2483
2484        protected void listChildren(List<Property> children) {
2485          super.listChildren(children);
2486          children.add(new Property("url", "uri", "URL to a particular requirement or feature within the FHIR specification.", 0, 1, url));
2487          children.add(new Property("description", "string", "Short description of the link.", 0, 1, description));
2488        }
2489
2490        @Override
2491        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2492          switch (_hash) {
2493          case 116079: /*url*/  return new Property("url", "uri", "URL to a particular requirement or feature within the FHIR specification.", 0, 1, url);
2494          case -1724546052: /*description*/  return new Property("description", "string", "Short description of the link.", 0, 1, description);
2495          default: return super.getNamedProperty(_hash, _name, _checkValid);
2496          }
2497
2498        }
2499
2500      @Override
2501      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2502        switch (hash) {
2503        case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType
2504        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType
2505        default: return super.getProperty(hash, name, checkValid);
2506        }
2507
2508      }
2509
2510      @Override
2511      public Base setProperty(int hash, String name, Base value) throws FHIRException {
2512        switch (hash) {
2513        case 116079: // url
2514          this.url = TypeConvertor.castToUri(value); // UriType
2515          return value;
2516        case -1724546052: // description
2517          this.description = TypeConvertor.castToString(value); // StringType
2518          return value;
2519        default: return super.setProperty(hash, name, value);
2520        }
2521
2522      }
2523
2524      @Override
2525      public Base setProperty(String name, Base value) throws FHIRException {
2526        if (name.equals("url")) {
2527          this.url = TypeConvertor.castToUri(value); // UriType
2528        } else if (name.equals("description")) {
2529          this.description = TypeConvertor.castToString(value); // StringType
2530        } else
2531          return super.setProperty(name, value);
2532        return value;
2533      }
2534
2535      @Override
2536      public Base makeProperty(int hash, String name) throws FHIRException {
2537        switch (hash) {
2538        case 116079:  return getUrlElement();
2539        case -1724546052:  return getDescriptionElement();
2540        default: return super.makeProperty(hash, name);
2541        }
2542
2543      }
2544
2545      @Override
2546      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2547        switch (hash) {
2548        case 116079: /*url*/ return new String[] {"uri"};
2549        case -1724546052: /*description*/ return new String[] {"string"};
2550        default: return super.getTypesForProperty(hash, name);
2551        }
2552
2553      }
2554
2555      @Override
2556      public Base addChild(String name) throws FHIRException {
2557        if (name.equals("url")) {
2558          throw new FHIRException("Cannot call addChild on a singleton property TestScript.metadata.link.url");
2559        }
2560        else if (name.equals("description")) {
2561          throw new FHIRException("Cannot call addChild on a singleton property TestScript.metadata.link.description");
2562        }
2563        else
2564          return super.addChild(name);
2565      }
2566
2567      public TestScriptMetadataLinkComponent copy() {
2568        TestScriptMetadataLinkComponent dst = new TestScriptMetadataLinkComponent();
2569        copyValues(dst);
2570        return dst;
2571      }
2572
2573      public void copyValues(TestScriptMetadataLinkComponent dst) {
2574        super.copyValues(dst);
2575        dst.url = url == null ? null : url.copy();
2576        dst.description = description == null ? null : description.copy();
2577      }
2578
2579      @Override
2580      public boolean equalsDeep(Base other_) {
2581        if (!super.equalsDeep(other_))
2582          return false;
2583        if (!(other_ instanceof TestScriptMetadataLinkComponent))
2584          return false;
2585        TestScriptMetadataLinkComponent o = (TestScriptMetadataLinkComponent) other_;
2586        return compareDeep(url, o.url, true) && compareDeep(description, o.description, true);
2587      }
2588
2589      @Override
2590      public boolean equalsShallow(Base other_) {
2591        if (!super.equalsShallow(other_))
2592          return false;
2593        if (!(other_ instanceof TestScriptMetadataLinkComponent))
2594          return false;
2595        TestScriptMetadataLinkComponent o = (TestScriptMetadataLinkComponent) other_;
2596        return compareValues(url, o.url, true) && compareValues(description, o.description, true);
2597      }
2598
2599      public boolean isEmpty() {
2600        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(url, description);
2601      }
2602
2603  public String fhirType() {
2604    return "TestScript.metadata.link";
2605
2606  }
2607
2608  }
2609
2610    @Block()
2611    public static class TestScriptMetadataCapabilityComponent extends BackboneElement implements IBaseBackboneElement {
2612        /**
2613         * Whether or not the test execution will require the given capabilities of the server in order for this test script to execute.
2614         */
2615        @Child(name = "required", type = {BooleanType.class}, order=1, min=1, max=1, modifier=false, summary=false)
2616        @Description(shortDefinition="Are the capabilities required?", formalDefinition="Whether or not the test execution will require the given capabilities of the server in order for this test script to execute." )
2617        protected BooleanType required;
2618
2619        /**
2620         * Whether or not the test execution will validate the given capabilities of the server in order for this test script to execute.
2621         */
2622        @Child(name = "validated", type = {BooleanType.class}, order=2, min=1, max=1, modifier=false, summary=false)
2623        @Description(shortDefinition="Are the capabilities validated?", formalDefinition="Whether or not the test execution will validate the given capabilities of the server in order for this test script to execute." )
2624        protected BooleanType validated;
2625
2626        /**
2627         * Description of the capabilities that this test script is requiring the server to support.
2628         */
2629        @Child(name = "description", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=false)
2630        @Description(shortDefinition="The expected capabilities of the server", formalDefinition="Description of the capabilities that this test script is requiring the server to support." )
2631        protected StringType description;
2632
2633        /**
2634         * Which origin server these requirements apply to.
2635         */
2636        @Child(name = "origin", type = {IntegerType.class}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2637        @Description(shortDefinition="Which origin server these requirements apply to", formalDefinition="Which origin server these requirements apply to." )
2638        protected List<IntegerType> origin;
2639
2640        /**
2641         * Which server these requirements apply to.
2642         */
2643        @Child(name = "destination", type = {IntegerType.class}, order=5, min=0, max=1, modifier=false, summary=false)
2644        @Description(shortDefinition="Which server these requirements apply to", formalDefinition="Which server these requirements apply to." )
2645        protected IntegerType destination;
2646
2647        /**
2648         * Links to the FHIR specification that describes this interaction and the resources involved in more detail.
2649         */
2650        @Child(name = "link", type = {UriType.class}, order=6, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
2651        @Description(shortDefinition="Links to the FHIR specification", formalDefinition="Links to the FHIR specification that describes this interaction and the resources involved in more detail." )
2652        protected List<UriType> link;
2653
2654        /**
2655         * Minimum capabilities required of server for test script to execute successfully.   If server does not meet at a minimum the referenced capability statement, then all tests in this script are skipped.
2656         */
2657        @Child(name = "capabilities", type = {CanonicalType.class}, order=7, min=1, max=1, modifier=false, summary=false)
2658        @Description(shortDefinition="Required Capability Statement", formalDefinition="Minimum capabilities required of server for test script to execute successfully.   If server does not meet at a minimum the referenced capability statement, then all tests in this script are skipped." )
2659        protected CanonicalType capabilities;
2660
2661        private static final long serialVersionUID = -1368199288L;
2662
2663    /**
2664     * Constructor
2665     */
2666      public TestScriptMetadataCapabilityComponent() {
2667        super();
2668      }
2669
2670    /**
2671     * Constructor
2672     */
2673      public TestScriptMetadataCapabilityComponent(boolean required, boolean validated, String capabilities) {
2674        super();
2675        this.setRequired(required);
2676        this.setValidated(validated);
2677        this.setCapabilities(capabilities);
2678      }
2679
2680        /**
2681         * @return {@link #required} (Whether or not the test execution will require the given capabilities of the server in order for this test script to execute.). This is the underlying object with id, value and extensions. The accessor "getRequired" gives direct access to the value
2682         */
2683        public BooleanType getRequiredElement() { 
2684          if (this.required == null)
2685            if (Configuration.errorOnAutoCreate())
2686              throw new Error("Attempt to auto-create TestScriptMetadataCapabilityComponent.required");
2687            else if (Configuration.doAutoCreate())
2688              this.required = new BooleanType(); // bb
2689          return this.required;
2690        }
2691
2692        public boolean hasRequiredElement() { 
2693          return this.required != null && !this.required.isEmpty();
2694        }
2695
2696        public boolean hasRequired() { 
2697          return this.required != null && !this.required.isEmpty();
2698        }
2699
2700        /**
2701         * @param value {@link #required} (Whether or not the test execution will require the given capabilities of the server in order for this test script to execute.). This is the underlying object with id, value and extensions. The accessor "getRequired" gives direct access to the value
2702         */
2703        public TestScriptMetadataCapabilityComponent setRequiredElement(BooleanType value) { 
2704          this.required = value;
2705          return this;
2706        }
2707
2708        /**
2709         * @return Whether or not the test execution will require the given capabilities of the server in order for this test script to execute.
2710         */
2711        public boolean getRequired() { 
2712          return this.required == null || this.required.isEmpty() ? false : this.required.getValue();
2713        }
2714
2715        /**
2716         * @param value Whether or not the test execution will require the given capabilities of the server in order for this test script to execute.
2717         */
2718        public TestScriptMetadataCapabilityComponent setRequired(boolean value) { 
2719            if (this.required == null)
2720              this.required = new BooleanType();
2721            this.required.setValue(value);
2722          return this;
2723        }
2724
2725        /**
2726         * @return {@link #validated} (Whether or not the test execution will validate the given capabilities of the server in order for this test script to execute.). This is the underlying object with id, value and extensions. The accessor "getValidated" gives direct access to the value
2727         */
2728        public BooleanType getValidatedElement() { 
2729          if (this.validated == null)
2730            if (Configuration.errorOnAutoCreate())
2731              throw new Error("Attempt to auto-create TestScriptMetadataCapabilityComponent.validated");
2732            else if (Configuration.doAutoCreate())
2733              this.validated = new BooleanType(); // bb
2734          return this.validated;
2735        }
2736
2737        public boolean hasValidatedElement() { 
2738          return this.validated != null && !this.validated.isEmpty();
2739        }
2740
2741        public boolean hasValidated() { 
2742          return this.validated != null && !this.validated.isEmpty();
2743        }
2744
2745        /**
2746         * @param value {@link #validated} (Whether or not the test execution will validate the given capabilities of the server in order for this test script to execute.). This is the underlying object with id, value and extensions. The accessor "getValidated" gives direct access to the value
2747         */
2748        public TestScriptMetadataCapabilityComponent setValidatedElement(BooleanType value) { 
2749          this.validated = value;
2750          return this;
2751        }
2752
2753        /**
2754         * @return Whether or not the test execution will validate the given capabilities of the server in order for this test script to execute.
2755         */
2756        public boolean getValidated() { 
2757          return this.validated == null || this.validated.isEmpty() ? false : this.validated.getValue();
2758        }
2759
2760        /**
2761         * @param value Whether or not the test execution will validate the given capabilities of the server in order for this test script to execute.
2762         */
2763        public TestScriptMetadataCapabilityComponent setValidated(boolean value) { 
2764            if (this.validated == null)
2765              this.validated = new BooleanType();
2766            this.validated.setValue(value);
2767          return this;
2768        }
2769
2770        /**
2771         * @return {@link #description} (Description of the capabilities that this test script is requiring the server to support.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
2772         */
2773        public StringType getDescriptionElement() { 
2774          if (this.description == null)
2775            if (Configuration.errorOnAutoCreate())
2776              throw new Error("Attempt to auto-create TestScriptMetadataCapabilityComponent.description");
2777            else if (Configuration.doAutoCreate())
2778              this.description = new StringType(); // bb
2779          return this.description;
2780        }
2781
2782        public boolean hasDescriptionElement() { 
2783          return this.description != null && !this.description.isEmpty();
2784        }
2785
2786        public boolean hasDescription() { 
2787          return this.description != null && !this.description.isEmpty();
2788        }
2789
2790        /**
2791         * @param value {@link #description} (Description of the capabilities that this test script is requiring the server to support.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
2792         */
2793        public TestScriptMetadataCapabilityComponent setDescriptionElement(StringType value) { 
2794          this.description = value;
2795          return this;
2796        }
2797
2798        /**
2799         * @return Description of the capabilities that this test script is requiring the server to support.
2800         */
2801        public String getDescription() { 
2802          return this.description == null ? null : this.description.getValue();
2803        }
2804
2805        /**
2806         * @param value Description of the capabilities that this test script is requiring the server to support.
2807         */
2808        public TestScriptMetadataCapabilityComponent setDescription(String value) { 
2809          if (Utilities.noString(value))
2810            this.description = null;
2811          else {
2812            if (this.description == null)
2813              this.description = new StringType();
2814            this.description.setValue(value);
2815          }
2816          return this;
2817        }
2818
2819        /**
2820         * @return {@link #origin} (Which origin server these requirements apply to.)
2821         */
2822        public List<IntegerType> getOrigin() { 
2823          if (this.origin == null)
2824            this.origin = new ArrayList<IntegerType>();
2825          return this.origin;
2826        }
2827
2828        /**
2829         * @return Returns a reference to <code>this</code> for easy method chaining
2830         */
2831        public TestScriptMetadataCapabilityComponent setOrigin(List<IntegerType> theOrigin) { 
2832          this.origin = theOrigin;
2833          return this;
2834        }
2835
2836        public boolean hasOrigin() { 
2837          if (this.origin == null)
2838            return false;
2839          for (IntegerType item : this.origin)
2840            if (!item.isEmpty())
2841              return true;
2842          return false;
2843        }
2844
2845        /**
2846         * @return {@link #origin} (Which origin server these requirements apply to.)
2847         */
2848        public IntegerType addOriginElement() {//2 
2849          IntegerType t = new IntegerType();
2850          if (this.origin == null)
2851            this.origin = new ArrayList<IntegerType>();
2852          this.origin.add(t);
2853          return t;
2854        }
2855
2856        /**
2857         * @param value {@link #origin} (Which origin server these requirements apply to.)
2858         */
2859        public TestScriptMetadataCapabilityComponent addOrigin(int value) { //1
2860          IntegerType t = new IntegerType();
2861          t.setValue(value);
2862          if (this.origin == null)
2863            this.origin = new ArrayList<IntegerType>();
2864          this.origin.add(t);
2865          return this;
2866        }
2867
2868        /**
2869         * @param value {@link #origin} (Which origin server these requirements apply to.)
2870         */
2871        public boolean hasOrigin(int value) { 
2872          if (this.origin == null)
2873            return false;
2874          for (IntegerType v : this.origin)
2875            if (v.getValue().equals(value)) // integer
2876              return true;
2877          return false;
2878        }
2879
2880        /**
2881         * @return {@link #destination} (Which server these requirements apply to.). This is the underlying object with id, value and extensions. The accessor "getDestination" gives direct access to the value
2882         */
2883        public IntegerType getDestinationElement() { 
2884          if (this.destination == null)
2885            if (Configuration.errorOnAutoCreate())
2886              throw new Error("Attempt to auto-create TestScriptMetadataCapabilityComponent.destination");
2887            else if (Configuration.doAutoCreate())
2888              this.destination = new IntegerType(); // bb
2889          return this.destination;
2890        }
2891
2892        public boolean hasDestinationElement() { 
2893          return this.destination != null && !this.destination.isEmpty();
2894        }
2895
2896        public boolean hasDestination() { 
2897          return this.destination != null && !this.destination.isEmpty();
2898        }
2899
2900        /**
2901         * @param value {@link #destination} (Which server these requirements apply to.). This is the underlying object with id, value and extensions. The accessor "getDestination" gives direct access to the value
2902         */
2903        public TestScriptMetadataCapabilityComponent setDestinationElement(IntegerType value) { 
2904          this.destination = value;
2905          return this;
2906        }
2907
2908        /**
2909         * @return Which server these requirements apply to.
2910         */
2911        public int getDestination() { 
2912          return this.destination == null || this.destination.isEmpty() ? 0 : this.destination.getValue();
2913        }
2914
2915        /**
2916         * @param value Which server these requirements apply to.
2917         */
2918        public TestScriptMetadataCapabilityComponent setDestination(int value) { 
2919            if (this.destination == null)
2920              this.destination = new IntegerType();
2921            this.destination.setValue(value);
2922          return this;
2923        }
2924
2925        /**
2926         * @return {@link #link} (Links to the FHIR specification that describes this interaction and the resources involved in more detail.)
2927         */
2928        public List<UriType> getLink() { 
2929          if (this.link == null)
2930            this.link = new ArrayList<UriType>();
2931          return this.link;
2932        }
2933
2934        /**
2935         * @return Returns a reference to <code>this</code> for easy method chaining
2936         */
2937        public TestScriptMetadataCapabilityComponent setLink(List<UriType> theLink) { 
2938          this.link = theLink;
2939          return this;
2940        }
2941
2942        public boolean hasLink() { 
2943          if (this.link == null)
2944            return false;
2945          for (UriType item : this.link)
2946            if (!item.isEmpty())
2947              return true;
2948          return false;
2949        }
2950
2951        /**
2952         * @return {@link #link} (Links to the FHIR specification that describes this interaction and the resources involved in more detail.)
2953         */
2954        public UriType addLinkElement() {//2 
2955          UriType t = new UriType();
2956          if (this.link == null)
2957            this.link = new ArrayList<UriType>();
2958          this.link.add(t);
2959          return t;
2960        }
2961
2962        /**
2963         * @param value {@link #link} (Links to the FHIR specification that describes this interaction and the resources involved in more detail.)
2964         */
2965        public TestScriptMetadataCapabilityComponent addLink(String value) { //1
2966          UriType t = new UriType();
2967          t.setValue(value);
2968          if (this.link == null)
2969            this.link = new ArrayList<UriType>();
2970          this.link.add(t);
2971          return this;
2972        }
2973
2974        /**
2975         * @param value {@link #link} (Links to the FHIR specification that describes this interaction and the resources involved in more detail.)
2976         */
2977        public boolean hasLink(String value) { 
2978          if (this.link == null)
2979            return false;
2980          for (UriType v : this.link)
2981            if (v.getValue().equals(value)) // uri
2982              return true;
2983          return false;
2984        }
2985
2986        /**
2987         * @return {@link #capabilities} (Minimum capabilities required of server for test script to execute successfully.   If server does not meet at a minimum the referenced capability statement, then all tests in this script are skipped.). This is the underlying object with id, value and extensions. The accessor "getCapabilities" gives direct access to the value
2988         */
2989        public CanonicalType getCapabilitiesElement() { 
2990          if (this.capabilities == null)
2991            if (Configuration.errorOnAutoCreate())
2992              throw new Error("Attempt to auto-create TestScriptMetadataCapabilityComponent.capabilities");
2993            else if (Configuration.doAutoCreate())
2994              this.capabilities = new CanonicalType(); // bb
2995          return this.capabilities;
2996        }
2997
2998        public boolean hasCapabilitiesElement() { 
2999          return this.capabilities != null && !this.capabilities.isEmpty();
3000        }
3001
3002        public boolean hasCapabilities() { 
3003          return this.capabilities != null && !this.capabilities.isEmpty();
3004        }
3005
3006        /**
3007         * @param value {@link #capabilities} (Minimum capabilities required of server for test script to execute successfully.   If server does not meet at a minimum the referenced capability statement, then all tests in this script are skipped.). This is the underlying object with id, value and extensions. The accessor "getCapabilities" gives direct access to the value
3008         */
3009        public TestScriptMetadataCapabilityComponent setCapabilitiesElement(CanonicalType value) { 
3010          this.capabilities = value;
3011          return this;
3012        }
3013
3014        /**
3015         * @return Minimum capabilities required of server for test script to execute successfully.   If server does not meet at a minimum the referenced capability statement, then all tests in this script are skipped.
3016         */
3017        public String getCapabilities() { 
3018          return this.capabilities == null ? null : this.capabilities.getValue();
3019        }
3020
3021        /**
3022         * @param value Minimum capabilities required of server for test script to execute successfully.   If server does not meet at a minimum the referenced capability statement, then all tests in this script are skipped.
3023         */
3024        public TestScriptMetadataCapabilityComponent setCapabilities(String value) { 
3025            if (this.capabilities == null)
3026              this.capabilities = new CanonicalType();
3027            this.capabilities.setValue(value);
3028          return this;
3029        }
3030
3031        protected void listChildren(List<Property> children) {
3032          super.listChildren(children);
3033          children.add(new Property("required", "boolean", "Whether or not the test execution will require the given capabilities of the server in order for this test script to execute.", 0, 1, required));
3034          children.add(new Property("validated", "boolean", "Whether or not the test execution will validate the given capabilities of the server in order for this test script to execute.", 0, 1, validated));
3035          children.add(new Property("description", "string", "Description of the capabilities that this test script is requiring the server to support.", 0, 1, description));
3036          children.add(new Property("origin", "integer", "Which origin server these requirements apply to.", 0, java.lang.Integer.MAX_VALUE, origin));
3037          children.add(new Property("destination", "integer", "Which server these requirements apply to.", 0, 1, destination));
3038          children.add(new Property("link", "uri", "Links to the FHIR specification that describes this interaction and the resources involved in more detail.", 0, java.lang.Integer.MAX_VALUE, link));
3039          children.add(new Property("capabilities", "canonical(CapabilityStatement)", "Minimum capabilities required of server for test script to execute successfully.   If server does not meet at a minimum the referenced capability statement, then all tests in this script are skipped.", 0, 1, capabilities));
3040        }
3041
3042        @Override
3043        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
3044          switch (_hash) {
3045          case -393139297: /*required*/  return new Property("required", "boolean", "Whether or not the test execution will require the given capabilities of the server in order for this test script to execute.", 0, 1, required);
3046          case -1109784050: /*validated*/  return new Property("validated", "boolean", "Whether or not the test execution will validate the given capabilities of the server in order for this test script to execute.", 0, 1, validated);
3047          case -1724546052: /*description*/  return new Property("description", "string", "Description of the capabilities that this test script is requiring the server to support.", 0, 1, description);
3048          case -1008619738: /*origin*/  return new Property("origin", "integer", "Which origin server these requirements apply to.", 0, java.lang.Integer.MAX_VALUE, origin);
3049          case -1429847026: /*destination*/  return new Property("destination", "integer", "Which server these requirements apply to.", 0, 1, destination);
3050          case 3321850: /*link*/  return new Property("link", "uri", "Links to the FHIR specification that describes this interaction and the resources involved in more detail.", 0, java.lang.Integer.MAX_VALUE, link);
3051          case -1487597642: /*capabilities*/  return new Property("capabilities", "canonical(CapabilityStatement)", "Minimum capabilities required of server for test script to execute successfully.   If server does not meet at a minimum the referenced capability statement, then all tests in this script are skipped.", 0, 1, capabilities);
3052          default: return super.getNamedProperty(_hash, _name, _checkValid);
3053          }
3054
3055        }
3056
3057      @Override
3058      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3059        switch (hash) {
3060        case -393139297: /*required*/ return this.required == null ? new Base[0] : new Base[] {this.required}; // BooleanType
3061        case -1109784050: /*validated*/ return this.validated == null ? new Base[0] : new Base[] {this.validated}; // BooleanType
3062        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType
3063        case -1008619738: /*origin*/ return this.origin == null ? new Base[0] : this.origin.toArray(new Base[this.origin.size()]); // IntegerType
3064        case -1429847026: /*destination*/ return this.destination == null ? new Base[0] : new Base[] {this.destination}; // IntegerType
3065        case 3321850: /*link*/ return this.link == null ? new Base[0] : this.link.toArray(new Base[this.link.size()]); // UriType
3066        case -1487597642: /*capabilities*/ return this.capabilities == null ? new Base[0] : new Base[] {this.capabilities}; // CanonicalType
3067        default: return super.getProperty(hash, name, checkValid);
3068        }
3069
3070      }
3071
3072      @Override
3073      public Base setProperty(int hash, String name, Base value) throws FHIRException {
3074        switch (hash) {
3075        case -393139297: // required
3076          this.required = TypeConvertor.castToBoolean(value); // BooleanType
3077          return value;
3078        case -1109784050: // validated
3079          this.validated = TypeConvertor.castToBoolean(value); // BooleanType
3080          return value;
3081        case -1724546052: // description
3082          this.description = TypeConvertor.castToString(value); // StringType
3083          return value;
3084        case -1008619738: // origin
3085          this.getOrigin().add(TypeConvertor.castToInteger(value)); // IntegerType
3086          return value;
3087        case -1429847026: // destination
3088          this.destination = TypeConvertor.castToInteger(value); // IntegerType
3089          return value;
3090        case 3321850: // link
3091          this.getLink().add(TypeConvertor.castToUri(value)); // UriType
3092          return value;
3093        case -1487597642: // capabilities
3094          this.capabilities = TypeConvertor.castToCanonical(value); // CanonicalType
3095          return value;
3096        default: return super.setProperty(hash, name, value);
3097        }
3098
3099      }
3100
3101      @Override
3102      public Base setProperty(String name, Base value) throws FHIRException {
3103        if (name.equals("required")) {
3104          this.required = TypeConvertor.castToBoolean(value); // BooleanType
3105        } else if (name.equals("validated")) {
3106          this.validated = TypeConvertor.castToBoolean(value); // BooleanType
3107        } else if (name.equals("description")) {
3108          this.description = TypeConvertor.castToString(value); // StringType
3109        } else if (name.equals("origin")) {
3110          this.getOrigin().add(TypeConvertor.castToInteger(value));
3111        } else if (name.equals("destination")) {
3112          this.destination = TypeConvertor.castToInteger(value); // IntegerType
3113        } else if (name.equals("link")) {
3114          this.getLink().add(TypeConvertor.castToUri(value));
3115        } else if (name.equals("capabilities")) {
3116          this.capabilities = TypeConvertor.castToCanonical(value); // CanonicalType
3117        } else
3118          return super.setProperty(name, value);
3119        return value;
3120      }
3121
3122      @Override
3123      public Base makeProperty(int hash, String name) throws FHIRException {
3124        switch (hash) {
3125        case -393139297:  return getRequiredElement();
3126        case -1109784050:  return getValidatedElement();
3127        case -1724546052:  return getDescriptionElement();
3128        case -1008619738:  return addOriginElement();
3129        case -1429847026:  return getDestinationElement();
3130        case 3321850:  return addLinkElement();
3131        case -1487597642:  return getCapabilitiesElement();
3132        default: return super.makeProperty(hash, name);
3133        }
3134
3135      }
3136
3137      @Override
3138      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
3139        switch (hash) {
3140        case -393139297: /*required*/ return new String[] {"boolean"};
3141        case -1109784050: /*validated*/ return new String[] {"boolean"};
3142        case -1724546052: /*description*/ return new String[] {"string"};
3143        case -1008619738: /*origin*/ return new String[] {"integer"};
3144        case -1429847026: /*destination*/ return new String[] {"integer"};
3145        case 3321850: /*link*/ return new String[] {"uri"};
3146        case -1487597642: /*capabilities*/ return new String[] {"canonical"};
3147        default: return super.getTypesForProperty(hash, name);
3148        }
3149
3150      }
3151
3152      @Override
3153      public Base addChild(String name) throws FHIRException {
3154        if (name.equals("required")) {
3155          throw new FHIRException("Cannot call addChild on a singleton property TestScript.metadata.capability.required");
3156        }
3157        else if (name.equals("validated")) {
3158          throw new FHIRException("Cannot call addChild on a singleton property TestScript.metadata.capability.validated");
3159        }
3160        else if (name.equals("description")) {
3161          throw new FHIRException("Cannot call addChild on a singleton property TestScript.metadata.capability.description");
3162        }
3163        else if (name.equals("origin")) {
3164          throw new FHIRException("Cannot call addChild on a singleton property TestScript.metadata.capability.origin");
3165        }
3166        else if (name.equals("destination")) {
3167          throw new FHIRException("Cannot call addChild on a singleton property TestScript.metadata.capability.destination");
3168        }
3169        else if (name.equals("link")) {
3170          throw new FHIRException("Cannot call addChild on a singleton property TestScript.metadata.capability.link");
3171        }
3172        else if (name.equals("capabilities")) {
3173          throw new FHIRException("Cannot call addChild on a singleton property TestScript.metadata.capability.capabilities");
3174        }
3175        else
3176          return super.addChild(name);
3177      }
3178
3179      public TestScriptMetadataCapabilityComponent copy() {
3180        TestScriptMetadataCapabilityComponent dst = new TestScriptMetadataCapabilityComponent();
3181        copyValues(dst);
3182        return dst;
3183      }
3184
3185      public void copyValues(TestScriptMetadataCapabilityComponent dst) {
3186        super.copyValues(dst);
3187        dst.required = required == null ? null : required.copy();
3188        dst.validated = validated == null ? null : validated.copy();
3189        dst.description = description == null ? null : description.copy();
3190        if (origin != null) {
3191          dst.origin = new ArrayList<IntegerType>();
3192          for (IntegerType i : origin)
3193            dst.origin.add(i.copy());
3194        };
3195        dst.destination = destination == null ? null : destination.copy();
3196        if (link != null) {
3197          dst.link = new ArrayList<UriType>();
3198          for (UriType i : link)
3199            dst.link.add(i.copy());
3200        };
3201        dst.capabilities = capabilities == null ? null : capabilities.copy();
3202      }
3203
3204      @Override
3205      public boolean equalsDeep(Base other_) {
3206        if (!super.equalsDeep(other_))
3207          return false;
3208        if (!(other_ instanceof TestScriptMetadataCapabilityComponent))
3209          return false;
3210        TestScriptMetadataCapabilityComponent o = (TestScriptMetadataCapabilityComponent) other_;
3211        return compareDeep(required, o.required, true) && compareDeep(validated, o.validated, true) && compareDeep(description, o.description, true)
3212           && compareDeep(origin, o.origin, true) && compareDeep(destination, o.destination, true) && compareDeep(link, o.link, true)
3213           && compareDeep(capabilities, o.capabilities, true);
3214      }
3215
3216      @Override
3217      public boolean equalsShallow(Base other_) {
3218        if (!super.equalsShallow(other_))
3219          return false;
3220        if (!(other_ instanceof TestScriptMetadataCapabilityComponent))
3221          return false;
3222        TestScriptMetadataCapabilityComponent o = (TestScriptMetadataCapabilityComponent) other_;
3223        return compareValues(required, o.required, true) && compareValues(validated, o.validated, true) && compareValues(description, o.description, true)
3224           && compareValues(origin, o.origin, true) && compareValues(destination, o.destination, true) && compareValues(link, o.link, true)
3225           && compareValues(capabilities, o.capabilities, true);
3226      }
3227
3228      public boolean isEmpty() {
3229        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(required, validated, description
3230          , origin, destination, link, capabilities);
3231      }
3232
3233  public String fhirType() {
3234    return "TestScript.metadata.capability";
3235
3236  }
3237
3238  }
3239
3240    @Block()
3241    public static class TestScriptScopeComponent extends BackboneElement implements IBaseBackboneElement {
3242        /**
3243         * The specific conformance artifact being tested. The canonical reference can be version-specific.
3244         */
3245        @Child(name = "artifact", type = {CanonicalType.class}, order=1, min=1, max=1, modifier=false, summary=false)
3246        @Description(shortDefinition="The specific conformance artifact being tested", formalDefinition="The specific conformance artifact being tested. The canonical reference can be version-specific." )
3247        protected CanonicalType artifact;
3248
3249        /**
3250         * The expectation of whether the test must pass for the system to be considered conformant with the artifact: required - all tests are expected to pass, optional - all test are expected to pass but non-pass status may be allowed, strict - all tests are expected to pass and warnings are treated as a failure.
3251         */
3252        @Child(name = "conformance", type = {CodeableConcept.class}, order=2, min=0, max=1, modifier=false, summary=false)
3253        @Description(shortDefinition="required | optional | strict", formalDefinition="The expectation of whether the test must pass for the system to be considered conformant with the artifact: required - all tests are expected to pass, optional - all test are expected to pass but non-pass status may be allowed, strict - all tests are expected to pass and warnings are treated as a failure." )
3254        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/testscript-scope-conformance-codes")
3255        protected CodeableConcept conformance;
3256
3257        /**
3258         * The phase of testing for this artifact: unit - development / implementation phase, integration - internal system to system phase, production - live system to system phase (Note, this may involve pii/phi data).
3259         */
3260        @Child(name = "phase", type = {CodeableConcept.class}, order=3, min=0, max=1, modifier=false, summary=false)
3261        @Description(shortDefinition="unit | integration | production", formalDefinition="The phase of testing for this artifact: unit - development / implementation phase, integration - internal system to system phase, production - live system to system phase (Note, this may involve pii/phi data)." )
3262        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/testscript-scope-phase-codes")
3263        protected CodeableConcept phase;
3264
3265        private static final long serialVersionUID = 1236847076L;
3266
3267    /**
3268     * Constructor
3269     */
3270      public TestScriptScopeComponent() {
3271        super();
3272      }
3273
3274    /**
3275     * Constructor
3276     */
3277      public TestScriptScopeComponent(String artifact) {
3278        super();
3279        this.setArtifact(artifact);
3280      }
3281
3282        /**
3283         * @return {@link #artifact} (The specific conformance artifact being tested. The canonical reference can be version-specific.). This is the underlying object with id, value and extensions. The accessor "getArtifact" gives direct access to the value
3284         */
3285        public CanonicalType getArtifactElement() { 
3286          if (this.artifact == null)
3287            if (Configuration.errorOnAutoCreate())
3288              throw new Error("Attempt to auto-create TestScriptScopeComponent.artifact");
3289            else if (Configuration.doAutoCreate())
3290              this.artifact = new CanonicalType(); // bb
3291          return this.artifact;
3292        }
3293
3294        public boolean hasArtifactElement() { 
3295          return this.artifact != null && !this.artifact.isEmpty();
3296        }
3297
3298        public boolean hasArtifact() { 
3299          return this.artifact != null && !this.artifact.isEmpty();
3300        }
3301
3302        /**
3303         * @param value {@link #artifact} (The specific conformance artifact being tested. The canonical reference can be version-specific.). This is the underlying object with id, value and extensions. The accessor "getArtifact" gives direct access to the value
3304         */
3305        public TestScriptScopeComponent setArtifactElement(CanonicalType value) { 
3306          this.artifact = value;
3307          return this;
3308        }
3309
3310        /**
3311         * @return The specific conformance artifact being tested. The canonical reference can be version-specific.
3312         */
3313        public String getArtifact() { 
3314          return this.artifact == null ? null : this.artifact.getValue();
3315        }
3316
3317        /**
3318         * @param value The specific conformance artifact being tested. The canonical reference can be version-specific.
3319         */
3320        public TestScriptScopeComponent setArtifact(String value) { 
3321            if (this.artifact == null)
3322              this.artifact = new CanonicalType();
3323            this.artifact.setValue(value);
3324          return this;
3325        }
3326
3327        /**
3328         * @return {@link #conformance} (The expectation of whether the test must pass for the system to be considered conformant with the artifact: required - all tests are expected to pass, optional - all test are expected to pass but non-pass status may be allowed, strict - all tests are expected to pass and warnings are treated as a failure.)
3329         */
3330        public CodeableConcept getConformance() { 
3331          if (this.conformance == null)
3332            if (Configuration.errorOnAutoCreate())
3333              throw new Error("Attempt to auto-create TestScriptScopeComponent.conformance");
3334            else if (Configuration.doAutoCreate())
3335              this.conformance = new CodeableConcept(); // cc
3336          return this.conformance;
3337        }
3338
3339        public boolean hasConformance() { 
3340          return this.conformance != null && !this.conformance.isEmpty();
3341        }
3342
3343        /**
3344         * @param value {@link #conformance} (The expectation of whether the test must pass for the system to be considered conformant with the artifact: required - all tests are expected to pass, optional - all test are expected to pass but non-pass status may be allowed, strict - all tests are expected to pass and warnings are treated as a failure.)
3345         */
3346        public TestScriptScopeComponent setConformance(CodeableConcept value) { 
3347          this.conformance = value;
3348          return this;
3349        }
3350
3351        /**
3352         * @return {@link #phase} (The phase of testing for this artifact: unit - development / implementation phase, integration - internal system to system phase, production - live system to system phase (Note, this may involve pii/phi data).)
3353         */
3354        public CodeableConcept getPhase() { 
3355          if (this.phase == null)
3356            if (Configuration.errorOnAutoCreate())
3357              throw new Error("Attempt to auto-create TestScriptScopeComponent.phase");
3358            else if (Configuration.doAutoCreate())
3359              this.phase = new CodeableConcept(); // cc
3360          return this.phase;
3361        }
3362
3363        public boolean hasPhase() { 
3364          return this.phase != null && !this.phase.isEmpty();
3365        }
3366
3367        /**
3368         * @param value {@link #phase} (The phase of testing for this artifact: unit - development / implementation phase, integration - internal system to system phase, production - live system to system phase (Note, this may involve pii/phi data).)
3369         */
3370        public TestScriptScopeComponent setPhase(CodeableConcept value) { 
3371          this.phase = value;
3372          return this;
3373        }
3374
3375        protected void listChildren(List<Property> children) {
3376          super.listChildren(children);
3377          children.add(new Property("artifact", "canonical(Any)", "The specific conformance artifact being tested. The canonical reference can be version-specific.", 0, 1, artifact));
3378          children.add(new Property("conformance", "CodeableConcept", "The expectation of whether the test must pass for the system to be considered conformant with the artifact: required - all tests are expected to pass, optional - all test are expected to pass but non-pass status may be allowed, strict - all tests are expected to pass and warnings are treated as a failure.", 0, 1, conformance));
3379          children.add(new Property("phase", "CodeableConcept", "The phase of testing for this artifact: unit - development / implementation phase, integration - internal system to system phase, production - live system to system phase (Note, this may involve pii/phi data).", 0, 1, phase));
3380        }
3381
3382        @Override
3383        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
3384          switch (_hash) {
3385          case -1228798510: /*artifact*/  return new Property("artifact", "canonical(Any)", "The specific conformance artifact being tested. The canonical reference can be version-specific.", 0, 1, artifact);
3386          case 1374858133: /*conformance*/  return new Property("conformance", "CodeableConcept", "The expectation of whether the test must pass for the system to be considered conformant with the artifact: required - all tests are expected to pass, optional - all test are expected to pass but non-pass status may be allowed, strict - all tests are expected to pass and warnings are treated as a failure.", 0, 1, conformance);
3387          case 106629499: /*phase*/  return new Property("phase", "CodeableConcept", "The phase of testing for this artifact: unit - development / implementation phase, integration - internal system to system phase, production - live system to system phase (Note, this may involve pii/phi data).", 0, 1, phase);
3388          default: return super.getNamedProperty(_hash, _name, _checkValid);
3389          }
3390
3391        }
3392
3393      @Override
3394      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3395        switch (hash) {
3396        case -1228798510: /*artifact*/ return this.artifact == null ? new Base[0] : new Base[] {this.artifact}; // CanonicalType
3397        case 1374858133: /*conformance*/ return this.conformance == null ? new Base[0] : new Base[] {this.conformance}; // CodeableConcept
3398        case 106629499: /*phase*/ return this.phase == null ? new Base[0] : new Base[] {this.phase}; // CodeableConcept
3399        default: return super.getProperty(hash, name, checkValid);
3400        }
3401
3402      }
3403
3404      @Override
3405      public Base setProperty(int hash, String name, Base value) throws FHIRException {
3406        switch (hash) {
3407        case -1228798510: // artifact
3408          this.artifact = TypeConvertor.castToCanonical(value); // CanonicalType
3409          return value;
3410        case 1374858133: // conformance
3411          this.conformance = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
3412          return value;
3413        case 106629499: // phase
3414          this.phase = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
3415          return value;
3416        default: return super.setProperty(hash, name, value);
3417        }
3418
3419      }
3420
3421      @Override
3422      public Base setProperty(String name, Base value) throws FHIRException {
3423        if (name.equals("artifact")) {
3424          this.artifact = TypeConvertor.castToCanonical(value); // CanonicalType
3425        } else if (name.equals("conformance")) {
3426          this.conformance = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
3427        } else if (name.equals("phase")) {
3428          this.phase = TypeConvertor.castToCodeableConcept(value); // CodeableConcept
3429        } else
3430          return super.setProperty(name, value);
3431        return value;
3432      }
3433
3434      @Override
3435      public Base makeProperty(int hash, String name) throws FHIRException {
3436        switch (hash) {
3437        case -1228798510:  return getArtifactElement();
3438        case 1374858133:  return getConformance();
3439        case 106629499:  return getPhase();
3440        default: return super.makeProperty(hash, name);
3441        }
3442
3443      }
3444
3445      @Override
3446      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
3447        switch (hash) {
3448        case -1228798510: /*artifact*/ return new String[] {"canonical"};
3449        case 1374858133: /*conformance*/ return new String[] {"CodeableConcept"};
3450        case 106629499: /*phase*/ return new String[] {"CodeableConcept"};
3451        default: return super.getTypesForProperty(hash, name);
3452        }
3453
3454      }
3455
3456      @Override
3457      public Base addChild(String name) throws FHIRException {
3458        if (name.equals("artifact")) {
3459          throw new FHIRException("Cannot call addChild on a singleton property TestScript.scope.artifact");
3460        }
3461        else if (name.equals("conformance")) {
3462          this.conformance = new CodeableConcept();
3463          return this.conformance;
3464        }
3465        else if (name.equals("phase")) {
3466          this.phase = new CodeableConcept();
3467          return this.phase;
3468        }
3469        else
3470          return super.addChild(name);
3471      }
3472
3473      public TestScriptScopeComponent copy() {
3474        TestScriptScopeComponent dst = new TestScriptScopeComponent();
3475        copyValues(dst);
3476        return dst;
3477      }
3478
3479      public void copyValues(TestScriptScopeComponent dst) {
3480        super.copyValues(dst);
3481        dst.artifact = artifact == null ? null : artifact.copy();
3482        dst.conformance = conformance == null ? null : conformance.copy();
3483        dst.phase = phase == null ? null : phase.copy();
3484      }
3485
3486      @Override
3487      public boolean equalsDeep(Base other_) {
3488        if (!super.equalsDeep(other_))
3489          return false;
3490        if (!(other_ instanceof TestScriptScopeComponent))
3491          return false;
3492        TestScriptScopeComponent o = (TestScriptScopeComponent) other_;
3493        return compareDeep(artifact, o.artifact, true) && compareDeep(conformance, o.conformance, true)
3494           && compareDeep(phase, o.phase, true);
3495      }
3496
3497      @Override
3498      public boolean equalsShallow(Base other_) {
3499        if (!super.equalsShallow(other_))
3500          return false;
3501        if (!(other_ instanceof TestScriptScopeComponent))
3502          return false;
3503        TestScriptScopeComponent o = (TestScriptScopeComponent) other_;
3504        return compareValues(artifact, o.artifact, true);
3505      }
3506
3507      public boolean isEmpty() {
3508        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(artifact, conformance, phase
3509          );
3510      }
3511
3512  public String fhirType() {
3513    return "TestScript.scope";
3514
3515  }
3516
3517  }
3518
3519    @Block()
3520    public static class TestScriptFixtureComponent extends BackboneElement implements IBaseBackboneElement {
3521        /**
3522         * Whether or not to implicitly create the fixture during setup. If true, the fixture is automatically created on each server being tested during setup, therefore no create operation is required for this fixture in the TestScript.setup section.
3523         */
3524        @Child(name = "autocreate", type = {BooleanType.class}, order=1, min=1, max=1, modifier=false, summary=false)
3525        @Description(shortDefinition="Whether or not to implicitly create the fixture during setup", formalDefinition="Whether or not to implicitly create the fixture during setup. If true, the fixture is automatically created on each server being tested during setup, therefore no create operation is required for this fixture in the TestScript.setup section." )
3526        protected BooleanType autocreate;
3527
3528        /**
3529         * Whether or not to implicitly delete the fixture during teardown. If true, the fixture is automatically deleted on each server being tested during teardown, therefore no delete operation is required for this fixture in the TestScript.teardown section.
3530         */
3531        @Child(name = "autodelete", type = {BooleanType.class}, order=2, min=1, max=1, modifier=false, summary=false)
3532        @Description(shortDefinition="Whether or not to implicitly delete the fixture during teardown", formalDefinition="Whether or not to implicitly delete the fixture during teardown. If true, the fixture is automatically deleted on each server being tested during teardown, therefore no delete operation is required for this fixture in the TestScript.teardown section." )
3533        protected BooleanType autodelete;
3534
3535        /**
3536         * Reference to the resource (containing the contents of the resource needed for operations). This is allowed to be a Parameters resource.
3537         */
3538        @Child(name = "resource", type = {Reference.class}, order=3, min=0, max=1, modifier=false, summary=false)
3539        @Description(shortDefinition="Reference of the resource", formalDefinition="Reference to the resource (containing the contents of the resource needed for operations). This is allowed to be a Parameters resource." )
3540        protected Reference resource;
3541
3542        private static final long serialVersionUID = 672117234L;
3543
3544    /**
3545     * Constructor
3546     */
3547      public TestScriptFixtureComponent() {
3548        super();
3549      }
3550
3551    /**
3552     * Constructor
3553     */
3554      public TestScriptFixtureComponent(boolean autocreate, boolean autodelete) {
3555        super();
3556        this.setAutocreate(autocreate);
3557        this.setAutodelete(autodelete);
3558      }
3559
3560        /**
3561         * @return {@link #autocreate} (Whether or not to implicitly create the fixture during setup. If true, the fixture is automatically created on each server being tested during setup, therefore no create operation is required for this fixture in the TestScript.setup section.). This is the underlying object with id, value and extensions. The accessor "getAutocreate" gives direct access to the value
3562         */
3563        public BooleanType getAutocreateElement() { 
3564          if (this.autocreate == null)
3565            if (Configuration.errorOnAutoCreate())
3566              throw new Error("Attempt to auto-create TestScriptFixtureComponent.autocreate");
3567            else if (Configuration.doAutoCreate())
3568              this.autocreate = new BooleanType(); // bb
3569          return this.autocreate;
3570        }
3571
3572        public boolean hasAutocreateElement() { 
3573          return this.autocreate != null && !this.autocreate.isEmpty();
3574        }
3575
3576        public boolean hasAutocreate() { 
3577          return this.autocreate != null && !this.autocreate.isEmpty();
3578        }
3579
3580        /**
3581         * @param value {@link #autocreate} (Whether or not to implicitly create the fixture during setup. If true, the fixture is automatically created on each server being tested during setup, therefore no create operation is required for this fixture in the TestScript.setup section.). This is the underlying object with id, value and extensions. The accessor "getAutocreate" gives direct access to the value
3582         */
3583        public TestScriptFixtureComponent setAutocreateElement(BooleanType value) { 
3584          this.autocreate = value;
3585          return this;
3586        }
3587
3588        /**
3589         * @return Whether or not to implicitly create the fixture during setup. If true, the fixture is automatically created on each server being tested during setup, therefore no create operation is required for this fixture in the TestScript.setup section.
3590         */
3591        public boolean getAutocreate() { 
3592          return this.autocreate == null || this.autocreate.isEmpty() ? false : this.autocreate.getValue();
3593        }
3594
3595        /**
3596         * @param value Whether or not to implicitly create the fixture during setup. If true, the fixture is automatically created on each server being tested during setup, therefore no create operation is required for this fixture in the TestScript.setup section.
3597         */
3598        public TestScriptFixtureComponent setAutocreate(boolean value) { 
3599            if (this.autocreate == null)
3600              this.autocreate = new BooleanType();
3601            this.autocreate.setValue(value);
3602          return this;
3603        }
3604
3605        /**
3606         * @return {@link #autodelete} (Whether or not to implicitly delete the fixture during teardown. If true, the fixture is automatically deleted on each server being tested during teardown, therefore no delete operation is required for this fixture in the TestScript.teardown section.). This is the underlying object with id, value and extensions. The accessor "getAutodelete" gives direct access to the value
3607         */
3608        public BooleanType getAutodeleteElement() { 
3609          if (this.autodelete == null)
3610            if (Configuration.errorOnAutoCreate())
3611              throw new Error("Attempt to auto-create TestScriptFixtureComponent.autodelete");
3612            else if (Configuration.doAutoCreate())
3613              this.autodelete = new BooleanType(); // bb
3614          return this.autodelete;
3615        }
3616
3617        public boolean hasAutodeleteElement() { 
3618          return this.autodelete != null && !this.autodelete.isEmpty();
3619        }
3620
3621        public boolean hasAutodelete() { 
3622          return this.autodelete != null && !this.autodelete.isEmpty();
3623        }
3624
3625        /**
3626         * @param value {@link #autodelete} (Whether or not to implicitly delete the fixture during teardown. If true, the fixture is automatically deleted on each server being tested during teardown, therefore no delete operation is required for this fixture in the TestScript.teardown section.). This is the underlying object with id, value and extensions. The accessor "getAutodelete" gives direct access to the value
3627         */
3628        public TestScriptFixtureComponent setAutodeleteElement(BooleanType value) { 
3629          this.autodelete = value;
3630          return this;
3631        }
3632
3633        /**
3634         * @return Whether or not to implicitly delete the fixture during teardown. If true, the fixture is automatically deleted on each server being tested during teardown, therefore no delete operation is required for this fixture in the TestScript.teardown section.
3635         */
3636        public boolean getAutodelete() { 
3637          return this.autodelete == null || this.autodelete.isEmpty() ? false : this.autodelete.getValue();
3638        }
3639
3640        /**
3641         * @param value Whether or not to implicitly delete the fixture during teardown. If true, the fixture is automatically deleted on each server being tested during teardown, therefore no delete operation is required for this fixture in the TestScript.teardown section.
3642         */
3643        public TestScriptFixtureComponent setAutodelete(boolean value) { 
3644            if (this.autodelete == null)
3645              this.autodelete = new BooleanType();
3646            this.autodelete.setValue(value);
3647          return this;
3648        }
3649
3650        /**
3651         * @return {@link #resource} (Reference to the resource (containing the contents of the resource needed for operations). This is allowed to be a Parameters resource.)
3652         */
3653        public Reference getResource() { 
3654          if (this.resource == null)
3655            if (Configuration.errorOnAutoCreate())
3656              throw new Error("Attempt to auto-create TestScriptFixtureComponent.resource");
3657            else if (Configuration.doAutoCreate())
3658              this.resource = new Reference(); // cc
3659          return this.resource;
3660        }
3661
3662        public boolean hasResource() { 
3663          return this.resource != null && !this.resource.isEmpty();
3664        }
3665
3666        /**
3667         * @param value {@link #resource} (Reference to the resource (containing the contents of the resource needed for operations). This is allowed to be a Parameters resource.)
3668         */
3669        public TestScriptFixtureComponent setResource(Reference value) { 
3670          this.resource = value;
3671          return this;
3672        }
3673
3674        protected void listChildren(List<Property> children) {
3675          super.listChildren(children);
3676          children.add(new Property("autocreate", "boolean", "Whether or not to implicitly create the fixture during setup. If true, the fixture is automatically created on each server being tested during setup, therefore no create operation is required for this fixture in the TestScript.setup section.", 0, 1, autocreate));
3677          children.add(new Property("autodelete", "boolean", "Whether or not to implicitly delete the fixture during teardown. If true, the fixture is automatically deleted on each server being tested during teardown, therefore no delete operation is required for this fixture in the TestScript.teardown section.", 0, 1, autodelete));
3678          children.add(new Property("resource", "Reference(Any)", "Reference to the resource (containing the contents of the resource needed for operations). This is allowed to be a Parameters resource.", 0, 1, resource));
3679        }
3680
3681        @Override
3682        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
3683          switch (_hash) {
3684          case 73154411: /*autocreate*/  return new Property("autocreate", "boolean", "Whether or not to implicitly create the fixture during setup. If true, the fixture is automatically created on each server being tested during setup, therefore no create operation is required for this fixture in the TestScript.setup section.", 0, 1, autocreate);
3685          case 89990170: /*autodelete*/  return new Property("autodelete", "boolean", "Whether or not to implicitly delete the fixture during teardown. If true, the fixture is automatically deleted on each server being tested during teardown, therefore no delete operation is required for this fixture in the TestScript.teardown section.", 0, 1, autodelete);
3686          case -341064690: /*resource*/  return new Property("resource", "Reference(Any)", "Reference to the resource (containing the contents of the resource needed for operations). This is allowed to be a Parameters resource.", 0, 1, resource);
3687          default: return super.getNamedProperty(_hash, _name, _checkValid);
3688          }
3689
3690        }
3691
3692      @Override
3693      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3694        switch (hash) {
3695        case 73154411: /*autocreate*/ return this.autocreate == null ? new Base[0] : new Base[] {this.autocreate}; // BooleanType
3696        case 89990170: /*autodelete*/ return this.autodelete == null ? new Base[0] : new Base[] {this.autodelete}; // BooleanType
3697        case -341064690: /*resource*/ return this.resource == null ? new Base[0] : new Base[] {this.resource}; // Reference
3698        default: return super.getProperty(hash, name, checkValid);
3699        }
3700
3701      }
3702
3703      @Override
3704      public Base setProperty(int hash, String name, Base value) throws FHIRException {
3705        switch (hash) {
3706        case 73154411: // autocreate
3707          this.autocreate = TypeConvertor.castToBoolean(value); // BooleanType
3708          return value;
3709        case 89990170: // autodelete
3710          this.autodelete = TypeConvertor.castToBoolean(value); // BooleanType
3711          return value;
3712        case -341064690: // resource
3713          this.resource = TypeConvertor.castToReference(value); // Reference
3714          return value;
3715        default: return super.setProperty(hash, name, value);
3716        }
3717
3718      }
3719
3720      @Override
3721      public Base setProperty(String name, Base value) throws FHIRException {
3722        if (name.equals("autocreate")) {
3723          this.autocreate = TypeConvertor.castToBoolean(value); // BooleanType
3724        } else if (name.equals("autodelete")) {
3725          this.autodelete = TypeConvertor.castToBoolean(value); // BooleanType
3726        } else if (name.equals("resource")) {
3727          this.resource = TypeConvertor.castToReference(value); // Reference
3728        } else
3729          return super.setProperty(name, value);
3730        return value;
3731      }
3732
3733      @Override
3734      public Base makeProperty(int hash, String name) throws FHIRException {
3735        switch (hash) {
3736        case 73154411:  return getAutocreateElement();
3737        case 89990170:  return getAutodeleteElement();
3738        case -341064690:  return getResource();
3739        default: return super.makeProperty(hash, name);
3740        }
3741
3742      }
3743
3744      @Override
3745      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
3746        switch (hash) {
3747        case 73154411: /*autocreate*/ return new String[] {"boolean"};
3748        case 89990170: /*autodelete*/ return new String[] {"boolean"};
3749        case -341064690: /*resource*/ return new String[] {"Reference"};
3750        default: return super.getTypesForProperty(hash, name);
3751        }
3752
3753      }
3754
3755      @Override
3756      public Base addChild(String name) throws FHIRException {
3757        if (name.equals("autocreate")) {
3758          throw new FHIRException("Cannot call addChild on a singleton property TestScript.fixture.autocreate");
3759        }
3760        else if (name.equals("autodelete")) {
3761          throw new FHIRException("Cannot call addChild on a singleton property TestScript.fixture.autodelete");
3762        }
3763        else if (name.equals("resource")) {
3764          this.resource = new Reference();
3765          return this.resource;
3766        }
3767        else
3768          return super.addChild(name);
3769      }
3770
3771      public TestScriptFixtureComponent copy() {
3772        TestScriptFixtureComponent dst = new TestScriptFixtureComponent();
3773        copyValues(dst);
3774        return dst;
3775      }
3776
3777      public void copyValues(TestScriptFixtureComponent dst) {
3778        super.copyValues(dst);
3779        dst.autocreate = autocreate == null ? null : autocreate.copy();
3780        dst.autodelete = autodelete == null ? null : autodelete.copy();
3781        dst.resource = resource == null ? null : resource.copy();
3782      }
3783
3784      @Override
3785      public boolean equalsDeep(Base other_) {
3786        if (!super.equalsDeep(other_))
3787          return false;
3788        if (!(other_ instanceof TestScriptFixtureComponent))
3789          return false;
3790        TestScriptFixtureComponent o = (TestScriptFixtureComponent) other_;
3791        return compareDeep(autocreate, o.autocreate, true) && compareDeep(autodelete, o.autodelete, true)
3792           && compareDeep(resource, o.resource, true);
3793      }
3794
3795      @Override
3796      public boolean equalsShallow(Base other_) {
3797        if (!super.equalsShallow(other_))
3798          return false;
3799        if (!(other_ instanceof TestScriptFixtureComponent))
3800          return false;
3801        TestScriptFixtureComponent o = (TestScriptFixtureComponent) other_;
3802        return compareValues(autocreate, o.autocreate, true) && compareValues(autodelete, o.autodelete, true)
3803          ;
3804      }
3805
3806      public boolean isEmpty() {
3807        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(autocreate, autodelete, resource
3808          );
3809      }
3810
3811  public String fhirType() {
3812    return "TestScript.fixture";
3813
3814  }
3815
3816  }
3817
3818    @Block()
3819    public static class TestScriptVariableComponent extends BackboneElement implements IBaseBackboneElement {
3820        /**
3821         * Descriptive name for this variable.
3822         */
3823        @Child(name = "name", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=false)
3824        @Description(shortDefinition="Descriptive name for this variable", formalDefinition="Descriptive name for this variable." )
3825        protected StringType name;
3826
3827        /**
3828         * A default, hard-coded, or user-defined value for this variable.
3829         */
3830        @Child(name = "defaultValue", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=false)
3831        @Description(shortDefinition="Default, hard-coded, or user-defined value for this variable", formalDefinition="A default, hard-coded, or user-defined value for this variable." )
3832        protected StringType defaultValue;
3833
3834        /**
3835         * A free text natural language description of the variable and its purpose.
3836         */
3837        @Child(name = "description", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=false)
3838        @Description(shortDefinition="Natural language description of the variable", formalDefinition="A free text natural language description of the variable and its purpose." )
3839        protected StringType description;
3840
3841        /**
3842         * The FHIRPath expression for a specific value to evaluate against the fixture body. When variables are defined, only one of either expression, headerField or path must be specified.
3843         */
3844        @Child(name = "expression", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=false)
3845        @Description(shortDefinition="The FHIRPath expression against the fixture body", formalDefinition="The FHIRPath expression for a specific value to evaluate against the fixture body. When variables are defined, only one of either expression, headerField or path must be specified." )
3846        protected StringType expression;
3847
3848        /**
3849         * Will be used to grab the HTTP header field value from the headers that sourceId is pointing to.
3850         */
3851        @Child(name = "headerField", type = {StringType.class}, order=5, min=0, max=1, modifier=false, summary=false)
3852        @Description(shortDefinition="HTTP header field name for source", formalDefinition="Will be used to grab the HTTP header field value from the headers that sourceId is pointing to." )
3853        protected StringType headerField;
3854
3855        /**
3856         * Displayable text string with hint help information to the user when entering a default value.
3857         */
3858        @Child(name = "hint", type = {StringType.class}, order=6, min=0, max=1, modifier=false, summary=false)
3859        @Description(shortDefinition="Hint help text for default value to enter", formalDefinition="Displayable text string with hint help information to the user when entering a default value." )
3860        protected StringType hint;
3861
3862        /**
3863         * XPath or JSONPath to evaluate against the fixture body.  When variables are defined, only one of either expression, headerField or path must be specified.
3864         */
3865        @Child(name = "path", type = {StringType.class}, order=7, min=0, max=1, modifier=false, summary=false)
3866        @Description(shortDefinition="XPath or JSONPath against the fixture body", formalDefinition="XPath or JSONPath to evaluate against the fixture body.  When variables are defined, only one of either expression, headerField or path must be specified." )
3867        protected StringType path;
3868
3869        /**
3870         * Fixture to evaluate the XPath/JSONPath expression or the headerField  against within this variable.
3871         */
3872        @Child(name = "sourceId", type = {IdType.class}, order=8, min=0, max=1, modifier=false, summary=false)
3873        @Description(shortDefinition="Fixture Id of source expression or headerField within this variable", formalDefinition="Fixture to evaluate the XPath/JSONPath expression or the headerField  against within this variable." )
3874        protected IdType sourceId;
3875
3876        private static final long serialVersionUID = -1592325432L;
3877
3878    /**
3879     * Constructor
3880     */
3881      public TestScriptVariableComponent() {
3882        super();
3883      }
3884
3885    /**
3886     * Constructor
3887     */
3888      public TestScriptVariableComponent(String name) {
3889        super();
3890        this.setName(name);
3891      }
3892
3893        /**
3894         * @return {@link #name} (Descriptive name for this variable.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
3895         */
3896        public StringType getNameElement() { 
3897          if (this.name == null)
3898            if (Configuration.errorOnAutoCreate())
3899              throw new Error("Attempt to auto-create TestScriptVariableComponent.name");
3900            else if (Configuration.doAutoCreate())
3901              this.name = new StringType(); // bb
3902          return this.name;
3903        }
3904
3905        public boolean hasNameElement() { 
3906          return this.name != null && !this.name.isEmpty();
3907        }
3908
3909        public boolean hasName() { 
3910          return this.name != null && !this.name.isEmpty();
3911        }
3912
3913        /**
3914         * @param value {@link #name} (Descriptive name for this variable.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
3915         */
3916        public TestScriptVariableComponent setNameElement(StringType value) { 
3917          this.name = value;
3918          return this;
3919        }
3920
3921        /**
3922         * @return Descriptive name for this variable.
3923         */
3924        public String getName() { 
3925          return this.name == null ? null : this.name.getValue();
3926        }
3927
3928        /**
3929         * @param value Descriptive name for this variable.
3930         */
3931        public TestScriptVariableComponent setName(String value) { 
3932            if (this.name == null)
3933              this.name = new StringType();
3934            this.name.setValue(value);
3935          return this;
3936        }
3937
3938        /**
3939         * @return {@link #defaultValue} (A default, hard-coded, or user-defined value for this variable.). This is the underlying object with id, value and extensions. The accessor "getDefaultValue" gives direct access to the value
3940         */
3941        public StringType getDefaultValueElement() { 
3942          if (this.defaultValue == null)
3943            if (Configuration.errorOnAutoCreate())
3944              throw new Error("Attempt to auto-create TestScriptVariableComponent.defaultValue");
3945            else if (Configuration.doAutoCreate())
3946              this.defaultValue = new StringType(); // bb
3947          return this.defaultValue;
3948        }
3949
3950        public boolean hasDefaultValueElement() { 
3951          return this.defaultValue != null && !this.defaultValue.isEmpty();
3952        }
3953
3954        public boolean hasDefaultValue() { 
3955          return this.defaultValue != null && !this.defaultValue.isEmpty();
3956        }
3957
3958        /**
3959         * @param value {@link #defaultValue} (A default, hard-coded, or user-defined value for this variable.). This is the underlying object with id, value and extensions. The accessor "getDefaultValue" gives direct access to the value
3960         */
3961        public TestScriptVariableComponent setDefaultValueElement(StringType value) { 
3962          this.defaultValue = value;
3963          return this;
3964        }
3965
3966        /**
3967         * @return A default, hard-coded, or user-defined value for this variable.
3968         */
3969        public String getDefaultValue() { 
3970          return this.defaultValue == null ? null : this.defaultValue.getValue();
3971        }
3972
3973        /**
3974         * @param value A default, hard-coded, or user-defined value for this variable.
3975         */
3976        public TestScriptVariableComponent setDefaultValue(String value) { 
3977          if (Utilities.noString(value))
3978            this.defaultValue = null;
3979          else {
3980            if (this.defaultValue == null)
3981              this.defaultValue = new StringType();
3982            this.defaultValue.setValue(value);
3983          }
3984          return this;
3985        }
3986
3987        /**
3988         * @return {@link #description} (A free text natural language description of the variable and its purpose.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
3989         */
3990        public StringType getDescriptionElement() { 
3991          if (this.description == null)
3992            if (Configuration.errorOnAutoCreate())
3993              throw new Error("Attempt to auto-create TestScriptVariableComponent.description");
3994            else if (Configuration.doAutoCreate())
3995              this.description = new StringType(); // bb
3996          return this.description;
3997        }
3998
3999        public boolean hasDescriptionElement() { 
4000          return this.description != null && !this.description.isEmpty();
4001        }
4002
4003        public boolean hasDescription() { 
4004          return this.description != null && !this.description.isEmpty();
4005        }
4006
4007        /**
4008         * @param value {@link #description} (A free text natural language description of the variable and its purpose.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
4009         */
4010        public TestScriptVariableComponent setDescriptionElement(StringType value) { 
4011          this.description = value;
4012          return this;
4013        }
4014
4015        /**
4016         * @return A free text natural language description of the variable and its purpose.
4017         */
4018        public String getDescription() { 
4019          return this.description == null ? null : this.description.getValue();
4020        }
4021
4022        /**
4023         * @param value A free text natural language description of the variable and its purpose.
4024         */
4025        public TestScriptVariableComponent setDescription(String value) { 
4026          if (Utilities.noString(value))
4027            this.description = null;
4028          else {
4029            if (this.description == null)
4030              this.description = new StringType();
4031            this.description.setValue(value);
4032          }
4033          return this;
4034        }
4035
4036        /**
4037         * @return {@link #expression} (The FHIRPath expression for a specific value to evaluate against the fixture body. When variables are defined, only one of either expression, headerField or path must be specified.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value
4038         */
4039        public StringType getExpressionElement() { 
4040          if (this.expression == null)
4041            if (Configuration.errorOnAutoCreate())
4042              throw new Error("Attempt to auto-create TestScriptVariableComponent.expression");
4043            else if (Configuration.doAutoCreate())
4044              this.expression = new StringType(); // bb
4045          return this.expression;
4046        }
4047
4048        public boolean hasExpressionElement() { 
4049          return this.expression != null && !this.expression.isEmpty();
4050        }
4051
4052        public boolean hasExpression() { 
4053          return this.expression != null && !this.expression.isEmpty();
4054        }
4055
4056        /**
4057         * @param value {@link #expression} (The FHIRPath expression for a specific value to evaluate against the fixture body. When variables are defined, only one of either expression, headerField or path must be specified.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value
4058         */
4059        public TestScriptVariableComponent setExpressionElement(StringType value) { 
4060          this.expression = value;
4061          return this;
4062        }
4063
4064        /**
4065         * @return The FHIRPath expression for a specific value to evaluate against the fixture body. When variables are defined, only one of either expression, headerField or path must be specified.
4066         */
4067        public String getExpression() { 
4068          return this.expression == null ? null : this.expression.getValue();
4069        }
4070
4071        /**
4072         * @param value The FHIRPath expression for a specific value to evaluate against the fixture body. When variables are defined, only one of either expression, headerField or path must be specified.
4073         */
4074        public TestScriptVariableComponent setExpression(String value) { 
4075          if (Utilities.noString(value))
4076            this.expression = null;
4077          else {
4078            if (this.expression == null)
4079              this.expression = new StringType();
4080            this.expression.setValue(value);
4081          }
4082          return this;
4083        }
4084
4085        /**
4086         * @return {@link #headerField} (Will be used to grab the HTTP header field value from the headers that sourceId is pointing to.). This is the underlying object with id, value and extensions. The accessor "getHeaderField" gives direct access to the value
4087         */
4088        public StringType getHeaderFieldElement() { 
4089          if (this.headerField == null)
4090            if (Configuration.errorOnAutoCreate())
4091              throw new Error("Attempt to auto-create TestScriptVariableComponent.headerField");
4092            else if (Configuration.doAutoCreate())
4093              this.headerField = new StringType(); // bb
4094          return this.headerField;
4095        }
4096
4097        public boolean hasHeaderFieldElement() { 
4098          return this.headerField != null && !this.headerField.isEmpty();
4099        }
4100
4101        public boolean hasHeaderField() { 
4102          return this.headerField != null && !this.headerField.isEmpty();
4103        }
4104
4105        /**
4106         * @param value {@link #headerField} (Will be used to grab the HTTP header field value from the headers that sourceId is pointing to.). This is the underlying object with id, value and extensions. The accessor "getHeaderField" gives direct access to the value
4107         */
4108        public TestScriptVariableComponent setHeaderFieldElement(StringType value) { 
4109          this.headerField = value;
4110          return this;
4111        }
4112
4113        /**
4114         * @return Will be used to grab the HTTP header field value from the headers that sourceId is pointing to.
4115         */
4116        public String getHeaderField() { 
4117          return this.headerField == null ? null : this.headerField.getValue();
4118        }
4119
4120        /**
4121         * @param value Will be used to grab the HTTP header field value from the headers that sourceId is pointing to.
4122         */
4123        public TestScriptVariableComponent setHeaderField(String value) { 
4124          if (Utilities.noString(value))
4125            this.headerField = null;
4126          else {
4127            if (this.headerField == null)
4128              this.headerField = new StringType();
4129            this.headerField.setValue(value);
4130          }
4131          return this;
4132        }
4133
4134        /**
4135         * @return {@link #hint} (Displayable text string with hint help information to the user when entering a default value.). This is the underlying object with id, value and extensions. The accessor "getHint" gives direct access to the value
4136         */
4137        public StringType getHintElement() { 
4138          if (this.hint == null)
4139            if (Configuration.errorOnAutoCreate())
4140              throw new Error("Attempt to auto-create TestScriptVariableComponent.hint");
4141            else if (Configuration.doAutoCreate())
4142              this.hint = new StringType(); // bb
4143          return this.hint;
4144        }
4145
4146        public boolean hasHintElement() { 
4147          return this.hint != null && !this.hint.isEmpty();
4148        }
4149
4150        public boolean hasHint() { 
4151          return this.hint != null && !this.hint.isEmpty();
4152        }
4153
4154        /**
4155         * @param value {@link #hint} (Displayable text string with hint help information to the user when entering a default value.). This is the underlying object with id, value and extensions. The accessor "getHint" gives direct access to the value
4156         */
4157        public TestScriptVariableComponent setHintElement(StringType value) { 
4158          this.hint = value;
4159          return this;
4160        }
4161
4162        /**
4163         * @return Displayable text string with hint help information to the user when entering a default value.
4164         */
4165        public String getHint() { 
4166          return this.hint == null ? null : this.hint.getValue();
4167        }
4168
4169        /**
4170         * @param value Displayable text string with hint help information to the user when entering a default value.
4171         */
4172        public TestScriptVariableComponent setHint(String value) { 
4173          if (Utilities.noString(value))
4174            this.hint = null;
4175          else {
4176            if (this.hint == null)
4177              this.hint = new StringType();
4178            this.hint.setValue(value);
4179          }
4180          return this;
4181        }
4182
4183        /**
4184         * @return {@link #path} (XPath or JSONPath to evaluate against the fixture body.  When variables are defined, only one of either expression, headerField or path must be specified.). This is the underlying object with id, value and extensions. The accessor "getPath" gives direct access to the value
4185         */
4186        public StringType getPathElement() { 
4187          if (this.path == null)
4188            if (Configuration.errorOnAutoCreate())
4189              throw new Error("Attempt to auto-create TestScriptVariableComponent.path");
4190            else if (Configuration.doAutoCreate())
4191              this.path = new StringType(); // bb
4192          return this.path;
4193        }
4194
4195        public boolean hasPathElement() { 
4196          return this.path != null && !this.path.isEmpty();
4197        }
4198
4199        public boolean hasPath() { 
4200          return this.path != null && !this.path.isEmpty();
4201        }
4202
4203        /**
4204         * @param value {@link #path} (XPath or JSONPath to evaluate against the fixture body.  When variables are defined, only one of either expression, headerField or path must be specified.). This is the underlying object with id, value and extensions. The accessor "getPath" gives direct access to the value
4205         */
4206        public TestScriptVariableComponent setPathElement(StringType value) { 
4207          this.path = value;
4208          return this;
4209        }
4210
4211        /**
4212         * @return XPath or JSONPath to evaluate against the fixture body.  When variables are defined, only one of either expression, headerField or path must be specified.
4213         */
4214        public String getPath() { 
4215          return this.path == null ? null : this.path.getValue();
4216        }
4217
4218        /**
4219         * @param value XPath or JSONPath to evaluate against the fixture body.  When variables are defined, only one of either expression, headerField or path must be specified.
4220         */
4221        public TestScriptVariableComponent setPath(String value) { 
4222          if (Utilities.noString(value))
4223            this.path = null;
4224          else {
4225            if (this.path == null)
4226              this.path = new StringType();
4227            this.path.setValue(value);
4228          }
4229          return this;
4230        }
4231
4232        /**
4233         * @return {@link #sourceId} (Fixture to evaluate the XPath/JSONPath expression or the headerField  against within this variable.). This is the underlying object with id, value and extensions. The accessor "getSourceId" gives direct access to the value
4234         */
4235        public IdType getSourceIdElement() { 
4236          if (this.sourceId == null)
4237            if (Configuration.errorOnAutoCreate())
4238              throw new Error("Attempt to auto-create TestScriptVariableComponent.sourceId");
4239            else if (Configuration.doAutoCreate())
4240              this.sourceId = new IdType(); // bb
4241          return this.sourceId;
4242        }
4243
4244        public boolean hasSourceIdElement() { 
4245          return this.sourceId != null && !this.sourceId.isEmpty();
4246        }
4247
4248        public boolean hasSourceId() { 
4249          return this.sourceId != null && !this.sourceId.isEmpty();
4250        }
4251
4252        /**
4253         * @param value {@link #sourceId} (Fixture to evaluate the XPath/JSONPath expression or the headerField  against within this variable.). This is the underlying object with id, value and extensions. The accessor "getSourceId" gives direct access to the value
4254         */
4255        public TestScriptVariableComponent setSourceIdElement(IdType value) { 
4256          this.sourceId = value;
4257          return this;
4258        }
4259
4260        /**
4261         * @return Fixture to evaluate the XPath/JSONPath expression or the headerField  against within this variable.
4262         */
4263        public String getSourceId() { 
4264          return this.sourceId == null ? null : this.sourceId.getValue();
4265        }
4266
4267        /**
4268         * @param value Fixture to evaluate the XPath/JSONPath expression or the headerField  against within this variable.
4269         */
4270        public TestScriptVariableComponent setSourceId(String value) { 
4271          if (Utilities.noString(value))
4272            this.sourceId = null;
4273          else {
4274            if (this.sourceId == null)
4275              this.sourceId = new IdType();
4276            this.sourceId.setValue(value);
4277          }
4278          return this;
4279        }
4280
4281        protected void listChildren(List<Property> children) {
4282          super.listChildren(children);
4283          children.add(new Property("name", "string", "Descriptive name for this variable.", 0, 1, name));
4284          children.add(new Property("defaultValue", "string", "A default, hard-coded, or user-defined value for this variable.", 0, 1, defaultValue));
4285          children.add(new Property("description", "string", "A free text natural language description of the variable and its purpose.", 0, 1, description));
4286          children.add(new Property("expression", "string", "The FHIRPath expression for a specific value to evaluate against the fixture body. When variables are defined, only one of either expression, headerField or path must be specified.", 0, 1, expression));
4287          children.add(new Property("headerField", "string", "Will be used to grab the HTTP header field value from the headers that sourceId is pointing to.", 0, 1, headerField));
4288          children.add(new Property("hint", "string", "Displayable text string with hint help information to the user when entering a default value.", 0, 1, hint));
4289          children.add(new Property("path", "string", "XPath or JSONPath to evaluate against the fixture body.  When variables are defined, only one of either expression, headerField or path must be specified.", 0, 1, path));
4290          children.add(new Property("sourceId", "id", "Fixture to evaluate the XPath/JSONPath expression or the headerField  against within this variable.", 0, 1, sourceId));
4291        }
4292
4293        @Override
4294        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
4295          switch (_hash) {
4296          case 3373707: /*name*/  return new Property("name", "string", "Descriptive name for this variable.", 0, 1, name);
4297          case -659125328: /*defaultValue*/  return new Property("defaultValue", "string", "A default, hard-coded, or user-defined value for this variable.", 0, 1, defaultValue);
4298          case -1724546052: /*description*/  return new Property("description", "string", "A free text natural language description of the variable and its purpose.", 0, 1, description);
4299          case -1795452264: /*expression*/  return new Property("expression", "string", "The FHIRPath expression for a specific value to evaluate against the fixture body. When variables are defined, only one of either expression, headerField or path must be specified.", 0, 1, expression);
4300          case 1160732269: /*headerField*/  return new Property("headerField", "string", "Will be used to grab the HTTP header field value from the headers that sourceId is pointing to.", 0, 1, headerField);
4301          case 3202695: /*hint*/  return new Property("hint", "string", "Displayable text string with hint help information to the user when entering a default value.", 0, 1, hint);
4302          case 3433509: /*path*/  return new Property("path", "string", "XPath or JSONPath to evaluate against the fixture body.  When variables are defined, only one of either expression, headerField or path must be specified.", 0, 1, path);
4303          case 1746327190: /*sourceId*/  return new Property("sourceId", "id", "Fixture to evaluate the XPath/JSONPath expression or the headerField  against within this variable.", 0, 1, sourceId);
4304          default: return super.getNamedProperty(_hash, _name, _checkValid);
4305          }
4306
4307        }
4308
4309      @Override
4310      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
4311        switch (hash) {
4312        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
4313        case -659125328: /*defaultValue*/ return this.defaultValue == null ? new Base[0] : new Base[] {this.defaultValue}; // StringType
4314        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType
4315        case -1795452264: /*expression*/ return this.expression == null ? new Base[0] : new Base[] {this.expression}; // StringType
4316        case 1160732269: /*headerField*/ return this.headerField == null ? new Base[0] : new Base[] {this.headerField}; // StringType
4317        case 3202695: /*hint*/ return this.hint == null ? new Base[0] : new Base[] {this.hint}; // StringType
4318        case 3433509: /*path*/ return this.path == null ? new Base[0] : new Base[] {this.path}; // StringType
4319        case 1746327190: /*sourceId*/ return this.sourceId == null ? new Base[0] : new Base[] {this.sourceId}; // IdType
4320        default: return super.getProperty(hash, name, checkValid);
4321        }
4322
4323      }
4324
4325      @Override
4326      public Base setProperty(int hash, String name, Base value) throws FHIRException {
4327        switch (hash) {
4328        case 3373707: // name
4329          this.name = TypeConvertor.castToString(value); // StringType
4330          return value;
4331        case -659125328: // defaultValue
4332          this.defaultValue = TypeConvertor.castToString(value); // StringType
4333          return value;
4334        case -1724546052: // description
4335          this.description = TypeConvertor.castToString(value); // StringType
4336          return value;
4337        case -1795452264: // expression
4338          this.expression = TypeConvertor.castToString(value); // StringType
4339          return value;
4340        case 1160732269: // headerField
4341          this.headerField = TypeConvertor.castToString(value); // StringType
4342          return value;
4343        case 3202695: // hint
4344          this.hint = TypeConvertor.castToString(value); // StringType
4345          return value;
4346        case 3433509: // path
4347          this.path = TypeConvertor.castToString(value); // StringType
4348          return value;
4349        case 1746327190: // sourceId
4350          this.sourceId = TypeConvertor.castToId(value); // IdType
4351          return value;
4352        default: return super.setProperty(hash, name, value);
4353        }
4354
4355      }
4356
4357      @Override
4358      public Base setProperty(String name, Base value) throws FHIRException {
4359        if (name.equals("name")) {
4360          this.name = TypeConvertor.castToString(value); // StringType
4361        } else if (name.equals("defaultValue")) {
4362          this.defaultValue = TypeConvertor.castToString(value); // StringType
4363        } else if (name.equals("description")) {
4364          this.description = TypeConvertor.castToString(value); // StringType
4365        } else if (name.equals("expression")) {
4366          this.expression = TypeConvertor.castToString(value); // StringType
4367        } else if (name.equals("headerField")) {
4368          this.headerField = TypeConvertor.castToString(value); // StringType
4369        } else if (name.equals("hint")) {
4370          this.hint = TypeConvertor.castToString(value); // StringType
4371        } else if (name.equals("path")) {
4372          this.path = TypeConvertor.castToString(value); // StringType
4373        } else if (name.equals("sourceId")) {
4374          this.sourceId = TypeConvertor.castToId(value); // IdType
4375        } else
4376          return super.setProperty(name, value);
4377        return value;
4378      }
4379
4380      @Override
4381      public Base makeProperty(int hash, String name) throws FHIRException {
4382        switch (hash) {
4383        case 3373707:  return getNameElement();
4384        case -659125328:  return getDefaultValueElement();
4385        case -1724546052:  return getDescriptionElement();
4386        case -1795452264:  return getExpressionElement();
4387        case 1160732269:  return getHeaderFieldElement();
4388        case 3202695:  return getHintElement();
4389        case 3433509:  return getPathElement();
4390        case 1746327190:  return getSourceIdElement();
4391        default: return super.makeProperty(hash, name);
4392        }
4393
4394      }
4395
4396      @Override
4397      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
4398        switch (hash) {
4399        case 3373707: /*name*/ return new String[] {"string"};
4400        case -659125328: /*defaultValue*/ return new String[] {"string"};
4401        case -1724546052: /*description*/ return new String[] {"string"};
4402        case -1795452264: /*expression*/ return new String[] {"string"};
4403        case 1160732269: /*headerField*/ return new String[] {"string"};
4404        case 3202695: /*hint*/ return new String[] {"string"};
4405        case 3433509: /*path*/ return new String[] {"string"};
4406        case 1746327190: /*sourceId*/ return new String[] {"id"};
4407        default: return super.getTypesForProperty(hash, name);
4408        }
4409
4410      }
4411
4412      @Override
4413      public Base addChild(String name) throws FHIRException {
4414        if (name.equals("name")) {
4415          throw new FHIRException("Cannot call addChild on a singleton property TestScript.variable.name");
4416        }
4417        else if (name.equals("defaultValue")) {
4418          throw new FHIRException("Cannot call addChild on a singleton property TestScript.variable.defaultValue");
4419        }
4420        else if (name.equals("description")) {
4421          throw new FHIRException("Cannot call addChild on a singleton property TestScript.variable.description");
4422        }
4423        else if (name.equals("expression")) {
4424          throw new FHIRException("Cannot call addChild on a singleton property TestScript.variable.expression");
4425        }
4426        else if (name.equals("headerField")) {
4427          throw new FHIRException("Cannot call addChild on a singleton property TestScript.variable.headerField");
4428        }
4429        else if (name.equals("hint")) {
4430          throw new FHIRException("Cannot call addChild on a singleton property TestScript.variable.hint");
4431        }
4432        else if (name.equals("path")) {
4433          throw new FHIRException("Cannot call addChild on a singleton property TestScript.variable.path");
4434        }
4435        else if (name.equals("sourceId")) {
4436          throw new FHIRException("Cannot call addChild on a singleton property TestScript.variable.sourceId");
4437        }
4438        else
4439          return super.addChild(name);
4440      }
4441
4442      public TestScriptVariableComponent copy() {
4443        TestScriptVariableComponent dst = new TestScriptVariableComponent();
4444        copyValues(dst);
4445        return dst;
4446      }
4447
4448      public void copyValues(TestScriptVariableComponent dst) {
4449        super.copyValues(dst);
4450        dst.name = name == null ? null : name.copy();
4451        dst.defaultValue = defaultValue == null ? null : defaultValue.copy();
4452        dst.description = description == null ? null : description.copy();
4453        dst.expression = expression == null ? null : expression.copy();
4454        dst.headerField = headerField == null ? null : headerField.copy();
4455        dst.hint = hint == null ? null : hint.copy();
4456        dst.path = path == null ? null : path.copy();
4457        dst.sourceId = sourceId == null ? null : sourceId.copy();
4458      }
4459
4460      @Override
4461      public boolean equalsDeep(Base other_) {
4462        if (!super.equalsDeep(other_))
4463          return false;
4464        if (!(other_ instanceof TestScriptVariableComponent))
4465          return false;
4466        TestScriptVariableComponent o = (TestScriptVariableComponent) other_;
4467        return compareDeep(name, o.name, true) && compareDeep(defaultValue, o.defaultValue, true) && compareDeep(description, o.description, true)
4468           && compareDeep(expression, o.expression, true) && compareDeep(headerField, o.headerField, true)
4469           && compareDeep(hint, o.hint, true) && compareDeep(path, o.path, true) && compareDeep(sourceId, o.sourceId, true)
4470          ;
4471      }
4472
4473      @Override
4474      public boolean equalsShallow(Base other_) {
4475        if (!super.equalsShallow(other_))
4476          return false;
4477        if (!(other_ instanceof TestScriptVariableComponent))
4478          return false;
4479        TestScriptVariableComponent o = (TestScriptVariableComponent) other_;
4480        return compareValues(name, o.name, true) && compareValues(defaultValue, o.defaultValue, true) && compareValues(description, o.description, true)
4481           && compareValues(expression, o.expression, true) && compareValues(headerField, o.headerField, true)
4482           && compareValues(hint, o.hint, true) && compareValues(path, o.path, true) && compareValues(sourceId, o.sourceId, true)
4483          ;
4484      }
4485
4486      public boolean isEmpty() {
4487        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, defaultValue, description
4488          , expression, headerField, hint, path, sourceId);
4489      }
4490
4491  public String fhirType() {
4492    return "TestScript.variable";
4493
4494  }
4495
4496  }
4497
4498    @Block()
4499    public static class TestScriptSetupComponent extends BackboneElement implements IBaseBackboneElement {
4500        /**
4501         * Action would contain either an operation or an assertion.
4502         */
4503        @Child(name = "action", type = {}, order=1, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
4504        @Description(shortDefinition="A setup operation or assert to perform", formalDefinition="Action would contain either an operation or an assertion." )
4505        protected List<SetupActionComponent> action;
4506
4507        private static final long serialVersionUID = -123374486L;
4508
4509    /**
4510     * Constructor
4511     */
4512      public TestScriptSetupComponent() {
4513        super();
4514      }
4515
4516    /**
4517     * Constructor
4518     */
4519      public TestScriptSetupComponent(SetupActionComponent action) {
4520        super();
4521        this.addAction(action);
4522      }
4523
4524        /**
4525         * @return {@link #action} (Action would contain either an operation or an assertion.)
4526         */
4527        public List<SetupActionComponent> getAction() { 
4528          if (this.action == null)
4529            this.action = new ArrayList<SetupActionComponent>();
4530          return this.action;
4531        }
4532
4533        /**
4534         * @return Returns a reference to <code>this</code> for easy method chaining
4535         */
4536        public TestScriptSetupComponent setAction(List<SetupActionComponent> theAction) { 
4537          this.action = theAction;
4538          return this;
4539        }
4540
4541        public boolean hasAction() { 
4542          if (this.action == null)
4543            return false;
4544          for (SetupActionComponent item : this.action)
4545            if (!item.isEmpty())
4546              return true;
4547          return false;
4548        }
4549
4550        public SetupActionComponent addAction() { //3
4551          SetupActionComponent t = new SetupActionComponent();
4552          if (this.action == null)
4553            this.action = new ArrayList<SetupActionComponent>();
4554          this.action.add(t);
4555          return t;
4556        }
4557
4558        public TestScriptSetupComponent addAction(SetupActionComponent t) { //3
4559          if (t == null)
4560            return this;
4561          if (this.action == null)
4562            this.action = new ArrayList<SetupActionComponent>();
4563          this.action.add(t);
4564          return this;
4565        }
4566
4567        /**
4568         * @return The first repetition of repeating field {@link #action}, creating it if it does not already exist {3}
4569         */
4570        public SetupActionComponent getActionFirstRep() { 
4571          if (getAction().isEmpty()) {
4572            addAction();
4573          }
4574          return getAction().get(0);
4575        }
4576
4577        protected void listChildren(List<Property> children) {
4578          super.listChildren(children);
4579          children.add(new Property("action", "", "Action would contain either an operation or an assertion.", 0, java.lang.Integer.MAX_VALUE, action));
4580        }
4581
4582        @Override
4583        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
4584          switch (_hash) {
4585          case -1422950858: /*action*/  return new Property("action", "", "Action would contain either an operation or an assertion.", 0, java.lang.Integer.MAX_VALUE, action);
4586          default: return super.getNamedProperty(_hash, _name, _checkValid);
4587          }
4588
4589        }
4590
4591      @Override
4592      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
4593        switch (hash) {
4594        case -1422950858: /*action*/ return this.action == null ? new Base[0] : this.action.toArray(new Base[this.action.size()]); // SetupActionComponent
4595        default: return super.getProperty(hash, name, checkValid);
4596        }
4597
4598      }
4599
4600      @Override
4601      public Base setProperty(int hash, String name, Base value) throws FHIRException {
4602        switch (hash) {
4603        case -1422950858: // action
4604          this.getAction().add((SetupActionComponent) value); // SetupActionComponent
4605          return value;
4606        default: return super.setProperty(hash, name, value);
4607        }
4608
4609      }
4610
4611      @Override
4612      public Base setProperty(String name, Base value) throws FHIRException {
4613        if (name.equals("action")) {
4614          this.getAction().add((SetupActionComponent) value);
4615        } else
4616          return super.setProperty(name, value);
4617        return value;
4618      }
4619
4620      @Override
4621      public Base makeProperty(int hash, String name) throws FHIRException {
4622        switch (hash) {
4623        case -1422950858:  return addAction(); 
4624        default: return super.makeProperty(hash, name);
4625        }
4626
4627      }
4628
4629      @Override
4630      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
4631        switch (hash) {
4632        case -1422950858: /*action*/ return new String[] {};
4633        default: return super.getTypesForProperty(hash, name);
4634        }
4635
4636      }
4637
4638      @Override
4639      public Base addChild(String name) throws FHIRException {
4640        if (name.equals("action")) {
4641          return addAction();
4642        }
4643        else
4644          return super.addChild(name);
4645      }
4646
4647      public TestScriptSetupComponent copy() {
4648        TestScriptSetupComponent dst = new TestScriptSetupComponent();
4649        copyValues(dst);
4650        return dst;
4651      }
4652
4653      public void copyValues(TestScriptSetupComponent dst) {
4654        super.copyValues(dst);
4655        if (action != null) {
4656          dst.action = new ArrayList<SetupActionComponent>();
4657          for (SetupActionComponent i : action)
4658            dst.action.add(i.copy());
4659        };
4660      }
4661
4662      @Override
4663      public boolean equalsDeep(Base other_) {
4664        if (!super.equalsDeep(other_))
4665          return false;
4666        if (!(other_ instanceof TestScriptSetupComponent))
4667          return false;
4668        TestScriptSetupComponent o = (TestScriptSetupComponent) other_;
4669        return compareDeep(action, o.action, true);
4670      }
4671
4672      @Override
4673      public boolean equalsShallow(Base other_) {
4674        if (!super.equalsShallow(other_))
4675          return false;
4676        if (!(other_ instanceof TestScriptSetupComponent))
4677          return false;
4678        TestScriptSetupComponent o = (TestScriptSetupComponent) other_;
4679        return true;
4680      }
4681
4682      public boolean isEmpty() {
4683        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(action);
4684      }
4685
4686  public String fhirType() {
4687    return "TestScript.setup";
4688
4689  }
4690
4691  }
4692
4693    @Block()
4694    public static class SetupActionComponent extends BackboneElement implements IBaseBackboneElement {
4695        /**
4696         * The operation to perform.
4697         */
4698        @Child(name = "operation", type = {}, order=1, min=0, max=1, modifier=false, summary=false)
4699        @Description(shortDefinition="The setup operation to perform", formalDefinition="The operation to perform." )
4700        protected SetupActionOperationComponent operation;
4701
4702        /**
4703         * Evaluates the results of previous operations to determine if the server under test behaves appropriately.
4704         */
4705        @Child(name = "assert", type = {}, order=2, min=0, max=1, modifier=false, summary=false)
4706        @Description(shortDefinition="The assertion to perform", formalDefinition="Evaluates the results of previous operations to determine if the server under test behaves appropriately." )
4707        protected SetupActionAssertComponent assert_;
4708
4709        private static final long serialVersionUID = -252088305L;
4710
4711    /**
4712     * Constructor
4713     */
4714      public SetupActionComponent() {
4715        super();
4716      }
4717
4718        /**
4719         * @return {@link #operation} (The operation to perform.)
4720         */
4721        public SetupActionOperationComponent getOperation() { 
4722          if (this.operation == null)
4723            if (Configuration.errorOnAutoCreate())
4724              throw new Error("Attempt to auto-create SetupActionComponent.operation");
4725            else if (Configuration.doAutoCreate())
4726              this.operation = new SetupActionOperationComponent(); // cc
4727          return this.operation;
4728        }
4729
4730        public boolean hasOperation() { 
4731          return this.operation != null && !this.operation.isEmpty();
4732        }
4733
4734        /**
4735         * @param value {@link #operation} (The operation to perform.)
4736         */
4737        public SetupActionComponent setOperation(SetupActionOperationComponent value) { 
4738          this.operation = value;
4739          return this;
4740        }
4741
4742        /**
4743         * @return {@link #assert_} (Evaluates the results of previous operations to determine if the server under test behaves appropriately.)
4744         */
4745        public SetupActionAssertComponent getAssert() { 
4746          if (this.assert_ == null)
4747            if (Configuration.errorOnAutoCreate())
4748              throw new Error("Attempt to auto-create SetupActionComponent.assert_");
4749            else if (Configuration.doAutoCreate())
4750              this.assert_ = new SetupActionAssertComponent(); // cc
4751          return this.assert_;
4752        }
4753
4754        public boolean hasAssert() { 
4755          return this.assert_ != null && !this.assert_.isEmpty();
4756        }
4757
4758        /**
4759         * @param value {@link #assert_} (Evaluates the results of previous operations to determine if the server under test behaves appropriately.)
4760         */
4761        public SetupActionComponent setAssert(SetupActionAssertComponent value) { 
4762          this.assert_ = value;
4763          return this;
4764        }
4765
4766        protected void listChildren(List<Property> children) {
4767          super.listChildren(children);
4768          children.add(new Property("operation", "", "The operation to perform.", 0, 1, operation));
4769          children.add(new Property("assert", "", "Evaluates the results of previous operations to determine if the server under test behaves appropriately.", 0, 1, assert_));
4770        }
4771
4772        @Override
4773        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
4774          switch (_hash) {
4775          case 1662702951: /*operation*/  return new Property("operation", "", "The operation to perform.", 0, 1, operation);
4776          case -1408208058: /*assert*/  return new Property("assert", "", "Evaluates the results of previous operations to determine if the server under test behaves appropriately.", 0, 1, assert_);
4777          default: return super.getNamedProperty(_hash, _name, _checkValid);
4778          }
4779
4780        }
4781
4782      @Override
4783      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
4784        switch (hash) {
4785        case 1662702951: /*operation*/ return this.operation == null ? new Base[0] : new Base[] {this.operation}; // SetupActionOperationComponent
4786        case -1408208058: /*assert*/ return this.assert_ == null ? new Base[0] : new Base[] {this.assert_}; // SetupActionAssertComponent
4787        default: return super.getProperty(hash, name, checkValid);
4788        }
4789
4790      }
4791
4792      @Override
4793      public Base setProperty(int hash, String name, Base value) throws FHIRException {
4794        switch (hash) {
4795        case 1662702951: // operation
4796          this.operation = (SetupActionOperationComponent) value; // SetupActionOperationComponent
4797          return value;
4798        case -1408208058: // assert
4799          this.assert_ = (SetupActionAssertComponent) value; // SetupActionAssertComponent
4800          return value;
4801        default: return super.setProperty(hash, name, value);
4802        }
4803
4804      }
4805
4806      @Override
4807      public Base setProperty(String name, Base value) throws FHIRException {
4808        if (name.equals("operation")) {
4809          this.operation = (SetupActionOperationComponent) value; // SetupActionOperationComponent
4810        } else if (name.equals("assert")) {
4811          this.assert_ = (SetupActionAssertComponent) value; // SetupActionAssertComponent
4812        } else
4813          return super.setProperty(name, value);
4814        return value;
4815      }
4816
4817      @Override
4818      public Base makeProperty(int hash, String name) throws FHIRException {
4819        switch (hash) {
4820        case 1662702951:  return getOperation();
4821        case -1408208058:  return getAssert();
4822        default: return super.makeProperty(hash, name);
4823        }
4824
4825      }
4826
4827      @Override
4828      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
4829        switch (hash) {
4830        case 1662702951: /*operation*/ return new String[] {};
4831        case -1408208058: /*assert*/ return new String[] {};
4832        default: return super.getTypesForProperty(hash, name);
4833        }
4834
4835      }
4836
4837      @Override
4838      public Base addChild(String name) throws FHIRException {
4839        if (name.equals("operation")) {
4840          this.operation = new SetupActionOperationComponent();
4841          return this.operation;
4842        }
4843        else if (name.equals("assert")) {
4844          this.assert_ = new SetupActionAssertComponent();
4845          return this.assert_;
4846        }
4847        else
4848          return super.addChild(name);
4849      }
4850
4851      public SetupActionComponent copy() {
4852        SetupActionComponent dst = new SetupActionComponent();
4853        copyValues(dst);
4854        return dst;
4855      }
4856
4857      public void copyValues(SetupActionComponent dst) {
4858        super.copyValues(dst);
4859        dst.operation = operation == null ? null : operation.copy();
4860        dst.assert_ = assert_ == null ? null : assert_.copy();
4861      }
4862
4863      @Override
4864      public boolean equalsDeep(Base other_) {
4865        if (!super.equalsDeep(other_))
4866          return false;
4867        if (!(other_ instanceof SetupActionComponent))
4868          return false;
4869        SetupActionComponent o = (SetupActionComponent) other_;
4870        return compareDeep(operation, o.operation, true) && compareDeep(assert_, o.assert_, true);
4871      }
4872
4873      @Override
4874      public boolean equalsShallow(Base other_) {
4875        if (!super.equalsShallow(other_))
4876          return false;
4877        if (!(other_ instanceof SetupActionComponent))
4878          return false;
4879        SetupActionComponent o = (SetupActionComponent) other_;
4880        return true;
4881      }
4882
4883      public boolean isEmpty() {
4884        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(operation, assert_);
4885      }
4886
4887  public String fhirType() {
4888    return "TestScript.setup.action";
4889
4890  }
4891
4892  }
4893
4894    @Block()
4895    public static class SetupActionOperationComponent extends BackboneElement implements IBaseBackboneElement {
4896        /**
4897         * Server interaction or operation type.
4898         */
4899        @Child(name = "type", type = {Coding.class}, order=1, min=0, max=1, modifier=false, summary=false)
4900        @Description(shortDefinition="The operation code type that will be executed", formalDefinition="Server interaction or operation type." )
4901        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/testscript-operation-codes")
4902        protected Coding type;
4903
4904        /**
4905         * The type of the FHIR resource. See the [resource list](resourcelist.html). Data type of uri is needed when non-HL7 artifacts are identified.
4906         */
4907        @Child(name = "resource", type = {UriType.class}, order=2, min=0, max=1, modifier=false, summary=false)
4908        @Description(shortDefinition="Resource type", formalDefinition="The type of the FHIR resource. See the [resource list](resourcelist.html). Data type of uri is needed when non-HL7 artifacts are identified." )
4909        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/concrete-fhir-types")
4910        protected UriType resource;
4911
4912        /**
4913         * The label would be used for tracking/logging purposes by test engines.
4914         */
4915        @Child(name = "label", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=false)
4916        @Description(shortDefinition="Tracking/logging operation label", formalDefinition="The label would be used for tracking/logging purposes by test engines." )
4917        protected StringType label;
4918
4919        /**
4920         * The description would be used by test engines for tracking and reporting purposes.
4921         */
4922        @Child(name = "description", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=false)
4923        @Description(shortDefinition="Tracking/reporting operation description", formalDefinition="The description would be used by test engines for tracking and reporting purposes." )
4924        protected StringType description;
4925
4926        /**
4927         * The mime-type to use for RESTful operation in the 'Accept' header.
4928         */
4929        @Child(name = "accept", type = {CodeType.class}, order=5, min=0, max=1, modifier=false, summary=false)
4930        @Description(shortDefinition="Mime type to accept in the payload of the response, with charset etc", formalDefinition="The mime-type to use for RESTful operation in the 'Accept' header." )
4931        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/mimetypes")
4932        protected CodeType accept;
4933
4934        /**
4935         * The mime-type to use for RESTful operation in the 'Content-Type' header.
4936         */
4937        @Child(name = "contentType", type = {CodeType.class}, order=6, min=0, max=1, modifier=false, summary=false)
4938        @Description(shortDefinition="Mime type of the request payload contents, with charset etc", formalDefinition="The mime-type to use for RESTful operation in the 'Content-Type' header." )
4939        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/mimetypes")
4940        protected CodeType contentType;
4941
4942        /**
4943         * The server where the request message is destined for.  Must be one of the server numbers listed in TestScript.destination section.
4944         */
4945        @Child(name = "destination", type = {IntegerType.class}, order=7, min=0, max=1, modifier=false, summary=false)
4946        @Description(shortDefinition="Server responding to the request", formalDefinition="The server where the request message is destined for.  Must be one of the server numbers listed in TestScript.destination section." )
4947        protected IntegerType destination;
4948
4949        /**
4950         * Whether or not to implicitly send the request url in encoded format. The default is true to match the standard RESTful client behavior. Set to false when communicating with a server that does not support encoded url paths.
4951         */
4952        @Child(name = "encodeRequestUrl", type = {BooleanType.class}, order=8, min=1, max=1, modifier=false, summary=false)
4953        @Description(shortDefinition="Whether or not to send the request url in encoded format", formalDefinition="Whether or not to implicitly send the request url in encoded format. The default is true to match the standard RESTful client behavior. Set to false when communicating with a server that does not support encoded url paths." )
4954        protected BooleanType encodeRequestUrl;
4955
4956        /**
4957         * The HTTP method the test engine MUST use for this operation regardless of any other operation details.
4958         */
4959        @Child(name = "method", type = {CodeType.class}, order=9, min=0, max=1, modifier=false, summary=false)
4960        @Description(shortDefinition="delete | get | options | patch | post | put | head", formalDefinition="The HTTP method the test engine MUST use for this operation regardless of any other operation details." )
4961        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/http-operations")
4962        protected Enumeration<TestScriptRequestMethodCode> method;
4963
4964        /**
4965         * The server where the request message originates from.  Must be one of the server numbers listed in TestScript.origin section.
4966         */
4967        @Child(name = "origin", type = {IntegerType.class}, order=10, min=0, max=1, modifier=false, summary=false)
4968        @Description(shortDefinition="Server initiating the request", formalDefinition="The server where the request message originates from.  Must be one of the server numbers listed in TestScript.origin section." )
4969        protected IntegerType origin;
4970
4971        /**
4972         * Path plus parameters after [type].  Used to set parts of the request URL explicitly.
4973         */
4974        @Child(name = "params", type = {StringType.class}, order=11, min=0, max=1, modifier=false, summary=false)
4975        @Description(shortDefinition="Explicitly defined path parameters", formalDefinition="Path plus parameters after [type].  Used to set parts of the request URL explicitly." )
4976        protected StringType params;
4977
4978        /**
4979         * Header elements would be used to set HTTP headers.
4980         */
4981        @Child(name = "requestHeader", type = {}, order=12, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
4982        @Description(shortDefinition="Each operation can have one or more header elements", formalDefinition="Header elements would be used to set HTTP headers." )
4983        protected List<SetupActionOperationRequestHeaderComponent> requestHeader;
4984
4985        /**
4986         * The fixture id (maybe new) to map to the request.
4987         */
4988        @Child(name = "requestId", type = {IdType.class}, order=13, min=0, max=1, modifier=false, summary=false)
4989        @Description(shortDefinition="Fixture Id of mapped request", formalDefinition="The fixture id (maybe new) to map to the request." )
4990        protected IdType requestId;
4991
4992        /**
4993         * The fixture id (maybe new) to map to the response.
4994         */
4995        @Child(name = "responseId", type = {IdType.class}, order=14, min=0, max=1, modifier=false, summary=false)
4996        @Description(shortDefinition="Fixture Id of mapped response", formalDefinition="The fixture id (maybe new) to map to the response." )
4997        protected IdType responseId;
4998
4999        /**
5000         * The id of the fixture used as the body of a PUT or POST request.
5001         */
5002        @Child(name = "sourceId", type = {IdType.class}, order=15, min=0, max=1, modifier=false, summary=false)
5003        @Description(shortDefinition="Fixture Id of body for PUT and POST requests", formalDefinition="The id of the fixture used as the body of a PUT or POST request." )
5004        protected IdType sourceId;
5005
5006        /**
5007         * Id of fixture used for extracting the [id],  [type], and [vid] for GET requests.
5008         */
5009        @Child(name = "targetId", type = {IdType.class}, order=16, min=0, max=1, modifier=false, summary=false)
5010        @Description(shortDefinition="Id of fixture used for extracting the [id],  [type], and [vid] for GET requests", formalDefinition="Id of fixture used for extracting the [id],  [type], and [vid] for GET requests." )
5011        protected IdType targetId;
5012
5013        /**
5014         * Complete request URL.
5015         */
5016        @Child(name = "url", type = {StringType.class}, order=17, min=0, max=1, modifier=false, summary=false)
5017        @Description(shortDefinition="Request URL", formalDefinition="Complete request URL." )
5018        protected StringType url;
5019
5020        private static final long serialVersionUID = 308704897L;
5021
5022    /**
5023     * Constructor
5024     */
5025      public SetupActionOperationComponent() {
5026        super();
5027      }
5028
5029    /**
5030     * Constructor
5031     */
5032      public SetupActionOperationComponent(boolean encodeRequestUrl) {
5033        super();
5034        this.setEncodeRequestUrl(encodeRequestUrl);
5035      }
5036
5037        /**
5038         * @return {@link #type} (Server interaction or operation type.)
5039         */
5040        public Coding getType() { 
5041          if (this.type == null)
5042            if (Configuration.errorOnAutoCreate())
5043              throw new Error("Attempt to auto-create SetupActionOperationComponent.type");
5044            else if (Configuration.doAutoCreate())
5045              this.type = new Coding(); // cc
5046          return this.type;
5047        }
5048
5049        public boolean hasType() { 
5050          return this.type != null && !this.type.isEmpty();
5051        }
5052
5053        /**
5054         * @param value {@link #type} (Server interaction or operation type.)
5055         */
5056        public SetupActionOperationComponent setType(Coding value) { 
5057          this.type = value;
5058          return this;
5059        }
5060
5061        /**
5062         * @return {@link #resource} (The type of the FHIR resource. See the [resource list](resourcelist.html). Data type of uri is needed when non-HL7 artifacts are identified.). This is the underlying object with id, value and extensions. The accessor "getResource" gives direct access to the value
5063         */
5064        public UriType getResourceElement() { 
5065          if (this.resource == null)
5066            if (Configuration.errorOnAutoCreate())
5067              throw new Error("Attempt to auto-create SetupActionOperationComponent.resource");
5068            else if (Configuration.doAutoCreate())
5069              this.resource = new UriType(); // bb
5070          return this.resource;
5071        }
5072
5073        public boolean hasResourceElement() { 
5074          return this.resource != null && !this.resource.isEmpty();
5075        }
5076
5077        public boolean hasResource() { 
5078          return this.resource != null && !this.resource.isEmpty();
5079        }
5080
5081        /**
5082         * @param value {@link #resource} (The type of the FHIR resource. See the [resource list](resourcelist.html). Data type of uri is needed when non-HL7 artifacts are identified.). This is the underlying object with id, value and extensions. The accessor "getResource" gives direct access to the value
5083         */
5084        public SetupActionOperationComponent setResourceElement(UriType value) { 
5085          this.resource = value;
5086          return this;
5087        }
5088
5089        /**
5090         * @return The type of the FHIR resource. See the [resource list](resourcelist.html). Data type of uri is needed when non-HL7 artifacts are identified.
5091         */
5092        public String getResource() { 
5093          return this.resource == null ? null : this.resource.getValue();
5094        }
5095
5096        /**
5097         * @param value The type of the FHIR resource. See the [resource list](resourcelist.html). Data type of uri is needed when non-HL7 artifacts are identified.
5098         */
5099        public SetupActionOperationComponent setResource(String value) { 
5100          if (Utilities.noString(value))
5101            this.resource = null;
5102          else {
5103            if (this.resource == null)
5104              this.resource = new UriType();
5105            this.resource.setValue(value);
5106          }
5107          return this;
5108        }
5109
5110        /**
5111         * @return {@link #label} (The label would be used for tracking/logging purposes by test engines.). This is the underlying object with id, value and extensions. The accessor "getLabel" gives direct access to the value
5112         */
5113        public StringType getLabelElement() { 
5114          if (this.label == null)
5115            if (Configuration.errorOnAutoCreate())
5116              throw new Error("Attempt to auto-create SetupActionOperationComponent.label");
5117            else if (Configuration.doAutoCreate())
5118              this.label = new StringType(); // bb
5119          return this.label;
5120        }
5121
5122        public boolean hasLabelElement() { 
5123          return this.label != null && !this.label.isEmpty();
5124        }
5125
5126        public boolean hasLabel() { 
5127          return this.label != null && !this.label.isEmpty();
5128        }
5129
5130        /**
5131         * @param value {@link #label} (The label would be used for tracking/logging purposes by test engines.). This is the underlying object with id, value and extensions. The accessor "getLabel" gives direct access to the value
5132         */
5133        public SetupActionOperationComponent setLabelElement(StringType value) { 
5134          this.label = value;
5135          return this;
5136        }
5137
5138        /**
5139         * @return The label would be used for tracking/logging purposes by test engines.
5140         */
5141        public String getLabel() { 
5142          return this.label == null ? null : this.label.getValue();
5143        }
5144
5145        /**
5146         * @param value The label would be used for tracking/logging purposes by test engines.
5147         */
5148        public SetupActionOperationComponent setLabel(String value) { 
5149          if (Utilities.noString(value))
5150            this.label = null;
5151          else {
5152            if (this.label == null)
5153              this.label = new StringType();
5154            this.label.setValue(value);
5155          }
5156          return this;
5157        }
5158
5159        /**
5160         * @return {@link #description} (The description would be used by test engines for tracking and reporting purposes.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
5161         */
5162        public StringType getDescriptionElement() { 
5163          if (this.description == null)
5164            if (Configuration.errorOnAutoCreate())
5165              throw new Error("Attempt to auto-create SetupActionOperationComponent.description");
5166            else if (Configuration.doAutoCreate())
5167              this.description = new StringType(); // bb
5168          return this.description;
5169        }
5170
5171        public boolean hasDescriptionElement() { 
5172          return this.description != null && !this.description.isEmpty();
5173        }
5174
5175        public boolean hasDescription() { 
5176          return this.description != null && !this.description.isEmpty();
5177        }
5178
5179        /**
5180         * @param value {@link #description} (The description would be used by test engines for tracking and reporting purposes.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
5181         */
5182        public SetupActionOperationComponent setDescriptionElement(StringType value) { 
5183          this.description = value;
5184          return this;
5185        }
5186
5187        /**
5188         * @return The description would be used by test engines for tracking and reporting purposes.
5189         */
5190        public String getDescription() { 
5191          return this.description == null ? null : this.description.getValue();
5192        }
5193
5194        /**
5195         * @param value The description would be used by test engines for tracking and reporting purposes.
5196         */
5197        public SetupActionOperationComponent setDescription(String value) { 
5198          if (Utilities.noString(value))
5199            this.description = null;
5200          else {
5201            if (this.description == null)
5202              this.description = new StringType();
5203            this.description.setValue(value);
5204          }
5205          return this;
5206        }
5207
5208        /**
5209         * @return {@link #accept} (The mime-type to use for RESTful operation in the 'Accept' header.). This is the underlying object with id, value and extensions. The accessor "getAccept" gives direct access to the value
5210         */
5211        public CodeType getAcceptElement() { 
5212          if (this.accept == null)
5213            if (Configuration.errorOnAutoCreate())
5214              throw new Error("Attempt to auto-create SetupActionOperationComponent.accept");
5215            else if (Configuration.doAutoCreate())
5216              this.accept = new CodeType(); // bb
5217          return this.accept;
5218        }
5219
5220        public boolean hasAcceptElement() { 
5221          return this.accept != null && !this.accept.isEmpty();
5222        }
5223
5224        public boolean hasAccept() { 
5225          return this.accept != null && !this.accept.isEmpty();
5226        }
5227
5228        /**
5229         * @param value {@link #accept} (The mime-type to use for RESTful operation in the 'Accept' header.). This is the underlying object with id, value and extensions. The accessor "getAccept" gives direct access to the value
5230         */
5231        public SetupActionOperationComponent setAcceptElement(CodeType value) { 
5232          this.accept = value;
5233          return this;
5234        }
5235
5236        /**
5237         * @return The mime-type to use for RESTful operation in the 'Accept' header.
5238         */
5239        public String getAccept() { 
5240          return this.accept == null ? null : this.accept.getValue();
5241        }
5242
5243        /**
5244         * @param value The mime-type to use for RESTful operation in the 'Accept' header.
5245         */
5246        public SetupActionOperationComponent setAccept(String value) { 
5247          if (Utilities.noString(value))
5248            this.accept = null;
5249          else {
5250            if (this.accept == null)
5251              this.accept = new CodeType();
5252            this.accept.setValue(value);
5253          }
5254          return this;
5255        }
5256
5257        /**
5258         * @return {@link #contentType} (The mime-type to use for RESTful operation in the 'Content-Type' header.). This is the underlying object with id, value and extensions. The accessor "getContentType" gives direct access to the value
5259         */
5260        public CodeType getContentTypeElement() { 
5261          if (this.contentType == null)
5262            if (Configuration.errorOnAutoCreate())
5263              throw new Error("Attempt to auto-create SetupActionOperationComponent.contentType");
5264            else if (Configuration.doAutoCreate())
5265              this.contentType = new CodeType(); // bb
5266          return this.contentType;
5267        }
5268
5269        public boolean hasContentTypeElement() { 
5270          return this.contentType != null && !this.contentType.isEmpty();
5271        }
5272
5273        public boolean hasContentType() { 
5274          return this.contentType != null && !this.contentType.isEmpty();
5275        }
5276
5277        /**
5278         * @param value {@link #contentType} (The mime-type to use for RESTful operation in the 'Content-Type' header.). This is the underlying object with id, value and extensions. The accessor "getContentType" gives direct access to the value
5279         */
5280        public SetupActionOperationComponent setContentTypeElement(CodeType value) { 
5281          this.contentType = value;
5282          return this;
5283        }
5284
5285        /**
5286         * @return The mime-type to use for RESTful operation in the 'Content-Type' header.
5287         */
5288        public String getContentType() { 
5289          return this.contentType == null ? null : this.contentType.getValue();
5290        }
5291
5292        /**
5293         * @param value The mime-type to use for RESTful operation in the 'Content-Type' header.
5294         */
5295        public SetupActionOperationComponent setContentType(String value) { 
5296          if (Utilities.noString(value))
5297            this.contentType = null;
5298          else {
5299            if (this.contentType == null)
5300              this.contentType = new CodeType();
5301            this.contentType.setValue(value);
5302          }
5303          return this;
5304        }
5305
5306        /**
5307         * @return {@link #destination} (The server where the request message is destined for.  Must be one of the server numbers listed in TestScript.destination section.). This is the underlying object with id, value and extensions. The accessor "getDestination" gives direct access to the value
5308         */
5309        public IntegerType getDestinationElement() { 
5310          if (this.destination == null)
5311            if (Configuration.errorOnAutoCreate())
5312              throw new Error("Attempt to auto-create SetupActionOperationComponent.destination");
5313            else if (Configuration.doAutoCreate())
5314              this.destination = new IntegerType(); // bb
5315          return this.destination;
5316        }
5317
5318        public boolean hasDestinationElement() { 
5319          return this.destination != null && !this.destination.isEmpty();
5320        }
5321
5322        public boolean hasDestination() { 
5323          return this.destination != null && !this.destination.isEmpty();
5324        }
5325
5326        /**
5327         * @param value {@link #destination} (The server where the request message is destined for.  Must be one of the server numbers listed in TestScript.destination section.). This is the underlying object with id, value and extensions. The accessor "getDestination" gives direct access to the value
5328         */
5329        public SetupActionOperationComponent setDestinationElement(IntegerType value) { 
5330          this.destination = value;
5331          return this;
5332        }
5333
5334        /**
5335         * @return The server where the request message is destined for.  Must be one of the server numbers listed in TestScript.destination section.
5336         */
5337        public int getDestination() { 
5338          return this.destination == null || this.destination.isEmpty() ? 0 : this.destination.getValue();
5339        }
5340
5341        /**
5342         * @param value The server where the request message is destined for.  Must be one of the server numbers listed in TestScript.destination section.
5343         */
5344        public SetupActionOperationComponent setDestination(int value) { 
5345            if (this.destination == null)
5346              this.destination = new IntegerType();
5347            this.destination.setValue(value);
5348          return this;
5349        }
5350
5351        /**
5352         * @return {@link #encodeRequestUrl} (Whether or not to implicitly send the request url in encoded format. The default is true to match the standard RESTful client behavior. Set to false when communicating with a server that does not support encoded url paths.). This is the underlying object with id, value and extensions. The accessor "getEncodeRequestUrl" gives direct access to the value
5353         */
5354        public BooleanType getEncodeRequestUrlElement() { 
5355          if (this.encodeRequestUrl == null)
5356            if (Configuration.errorOnAutoCreate())
5357              throw new Error("Attempt to auto-create SetupActionOperationComponent.encodeRequestUrl");
5358            else if (Configuration.doAutoCreate())
5359              this.encodeRequestUrl = new BooleanType(); // bb
5360          return this.encodeRequestUrl;
5361        }
5362
5363        public boolean hasEncodeRequestUrlElement() { 
5364          return this.encodeRequestUrl != null && !this.encodeRequestUrl.isEmpty();
5365        }
5366
5367        public boolean hasEncodeRequestUrl() { 
5368          return this.encodeRequestUrl != null && !this.encodeRequestUrl.isEmpty();
5369        }
5370
5371        /**
5372         * @param value {@link #encodeRequestUrl} (Whether or not to implicitly send the request url in encoded format. The default is true to match the standard RESTful client behavior. Set to false when communicating with a server that does not support encoded url paths.). This is the underlying object with id, value and extensions. The accessor "getEncodeRequestUrl" gives direct access to the value
5373         */
5374        public SetupActionOperationComponent setEncodeRequestUrlElement(BooleanType value) { 
5375          this.encodeRequestUrl = value;
5376          return this;
5377        }
5378
5379        /**
5380         * @return Whether or not to implicitly send the request url in encoded format. The default is true to match the standard RESTful client behavior. Set to false when communicating with a server that does not support encoded url paths.
5381         */
5382        public boolean getEncodeRequestUrl() { 
5383          return this.encodeRequestUrl == null || this.encodeRequestUrl.isEmpty() ? false : this.encodeRequestUrl.getValue();
5384        }
5385
5386        /**
5387         * @param value Whether or not to implicitly send the request url in encoded format. The default is true to match the standard RESTful client behavior. Set to false when communicating with a server that does not support encoded url paths.
5388         */
5389        public SetupActionOperationComponent setEncodeRequestUrl(boolean value) { 
5390            if (this.encodeRequestUrl == null)
5391              this.encodeRequestUrl = new BooleanType();
5392            this.encodeRequestUrl.setValue(value);
5393          return this;
5394        }
5395
5396        /**
5397         * @return {@link #method} (The HTTP method the test engine MUST use for this operation regardless of any other operation details.). This is the underlying object with id, value and extensions. The accessor "getMethod" gives direct access to the value
5398         */
5399        public Enumeration<TestScriptRequestMethodCode> getMethodElement() { 
5400          if (this.method == null)
5401            if (Configuration.errorOnAutoCreate())
5402              throw new Error("Attempt to auto-create SetupActionOperationComponent.method");
5403            else if (Configuration.doAutoCreate())
5404              this.method = new Enumeration<TestScriptRequestMethodCode>(new TestScriptRequestMethodCodeEnumFactory()); // bb
5405          return this.method;
5406        }
5407
5408        public boolean hasMethodElement() { 
5409          return this.method != null && !this.method.isEmpty();
5410        }
5411
5412        public boolean hasMethod() { 
5413          return this.method != null && !this.method.isEmpty();
5414        }
5415
5416        /**
5417         * @param value {@link #method} (The HTTP method the test engine MUST use for this operation regardless of any other operation details.). This is the underlying object with id, value and extensions. The accessor "getMethod" gives direct access to the value
5418         */
5419        public SetupActionOperationComponent setMethodElement(Enumeration<TestScriptRequestMethodCode> value) { 
5420          this.method = value;
5421          return this;
5422        }
5423
5424        /**
5425         * @return The HTTP method the test engine MUST use for this operation regardless of any other operation details.
5426         */
5427        public TestScriptRequestMethodCode getMethod() { 
5428          return this.method == null ? null : this.method.getValue();
5429        }
5430
5431        /**
5432         * @param value The HTTP method the test engine MUST use for this operation regardless of any other operation details.
5433         */
5434        public SetupActionOperationComponent setMethod(TestScriptRequestMethodCode value) { 
5435          if (value == null)
5436            this.method = null;
5437          else {
5438            if (this.method == null)
5439              this.method = new Enumeration<TestScriptRequestMethodCode>(new TestScriptRequestMethodCodeEnumFactory());
5440            this.method.setValue(value);
5441          }
5442          return this;
5443        }
5444
5445        /**
5446         * @return {@link #origin} (The server where the request message originates from.  Must be one of the server numbers listed in TestScript.origin section.). This is the underlying object with id, value and extensions. The accessor "getOrigin" gives direct access to the value
5447         */
5448        public IntegerType getOriginElement() { 
5449          if (this.origin == null)
5450            if (Configuration.errorOnAutoCreate())
5451              throw new Error("Attempt to auto-create SetupActionOperationComponent.origin");
5452            else if (Configuration.doAutoCreate())
5453              this.origin = new IntegerType(); // bb
5454          return this.origin;
5455        }
5456
5457        public boolean hasOriginElement() { 
5458          return this.origin != null && !this.origin.isEmpty();
5459        }
5460
5461        public boolean hasOrigin() { 
5462          return this.origin != null && !this.origin.isEmpty();
5463        }
5464
5465        /**
5466         * @param value {@link #origin} (The server where the request message originates from.  Must be one of the server numbers listed in TestScript.origin section.). This is the underlying object with id, value and extensions. The accessor "getOrigin" gives direct access to the value
5467         */
5468        public SetupActionOperationComponent setOriginElement(IntegerType value) { 
5469          this.origin = value;
5470          return this;
5471        }
5472
5473        /**
5474         * @return The server where the request message originates from.  Must be one of the server numbers listed in TestScript.origin section.
5475         */
5476        public int getOrigin() { 
5477          return this.origin == null || this.origin.isEmpty() ? 0 : this.origin.getValue();
5478        }
5479
5480        /**
5481         * @param value The server where the request message originates from.  Must be one of the server numbers listed in TestScript.origin section.
5482         */
5483        public SetupActionOperationComponent setOrigin(int value) { 
5484            if (this.origin == null)
5485              this.origin = new IntegerType();
5486            this.origin.setValue(value);
5487          return this;
5488        }
5489
5490        /**
5491         * @return {@link #params} (Path plus parameters after [type].  Used to set parts of the request URL explicitly.). This is the underlying object with id, value and extensions. The accessor "getParams" gives direct access to the value
5492         */
5493        public StringType getParamsElement() { 
5494          if (this.params == null)
5495            if (Configuration.errorOnAutoCreate())
5496              throw new Error("Attempt to auto-create SetupActionOperationComponent.params");
5497            else if (Configuration.doAutoCreate())
5498              this.params = new StringType(); // bb
5499          return this.params;
5500        }
5501
5502        public boolean hasParamsElement() { 
5503          return this.params != null && !this.params.isEmpty();
5504        }
5505
5506        public boolean hasParams() { 
5507          return this.params != null && !this.params.isEmpty();
5508        }
5509
5510        /**
5511         * @param value {@link #params} (Path plus parameters after [type].  Used to set parts of the request URL explicitly.). This is the underlying object with id, value and extensions. The accessor "getParams" gives direct access to the value
5512         */
5513        public SetupActionOperationComponent setParamsElement(StringType value) { 
5514          this.params = value;
5515          return this;
5516        }
5517
5518        /**
5519         * @return Path plus parameters after [type].  Used to set parts of the request URL explicitly.
5520         */
5521        public String getParams() { 
5522          return this.params == null ? null : this.params.getValue();
5523        }
5524
5525        /**
5526         * @param value Path plus parameters after [type].  Used to set parts of the request URL explicitly.
5527         */
5528        public SetupActionOperationComponent setParams(String value) { 
5529          if (Utilities.noString(value))
5530            this.params = null;
5531          else {
5532            if (this.params == null)
5533              this.params = new StringType();
5534            this.params.setValue(value);
5535          }
5536          return this;
5537        }
5538
5539        /**
5540         * @return {@link #requestHeader} (Header elements would be used to set HTTP headers.)
5541         */
5542        public List<SetupActionOperationRequestHeaderComponent> getRequestHeader() { 
5543          if (this.requestHeader == null)
5544            this.requestHeader = new ArrayList<SetupActionOperationRequestHeaderComponent>();
5545          return this.requestHeader;
5546        }
5547
5548        /**
5549         * @return Returns a reference to <code>this</code> for easy method chaining
5550         */
5551        public SetupActionOperationComponent setRequestHeader(List<SetupActionOperationRequestHeaderComponent> theRequestHeader) { 
5552          this.requestHeader = theRequestHeader;
5553          return this;
5554        }
5555
5556        public boolean hasRequestHeader() { 
5557          if (this.requestHeader == null)
5558            return false;
5559          for (SetupActionOperationRequestHeaderComponent item : this.requestHeader)
5560            if (!item.isEmpty())
5561              return true;
5562          return false;
5563        }
5564
5565        public SetupActionOperationRequestHeaderComponent addRequestHeader() { //3
5566          SetupActionOperationRequestHeaderComponent t = new SetupActionOperationRequestHeaderComponent();
5567          if (this.requestHeader == null)
5568            this.requestHeader = new ArrayList<SetupActionOperationRequestHeaderComponent>();
5569          this.requestHeader.add(t);
5570          return t;
5571        }
5572
5573        public SetupActionOperationComponent addRequestHeader(SetupActionOperationRequestHeaderComponent t) { //3
5574          if (t == null)
5575            return this;
5576          if (this.requestHeader == null)
5577            this.requestHeader = new ArrayList<SetupActionOperationRequestHeaderComponent>();
5578          this.requestHeader.add(t);
5579          return this;
5580        }
5581
5582        /**
5583         * @return The first repetition of repeating field {@link #requestHeader}, creating it if it does not already exist {3}
5584         */
5585        public SetupActionOperationRequestHeaderComponent getRequestHeaderFirstRep() { 
5586          if (getRequestHeader().isEmpty()) {
5587            addRequestHeader();
5588          }
5589          return getRequestHeader().get(0);
5590        }
5591
5592        /**
5593         * @return {@link #requestId} (The fixture id (maybe new) to map to the request.). This is the underlying object with id, value and extensions. The accessor "getRequestId" gives direct access to the value
5594         */
5595        public IdType getRequestIdElement() { 
5596          if (this.requestId == null)
5597            if (Configuration.errorOnAutoCreate())
5598              throw new Error("Attempt to auto-create SetupActionOperationComponent.requestId");
5599            else if (Configuration.doAutoCreate())
5600              this.requestId = new IdType(); // bb
5601          return this.requestId;
5602        }
5603
5604        public boolean hasRequestIdElement() { 
5605          return this.requestId != null && !this.requestId.isEmpty();
5606        }
5607
5608        public boolean hasRequestId() { 
5609          return this.requestId != null && !this.requestId.isEmpty();
5610        }
5611
5612        /**
5613         * @param value {@link #requestId} (The fixture id (maybe new) to map to the request.). This is the underlying object with id, value and extensions. The accessor "getRequestId" gives direct access to the value
5614         */
5615        public SetupActionOperationComponent setRequestIdElement(IdType value) { 
5616          this.requestId = value;
5617          return this;
5618        }
5619
5620        /**
5621         * @return The fixture id (maybe new) to map to the request.
5622         */
5623        public String getRequestId() { 
5624          return this.requestId == null ? null : this.requestId.getValue();
5625        }
5626
5627        /**
5628         * @param value The fixture id (maybe new) to map to the request.
5629         */
5630        public SetupActionOperationComponent setRequestId(String value) { 
5631          if (Utilities.noString(value))
5632            this.requestId = null;
5633          else {
5634            if (this.requestId == null)
5635              this.requestId = new IdType();
5636            this.requestId.setValue(value);
5637          }
5638          return this;
5639        }
5640
5641        /**
5642         * @return {@link #responseId} (The fixture id (maybe new) to map to the response.). This is the underlying object with id, value and extensions. The accessor "getResponseId" gives direct access to the value
5643         */
5644        public IdType getResponseIdElement() { 
5645          if (this.responseId == null)
5646            if (Configuration.errorOnAutoCreate())
5647              throw new Error("Attempt to auto-create SetupActionOperationComponent.responseId");
5648            else if (Configuration.doAutoCreate())
5649              this.responseId = new IdType(); // bb
5650          return this.responseId;
5651        }
5652
5653        public boolean hasResponseIdElement() { 
5654          return this.responseId != null && !this.responseId.isEmpty();
5655        }
5656
5657        public boolean hasResponseId() { 
5658          return this.responseId != null && !this.responseId.isEmpty();
5659        }
5660
5661        /**
5662         * @param value {@link #responseId} (The fixture id (maybe new) to map to the response.). This is the underlying object with id, value and extensions. The accessor "getResponseId" gives direct access to the value
5663         */
5664        public SetupActionOperationComponent setResponseIdElement(IdType value) { 
5665          this.responseId = value;
5666          return this;
5667        }
5668
5669        /**
5670         * @return The fixture id (maybe new) to map to the response.
5671         */
5672        public String getResponseId() { 
5673          return this.responseId == null ? null : this.responseId.getValue();
5674        }
5675
5676        /**
5677         * @param value The fixture id (maybe new) to map to the response.
5678         */
5679        public SetupActionOperationComponent setResponseId(String value) { 
5680          if (Utilities.noString(value))
5681            this.responseId = null;
5682          else {
5683            if (this.responseId == null)
5684              this.responseId = new IdType();
5685            this.responseId.setValue(value);
5686          }
5687          return this;
5688        }
5689
5690        /**
5691         * @return {@link #sourceId} (The id of the fixture used as the body of a PUT or POST request.). This is the underlying object with id, value and extensions. The accessor "getSourceId" gives direct access to the value
5692         */
5693        public IdType getSourceIdElement() { 
5694          if (this.sourceId == null)
5695            if (Configuration.errorOnAutoCreate())
5696              throw new Error("Attempt to auto-create SetupActionOperationComponent.sourceId");
5697            else if (Configuration.doAutoCreate())
5698              this.sourceId = new IdType(); // bb
5699          return this.sourceId;
5700        }
5701
5702        public boolean hasSourceIdElement() { 
5703          return this.sourceId != null && !this.sourceId.isEmpty();
5704        }
5705
5706        public boolean hasSourceId() { 
5707          return this.sourceId != null && !this.sourceId.isEmpty();
5708        }
5709
5710        /**
5711         * @param value {@link #sourceId} (The id of the fixture used as the body of a PUT or POST request.). This is the underlying object with id, value and extensions. The accessor "getSourceId" gives direct access to the value
5712         */
5713        public SetupActionOperationComponent setSourceIdElement(IdType value) { 
5714          this.sourceId = value;
5715          return this;
5716        }
5717
5718        /**
5719         * @return The id of the fixture used as the body of a PUT or POST request.
5720         */
5721        public String getSourceId() { 
5722          return this.sourceId == null ? null : this.sourceId.getValue();
5723        }
5724
5725        /**
5726         * @param value The id of the fixture used as the body of a PUT or POST request.
5727         */
5728        public SetupActionOperationComponent setSourceId(String value) { 
5729          if (Utilities.noString(value))
5730            this.sourceId = null;
5731          else {
5732            if (this.sourceId == null)
5733              this.sourceId = new IdType();
5734            this.sourceId.setValue(value);
5735          }
5736          return this;
5737        }
5738
5739        /**
5740         * @return {@link #targetId} (Id of fixture used for extracting the [id],  [type], and [vid] for GET requests.). This is the underlying object with id, value and extensions. The accessor "getTargetId" gives direct access to the value
5741         */
5742        public IdType getTargetIdElement() { 
5743          if (this.targetId == null)
5744            if (Configuration.errorOnAutoCreate())
5745              throw new Error("Attempt to auto-create SetupActionOperationComponent.targetId");
5746            else if (Configuration.doAutoCreate())
5747              this.targetId = new IdType(); // bb
5748          return this.targetId;
5749        }
5750
5751        public boolean hasTargetIdElement() { 
5752          return this.targetId != null && !this.targetId.isEmpty();
5753        }
5754
5755        public boolean hasTargetId() { 
5756          return this.targetId != null && !this.targetId.isEmpty();
5757        }
5758
5759        /**
5760         * @param value {@link #targetId} (Id of fixture used for extracting the [id],  [type], and [vid] for GET requests.). This is the underlying object with id, value and extensions. The accessor "getTargetId" gives direct access to the value
5761         */
5762        public SetupActionOperationComponent setTargetIdElement(IdType value) { 
5763          this.targetId = value;
5764          return this;
5765        }
5766
5767        /**
5768         * @return Id of fixture used for extracting the [id],  [type], and [vid] for GET requests.
5769         */
5770        public String getTargetId() { 
5771          return this.targetId == null ? null : this.targetId.getValue();
5772        }
5773
5774        /**
5775         * @param value Id of fixture used for extracting the [id],  [type], and [vid] for GET requests.
5776         */
5777        public SetupActionOperationComponent setTargetId(String value) { 
5778          if (Utilities.noString(value))
5779            this.targetId = null;
5780          else {
5781            if (this.targetId == null)
5782              this.targetId = new IdType();
5783            this.targetId.setValue(value);
5784          }
5785          return this;
5786        }
5787
5788        /**
5789         * @return {@link #url} (Complete request URL.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
5790         */
5791        public StringType getUrlElement() { 
5792          if (this.url == null)
5793            if (Configuration.errorOnAutoCreate())
5794              throw new Error("Attempt to auto-create SetupActionOperationComponent.url");
5795            else if (Configuration.doAutoCreate())
5796              this.url = new StringType(); // bb
5797          return this.url;
5798        }
5799
5800        public boolean hasUrlElement() { 
5801          return this.url != null && !this.url.isEmpty();
5802        }
5803
5804        public boolean hasUrl() { 
5805          return this.url != null && !this.url.isEmpty();
5806        }
5807
5808        /**
5809         * @param value {@link #url} (Complete request URL.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
5810         */
5811        public SetupActionOperationComponent setUrlElement(StringType value) { 
5812          this.url = value;
5813          return this;
5814        }
5815
5816        /**
5817         * @return Complete request URL.
5818         */
5819        public String getUrl() { 
5820          return this.url == null ? null : this.url.getValue();
5821        }
5822
5823        /**
5824         * @param value Complete request URL.
5825         */
5826        public SetupActionOperationComponent setUrl(String value) { 
5827          if (Utilities.noString(value))
5828            this.url = null;
5829          else {
5830            if (this.url == null)
5831              this.url = new StringType();
5832            this.url.setValue(value);
5833          }
5834          return this;
5835        }
5836
5837        protected void listChildren(List<Property> children) {
5838          super.listChildren(children);
5839          children.add(new Property("type", "Coding", "Server interaction or operation type.", 0, 1, type));
5840          children.add(new Property("resource", "uri", "The type of the FHIR resource. See the [resource list](resourcelist.html). Data type of uri is needed when non-HL7 artifacts are identified.", 0, 1, resource));
5841          children.add(new Property("label", "string", "The label would be used for tracking/logging purposes by test engines.", 0, 1, label));
5842          children.add(new Property("description", "string", "The description would be used by test engines for tracking and reporting purposes.", 0, 1, description));
5843          children.add(new Property("accept", "code", "The mime-type to use for RESTful operation in the 'Accept' header.", 0, 1, accept));
5844          children.add(new Property("contentType", "code", "The mime-type to use for RESTful operation in the 'Content-Type' header.", 0, 1, contentType));
5845          children.add(new Property("destination", "integer", "The server where the request message is destined for.  Must be one of the server numbers listed in TestScript.destination section.", 0, 1, destination));
5846          children.add(new Property("encodeRequestUrl", "boolean", "Whether or not to implicitly send the request url in encoded format. The default is true to match the standard RESTful client behavior. Set to false when communicating with a server that does not support encoded url paths.", 0, 1, encodeRequestUrl));
5847          children.add(new Property("method", "code", "The HTTP method the test engine MUST use for this operation regardless of any other operation details.", 0, 1, method));
5848          children.add(new Property("origin", "integer", "The server where the request message originates from.  Must be one of the server numbers listed in TestScript.origin section.", 0, 1, origin));
5849          children.add(new Property("params", "string", "Path plus parameters after [type].  Used to set parts of the request URL explicitly.", 0, 1, params));
5850          children.add(new Property("requestHeader", "", "Header elements would be used to set HTTP headers.", 0, java.lang.Integer.MAX_VALUE, requestHeader));
5851          children.add(new Property("requestId", "id", "The fixture id (maybe new) to map to the request.", 0, 1, requestId));
5852          children.add(new Property("responseId", "id", "The fixture id (maybe new) to map to the response.", 0, 1, responseId));
5853          children.add(new Property("sourceId", "id", "The id of the fixture used as the body of a PUT or POST request.", 0, 1, sourceId));
5854          children.add(new Property("targetId", "id", "Id of fixture used for extracting the [id],  [type], and [vid] for GET requests.", 0, 1, targetId));
5855          children.add(new Property("url", "string", "Complete request URL.", 0, 1, url));
5856        }
5857
5858        @Override
5859        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
5860          switch (_hash) {
5861          case 3575610: /*type*/  return new Property("type", "Coding", "Server interaction or operation type.", 0, 1, type);
5862          case -341064690: /*resource*/  return new Property("resource", "uri", "The type of the FHIR resource. See the [resource list](resourcelist.html). Data type of uri is needed when non-HL7 artifacts are identified.", 0, 1, resource);
5863          case 102727412: /*label*/  return new Property("label", "string", "The label would be used for tracking/logging purposes by test engines.", 0, 1, label);
5864          case -1724546052: /*description*/  return new Property("description", "string", "The description would be used by test engines for tracking and reporting purposes.", 0, 1, description);
5865          case -1423461112: /*accept*/  return new Property("accept", "code", "The mime-type to use for RESTful operation in the 'Accept' header.", 0, 1, accept);
5866          case -389131437: /*contentType*/  return new Property("contentType", "code", "The mime-type to use for RESTful operation in the 'Content-Type' header.", 0, 1, contentType);
5867          case -1429847026: /*destination*/  return new Property("destination", "integer", "The server where the request message is destined for.  Must be one of the server numbers listed in TestScript.destination section.", 0, 1, destination);
5868          case -1760554218: /*encodeRequestUrl*/  return new Property("encodeRequestUrl", "boolean", "Whether or not to implicitly send the request url in encoded format. The default is true to match the standard RESTful client behavior. Set to false when communicating with a server that does not support encoded url paths.", 0, 1, encodeRequestUrl);
5869          case -1077554975: /*method*/  return new Property("method", "code", "The HTTP method the test engine MUST use for this operation regardless of any other operation details.", 0, 1, method);
5870          case -1008619738: /*origin*/  return new Property("origin", "integer", "The server where the request message originates from.  Must be one of the server numbers listed in TestScript.origin section.", 0, 1, origin);
5871          case -995427962: /*params*/  return new Property("params", "string", "Path plus parameters after [type].  Used to set parts of the request URL explicitly.", 0, 1, params);
5872          case 1074158076: /*requestHeader*/  return new Property("requestHeader", "", "Header elements would be used to set HTTP headers.", 0, java.lang.Integer.MAX_VALUE, requestHeader);
5873          case 693933066: /*requestId*/  return new Property("requestId", "id", "The fixture id (maybe new) to map to the request.", 0, 1, requestId);
5874          case -633138884: /*responseId*/  return new Property("responseId", "id", "The fixture id (maybe new) to map to the response.", 0, 1, responseId);
5875          case 1746327190: /*sourceId*/  return new Property("sourceId", "id", "The id of the fixture used as the body of a PUT or POST request.", 0, 1, sourceId);
5876          case -441951604: /*targetId*/  return new Property("targetId", "id", "Id of fixture used for extracting the [id],  [type], and [vid] for GET requests.", 0, 1, targetId);
5877          case 116079: /*url*/  return new Property("url", "string", "Complete request URL.", 0, 1, url);
5878          default: return super.getNamedProperty(_hash, _name, _checkValid);
5879          }
5880
5881        }
5882
5883      @Override
5884      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
5885        switch (hash) {
5886        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Coding
5887        case -341064690: /*resource*/ return this.resource == null ? new Base[0] : new Base[] {this.resource}; // UriType
5888        case 102727412: /*label*/ return this.label == null ? new Base[0] : new Base[] {this.label}; // StringType
5889        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType
5890        case -1423461112: /*accept*/ return this.accept == null ? new Base[0] : new Base[] {this.accept}; // CodeType
5891        case -389131437: /*contentType*/ return this.contentType == null ? new Base[0] : new Base[] {this.contentType}; // CodeType
5892        case -1429847026: /*destination*/ return this.destination == null ? new Base[0] : new Base[] {this.destination}; // IntegerType
5893        case -1760554218: /*encodeRequestUrl*/ return this.encodeRequestUrl == null ? new Base[0] : new Base[] {this.encodeRequestUrl}; // BooleanType
5894        case -1077554975: /*method*/ return this.method == null ? new Base[0] : new Base[] {this.method}; // Enumeration<TestScriptRequestMethodCode>
5895        case -1008619738: /*origin*/ return this.origin == null ? new Base[0] : new Base[] {this.origin}; // IntegerType
5896        case -995427962: /*params*/ return this.params == null ? new Base[0] : new Base[] {this.params}; // StringType
5897        case 1074158076: /*requestHeader*/ return this.requestHeader == null ? new Base[0] : this.requestHeader.toArray(new Base[this.requestHeader.size()]); // SetupActionOperationRequestHeaderComponent
5898        case 693933066: /*requestId*/ return this.requestId == null ? new Base[0] : new Base[] {this.requestId}; // IdType
5899        case -633138884: /*responseId*/ return this.responseId == null ? new Base[0] : new Base[] {this.responseId}; // IdType
5900        case 1746327190: /*sourceId*/ return this.sourceId == null ? new Base[0] : new Base[] {this.sourceId}; // IdType
5901        case -441951604: /*targetId*/ return this.targetId == null ? new Base[0] : new Base[] {this.targetId}; // IdType
5902        case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // StringType
5903        default: return super.getProperty(hash, name, checkValid);
5904        }
5905
5906      }
5907
5908      @Override
5909      public Base setProperty(int hash, String name, Base value) throws FHIRException {
5910        switch (hash) {
5911        case 3575610: // type
5912          this.type = TypeConvertor.castToCoding(value); // Coding
5913          return value;
5914        case -341064690: // resource
5915          this.resource = TypeConvertor.castToUri(value); // UriType
5916          return value;
5917        case 102727412: // label
5918          this.label = TypeConvertor.castToString(value); // StringType
5919          return value;
5920        case -1724546052: // description
5921          this.description = TypeConvertor.castToString(value); // StringType
5922          return value;
5923        case -1423461112: // accept
5924          this.accept = TypeConvertor.castToCode(value); // CodeType
5925          return value;
5926        case -389131437: // contentType
5927          this.contentType = TypeConvertor.castToCode(value); // CodeType
5928          return value;
5929        case -1429847026: // destination
5930          this.destination = TypeConvertor.castToInteger(value); // IntegerType
5931          return value;
5932        case -1760554218: // encodeRequestUrl
5933          this.encodeRequestUrl = TypeConvertor.castToBoolean(value); // BooleanType
5934          return value;
5935        case -1077554975: // method
5936          value = new TestScriptRequestMethodCodeEnumFactory().fromType(TypeConvertor.castToCode(value));
5937          this.method = (Enumeration) value; // Enumeration<TestScriptRequestMethodCode>
5938          return value;
5939        case -1008619738: // origin
5940          this.origin = TypeConvertor.castToInteger(value); // IntegerType
5941          return value;
5942        case -995427962: // params
5943          this.params = TypeConvertor.castToString(value); // StringType
5944          return value;
5945        case 1074158076: // requestHeader
5946          this.getRequestHeader().add((SetupActionOperationRequestHeaderComponent) value); // SetupActionOperationRequestHeaderComponent
5947          return value;
5948        case 693933066: // requestId
5949          this.requestId = TypeConvertor.castToId(value); // IdType
5950          return value;
5951        case -633138884: // responseId
5952          this.responseId = TypeConvertor.castToId(value); // IdType
5953          return value;
5954        case 1746327190: // sourceId
5955          this.sourceId = TypeConvertor.castToId(value); // IdType
5956          return value;
5957        case -441951604: // targetId
5958          this.targetId = TypeConvertor.castToId(value); // IdType
5959          return value;
5960        case 116079: // url
5961          this.url = TypeConvertor.castToString(value); // StringType
5962          return value;
5963        default: return super.setProperty(hash, name, value);
5964        }
5965
5966      }
5967
5968      @Override
5969      public Base setProperty(String name, Base value) throws FHIRException {
5970        if (name.equals("type")) {
5971          this.type = TypeConvertor.castToCoding(value); // Coding
5972        } else if (name.equals("resource")) {
5973          this.resource = TypeConvertor.castToUri(value); // UriType
5974        } else if (name.equals("label")) {
5975          this.label = TypeConvertor.castToString(value); // StringType
5976        } else if (name.equals("description")) {
5977          this.description = TypeConvertor.castToString(value); // StringType
5978        } else if (name.equals("accept")) {
5979          this.accept = TypeConvertor.castToCode(value); // CodeType
5980        } else if (name.equals("contentType")) {
5981          this.contentType = TypeConvertor.castToCode(value); // CodeType
5982        } else if (name.equals("destination")) {
5983          this.destination = TypeConvertor.castToInteger(value); // IntegerType
5984        } else if (name.equals("encodeRequestUrl")) {
5985          this.encodeRequestUrl = TypeConvertor.castToBoolean(value); // BooleanType
5986        } else if (name.equals("method")) {
5987          value = new TestScriptRequestMethodCodeEnumFactory().fromType(TypeConvertor.castToCode(value));
5988          this.method = (Enumeration) value; // Enumeration<TestScriptRequestMethodCode>
5989        } else if (name.equals("origin")) {
5990          this.origin = TypeConvertor.castToInteger(value); // IntegerType
5991        } else if (name.equals("params")) {
5992          this.params = TypeConvertor.castToString(value); // StringType
5993        } else if (name.equals("requestHeader")) {
5994          this.getRequestHeader().add((SetupActionOperationRequestHeaderComponent) value);
5995        } else if (name.equals("requestId")) {
5996          this.requestId = TypeConvertor.castToId(value); // IdType
5997        } else if (name.equals("responseId")) {
5998          this.responseId = TypeConvertor.castToId(value); // IdType
5999        } else if (name.equals("sourceId")) {
6000          this.sourceId = TypeConvertor.castToId(value); // IdType
6001        } else if (name.equals("targetId")) {
6002          this.targetId = TypeConvertor.castToId(value); // IdType
6003        } else if (name.equals("url")) {
6004          this.url = TypeConvertor.castToString(value); // StringType
6005        } else
6006          return super.setProperty(name, value);
6007        return value;
6008      }
6009
6010      @Override
6011      public Base makeProperty(int hash, String name) throws FHIRException {
6012        switch (hash) {
6013        case 3575610:  return getType();
6014        case -341064690:  return getResourceElement();
6015        case 102727412:  return getLabelElement();
6016        case -1724546052:  return getDescriptionElement();
6017        case -1423461112:  return getAcceptElement();
6018        case -389131437:  return getContentTypeElement();
6019        case -1429847026:  return getDestinationElement();
6020        case -1760554218:  return getEncodeRequestUrlElement();
6021        case -1077554975:  return getMethodElement();
6022        case -1008619738:  return getOriginElement();
6023        case -995427962:  return getParamsElement();
6024        case 1074158076:  return addRequestHeader(); 
6025        case 693933066:  return getRequestIdElement();
6026        case -633138884:  return getResponseIdElement();
6027        case 1746327190:  return getSourceIdElement();
6028        case -441951604:  return getTargetIdElement();
6029        case 116079:  return getUrlElement();
6030        default: return super.makeProperty(hash, name);
6031        }
6032
6033      }
6034
6035      @Override
6036      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
6037        switch (hash) {
6038        case 3575610: /*type*/ return new String[] {"Coding"};
6039        case -341064690: /*resource*/ return new String[] {"uri"};
6040        case 102727412: /*label*/ return new String[] {"string"};
6041        case -1724546052: /*description*/ return new String[] {"string"};
6042        case -1423461112: /*accept*/ return new String[] {"code"};
6043        case -389131437: /*contentType*/ return new String[] {"code"};
6044        case -1429847026: /*destination*/ return new String[] {"integer"};
6045        case -1760554218: /*encodeRequestUrl*/ return new String[] {"boolean"};
6046        case -1077554975: /*method*/ return new String[] {"code"};
6047        case -1008619738: /*origin*/ return new String[] {"integer"};
6048        case -995427962: /*params*/ return new String[] {"string"};
6049        case 1074158076: /*requestHeader*/ return new String[] {};
6050        case 693933066: /*requestId*/ return new String[] {"id"};
6051        case -633138884: /*responseId*/ return new String[] {"id"};
6052        case 1746327190: /*sourceId*/ return new String[] {"id"};
6053        case -441951604: /*targetId*/ return new String[] {"id"};
6054        case 116079: /*url*/ return new String[] {"string"};
6055        default: return super.getTypesForProperty(hash, name);
6056        }
6057
6058      }
6059
6060      @Override
6061      public Base addChild(String name) throws FHIRException {
6062        if (name.equals("type")) {
6063          this.type = new Coding();
6064          return this.type;
6065        }
6066        else if (name.equals("resource")) {
6067          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.operation.resource");
6068        }
6069        else if (name.equals("label")) {
6070          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.operation.label");
6071        }
6072        else if (name.equals("description")) {
6073          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.operation.description");
6074        }
6075        else if (name.equals("accept")) {
6076          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.operation.accept");
6077        }
6078        else if (name.equals("contentType")) {
6079          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.operation.contentType");
6080        }
6081        else if (name.equals("destination")) {
6082          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.operation.destination");
6083        }
6084        else if (name.equals("encodeRequestUrl")) {
6085          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.operation.encodeRequestUrl");
6086        }
6087        else if (name.equals("method")) {
6088          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.operation.method");
6089        }
6090        else if (name.equals("origin")) {
6091          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.operation.origin");
6092        }
6093        else if (name.equals("params")) {
6094          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.operation.params");
6095        }
6096        else if (name.equals("requestHeader")) {
6097          return addRequestHeader();
6098        }
6099        else if (name.equals("requestId")) {
6100          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.operation.requestId");
6101        }
6102        else if (name.equals("responseId")) {
6103          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.operation.responseId");
6104        }
6105        else if (name.equals("sourceId")) {
6106          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.operation.sourceId");
6107        }
6108        else if (name.equals("targetId")) {
6109          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.operation.targetId");
6110        }
6111        else if (name.equals("url")) {
6112          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.operation.url");
6113        }
6114        else
6115          return super.addChild(name);
6116      }
6117
6118      public SetupActionOperationComponent copy() {
6119        SetupActionOperationComponent dst = new SetupActionOperationComponent();
6120        copyValues(dst);
6121        return dst;
6122      }
6123
6124      public void copyValues(SetupActionOperationComponent dst) {
6125        super.copyValues(dst);
6126        dst.type = type == null ? null : type.copy();
6127        dst.resource = resource == null ? null : resource.copy();
6128        dst.label = label == null ? null : label.copy();
6129        dst.description = description == null ? null : description.copy();
6130        dst.accept = accept == null ? null : accept.copy();
6131        dst.contentType = contentType == null ? null : contentType.copy();
6132        dst.destination = destination == null ? null : destination.copy();
6133        dst.encodeRequestUrl = encodeRequestUrl == null ? null : encodeRequestUrl.copy();
6134        dst.method = method == null ? null : method.copy();
6135        dst.origin = origin == null ? null : origin.copy();
6136        dst.params = params == null ? null : params.copy();
6137        if (requestHeader != null) {
6138          dst.requestHeader = new ArrayList<SetupActionOperationRequestHeaderComponent>();
6139          for (SetupActionOperationRequestHeaderComponent i : requestHeader)
6140            dst.requestHeader.add(i.copy());
6141        };
6142        dst.requestId = requestId == null ? null : requestId.copy();
6143        dst.responseId = responseId == null ? null : responseId.copy();
6144        dst.sourceId = sourceId == null ? null : sourceId.copy();
6145        dst.targetId = targetId == null ? null : targetId.copy();
6146        dst.url = url == null ? null : url.copy();
6147      }
6148
6149      @Override
6150      public boolean equalsDeep(Base other_) {
6151        if (!super.equalsDeep(other_))
6152          return false;
6153        if (!(other_ instanceof SetupActionOperationComponent))
6154          return false;
6155        SetupActionOperationComponent o = (SetupActionOperationComponent) other_;
6156        return compareDeep(type, o.type, true) && compareDeep(resource, o.resource, true) && compareDeep(label, o.label, true)
6157           && compareDeep(description, o.description, true) && compareDeep(accept, o.accept, true) && compareDeep(contentType, o.contentType, true)
6158           && compareDeep(destination, o.destination, true) && compareDeep(encodeRequestUrl, o.encodeRequestUrl, true)
6159           && compareDeep(method, o.method, true) && compareDeep(origin, o.origin, true) && compareDeep(params, o.params, true)
6160           && compareDeep(requestHeader, o.requestHeader, true) && compareDeep(requestId, o.requestId, true)
6161           && compareDeep(responseId, o.responseId, true) && compareDeep(sourceId, o.sourceId, true) && compareDeep(targetId, o.targetId, true)
6162           && compareDeep(url, o.url, true);
6163      }
6164
6165      @Override
6166      public boolean equalsShallow(Base other_) {
6167        if (!super.equalsShallow(other_))
6168          return false;
6169        if (!(other_ instanceof SetupActionOperationComponent))
6170          return false;
6171        SetupActionOperationComponent o = (SetupActionOperationComponent) other_;
6172        return compareValues(resource, o.resource, true) && compareValues(label, o.label, true) && compareValues(description, o.description, true)
6173           && compareValues(accept, o.accept, true) && compareValues(contentType, o.contentType, true) && compareValues(destination, o.destination, true)
6174           && compareValues(encodeRequestUrl, o.encodeRequestUrl, true) && compareValues(method, o.method, true)
6175           && compareValues(origin, o.origin, true) && compareValues(params, o.params, true) && compareValues(requestId, o.requestId, true)
6176           && compareValues(responseId, o.responseId, true) && compareValues(sourceId, o.sourceId, true) && compareValues(targetId, o.targetId, true)
6177           && compareValues(url, o.url, true);
6178      }
6179
6180      public boolean isEmpty() {
6181        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(type, resource, label, description
6182          , accept, contentType, destination, encodeRequestUrl, method, origin, params, requestHeader
6183          , requestId, responseId, sourceId, targetId, url);
6184      }
6185
6186  public String fhirType() {
6187    return "TestScript.setup.action.operation";
6188
6189  }
6190
6191  }
6192
6193    @Block()
6194    public static class SetupActionOperationRequestHeaderComponent extends BackboneElement implements IBaseBackboneElement {
6195        /**
6196         * The HTTP header field e.g. "Accept".
6197         */
6198        @Child(name = "field", type = {StringType.class}, order=1, min=1, max=1, modifier=false, summary=false)
6199        @Description(shortDefinition="HTTP header field name", formalDefinition="The HTTP header field e.g. \"Accept\"." )
6200        protected StringType field;
6201
6202        /**
6203         * The value of the header e.g. "application/fhir+xml".
6204         */
6205        @Child(name = "value", type = {StringType.class}, order=2, min=1, max=1, modifier=false, summary=false)
6206        @Description(shortDefinition="HTTP headerfield value", formalDefinition="The value of the header e.g. \"application/fhir+xml\"." )
6207        protected StringType value;
6208
6209        private static final long serialVersionUID = 274395337L;
6210
6211    /**
6212     * Constructor
6213     */
6214      public SetupActionOperationRequestHeaderComponent() {
6215        super();
6216      }
6217
6218    /**
6219     * Constructor
6220     */
6221      public SetupActionOperationRequestHeaderComponent(String field, String value) {
6222        super();
6223        this.setField(field);
6224        this.setValue(value);
6225      }
6226
6227        /**
6228         * @return {@link #field} (The HTTP header field e.g. "Accept".). This is the underlying object with id, value and extensions. The accessor "getField" gives direct access to the value
6229         */
6230        public StringType getFieldElement() { 
6231          if (this.field == null)
6232            if (Configuration.errorOnAutoCreate())
6233              throw new Error("Attempt to auto-create SetupActionOperationRequestHeaderComponent.field");
6234            else if (Configuration.doAutoCreate())
6235              this.field = new StringType(); // bb
6236          return this.field;
6237        }
6238
6239        public boolean hasFieldElement() { 
6240          return this.field != null && !this.field.isEmpty();
6241        }
6242
6243        public boolean hasField() { 
6244          return this.field != null && !this.field.isEmpty();
6245        }
6246
6247        /**
6248         * @param value {@link #field} (The HTTP header field e.g. "Accept".). This is the underlying object with id, value and extensions. The accessor "getField" gives direct access to the value
6249         */
6250        public SetupActionOperationRequestHeaderComponent setFieldElement(StringType value) { 
6251          this.field = value;
6252          return this;
6253        }
6254
6255        /**
6256         * @return The HTTP header field e.g. "Accept".
6257         */
6258        public String getField() { 
6259          return this.field == null ? null : this.field.getValue();
6260        }
6261
6262        /**
6263         * @param value The HTTP header field e.g. "Accept".
6264         */
6265        public SetupActionOperationRequestHeaderComponent setField(String value) { 
6266            if (this.field == null)
6267              this.field = new StringType();
6268            this.field.setValue(value);
6269          return this;
6270        }
6271
6272        /**
6273         * @return {@link #value} (The value of the header e.g. "application/fhir+xml".). This is the underlying object with id, value and extensions. The accessor "getValue" gives direct access to the value
6274         */
6275        public StringType getValueElement() { 
6276          if (this.value == null)
6277            if (Configuration.errorOnAutoCreate())
6278              throw new Error("Attempt to auto-create SetupActionOperationRequestHeaderComponent.value");
6279            else if (Configuration.doAutoCreate())
6280              this.value = new StringType(); // bb
6281          return this.value;
6282        }
6283
6284        public boolean hasValueElement() { 
6285          return this.value != null && !this.value.isEmpty();
6286        }
6287
6288        public boolean hasValue() { 
6289          return this.value != null && !this.value.isEmpty();
6290        }
6291
6292        /**
6293         * @param value {@link #value} (The value of the header e.g. "application/fhir+xml".). This is the underlying object with id, value and extensions. The accessor "getValue" gives direct access to the value
6294         */
6295        public SetupActionOperationRequestHeaderComponent setValueElement(StringType value) { 
6296          this.value = value;
6297          return this;
6298        }
6299
6300        /**
6301         * @return The value of the header e.g. "application/fhir+xml".
6302         */
6303        public String getValue() { 
6304          return this.value == null ? null : this.value.getValue();
6305        }
6306
6307        /**
6308         * @param value The value of the header e.g. "application/fhir+xml".
6309         */
6310        public SetupActionOperationRequestHeaderComponent setValue(String value) { 
6311            if (this.value == null)
6312              this.value = new StringType();
6313            this.value.setValue(value);
6314          return this;
6315        }
6316
6317        protected void listChildren(List<Property> children) {
6318          super.listChildren(children);
6319          children.add(new Property("field", "string", "The HTTP header field e.g. \"Accept\".", 0, 1, field));
6320          children.add(new Property("value", "string", "The value of the header e.g. \"application/fhir+xml\".", 0, 1, value));
6321        }
6322
6323        @Override
6324        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
6325          switch (_hash) {
6326          case 97427706: /*field*/  return new Property("field", "string", "The HTTP header field e.g. \"Accept\".", 0, 1, field);
6327          case 111972721: /*value*/  return new Property("value", "string", "The value of the header e.g. \"application/fhir+xml\".", 0, 1, value);
6328          default: return super.getNamedProperty(_hash, _name, _checkValid);
6329          }
6330
6331        }
6332
6333      @Override
6334      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
6335        switch (hash) {
6336        case 97427706: /*field*/ return this.field == null ? new Base[0] : new Base[] {this.field}; // StringType
6337        case 111972721: /*value*/ return this.value == null ? new Base[0] : new Base[] {this.value}; // StringType
6338        default: return super.getProperty(hash, name, checkValid);
6339        }
6340
6341      }
6342
6343      @Override
6344      public Base setProperty(int hash, String name, Base value) throws FHIRException {
6345        switch (hash) {
6346        case 97427706: // field
6347          this.field = TypeConvertor.castToString(value); // StringType
6348          return value;
6349        case 111972721: // value
6350          this.value = TypeConvertor.castToString(value); // StringType
6351          return value;
6352        default: return super.setProperty(hash, name, value);
6353        }
6354
6355      }
6356
6357      @Override
6358      public Base setProperty(String name, Base value) throws FHIRException {
6359        if (name.equals("field")) {
6360          this.field = TypeConvertor.castToString(value); // StringType
6361        } else if (name.equals("value")) {
6362          this.value = TypeConvertor.castToString(value); // StringType
6363        } else
6364          return super.setProperty(name, value);
6365        return value;
6366      }
6367
6368      @Override
6369      public Base makeProperty(int hash, String name) throws FHIRException {
6370        switch (hash) {
6371        case 97427706:  return getFieldElement();
6372        case 111972721:  return getValueElement();
6373        default: return super.makeProperty(hash, name);
6374        }
6375
6376      }
6377
6378      @Override
6379      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
6380        switch (hash) {
6381        case 97427706: /*field*/ return new String[] {"string"};
6382        case 111972721: /*value*/ return new String[] {"string"};
6383        default: return super.getTypesForProperty(hash, name);
6384        }
6385
6386      }
6387
6388      @Override
6389      public Base addChild(String name) throws FHIRException {
6390        if (name.equals("field")) {
6391          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.operation.requestHeader.field");
6392        }
6393        else if (name.equals("value")) {
6394          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.operation.requestHeader.value");
6395        }
6396        else
6397          return super.addChild(name);
6398      }
6399
6400      public SetupActionOperationRequestHeaderComponent copy() {
6401        SetupActionOperationRequestHeaderComponent dst = new SetupActionOperationRequestHeaderComponent();
6402        copyValues(dst);
6403        return dst;
6404      }
6405
6406      public void copyValues(SetupActionOperationRequestHeaderComponent dst) {
6407        super.copyValues(dst);
6408        dst.field = field == null ? null : field.copy();
6409        dst.value = value == null ? null : value.copy();
6410      }
6411
6412      @Override
6413      public boolean equalsDeep(Base other_) {
6414        if (!super.equalsDeep(other_))
6415          return false;
6416        if (!(other_ instanceof SetupActionOperationRequestHeaderComponent))
6417          return false;
6418        SetupActionOperationRequestHeaderComponent o = (SetupActionOperationRequestHeaderComponent) other_;
6419        return compareDeep(field, o.field, true) && compareDeep(value, o.value, true);
6420      }
6421
6422      @Override
6423      public boolean equalsShallow(Base other_) {
6424        if (!super.equalsShallow(other_))
6425          return false;
6426        if (!(other_ instanceof SetupActionOperationRequestHeaderComponent))
6427          return false;
6428        SetupActionOperationRequestHeaderComponent o = (SetupActionOperationRequestHeaderComponent) other_;
6429        return compareValues(field, o.field, true) && compareValues(value, o.value, true);
6430      }
6431
6432      public boolean isEmpty() {
6433        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(field, value);
6434      }
6435
6436  public String fhirType() {
6437    return "TestScript.setup.action.operation.requestHeader";
6438
6439  }
6440
6441  }
6442
6443    @Block()
6444    public static class SetupActionAssertComponent extends BackboneElement implements IBaseBackboneElement {
6445        /**
6446         * The label would be used for tracking/logging purposes by test engines.
6447         */
6448        @Child(name = "label", type = {StringType.class}, order=1, min=0, max=1, modifier=false, summary=false)
6449        @Description(shortDefinition="Tracking/logging assertion label", formalDefinition="The label would be used for tracking/logging purposes by test engines." )
6450        protected StringType label;
6451
6452        /**
6453         * The description would be used by test engines for tracking and reporting purposes.
6454         */
6455        @Child(name = "description", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=false)
6456        @Description(shortDefinition="Tracking/reporting assertion description", formalDefinition="The description would be used by test engines for tracking and reporting purposes." )
6457        protected StringType description;
6458
6459        /**
6460         * The direction to use for the assertion.
6461         */
6462        @Child(name = "direction", type = {CodeType.class}, order=3, min=0, max=1, modifier=false, summary=false)
6463        @Description(shortDefinition="response | request", formalDefinition="The direction to use for the assertion." )
6464        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/assert-direction-codes")
6465        protected Enumeration<AssertionDirectionType> direction;
6466
6467        /**
6468         * Id of the source fixture used as the contents to be evaluated by either the "source/expression" or "sourceId/path" definition.
6469         */
6470        @Child(name = "compareToSourceId", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=false)
6471        @Description(shortDefinition="Id of the source fixture to be evaluated", formalDefinition="Id of the source fixture used as the contents to be evaluated by either the \"source/expression\" or \"sourceId/path\" definition." )
6472        protected StringType compareToSourceId;
6473
6474        /**
6475         * The FHIRPath expression for a specific value to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.
6476         */
6477        @Child(name = "compareToSourceExpression", type = {StringType.class}, order=5, min=0, max=1, modifier=false, summary=false)
6478        @Description(shortDefinition="The FHIRPath expression to evaluate against the source fixture", formalDefinition="The FHIRPath expression for a specific value to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both." )
6479        protected StringType compareToSourceExpression;
6480
6481        /**
6482         * XPath or JSONPath expression to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.
6483         */
6484        @Child(name = "compareToSourcePath", type = {StringType.class}, order=6, min=0, max=1, modifier=false, summary=false)
6485        @Description(shortDefinition="XPath or JSONPath expression to evaluate against the source fixture", formalDefinition="XPath or JSONPath expression to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both." )
6486        protected StringType compareToSourcePath;
6487
6488        /**
6489         * The mime-type contents to compare against the request or response message 'Content-Type' header.
6490         */
6491        @Child(name = "contentType", type = {CodeType.class}, order=7, min=0, max=1, modifier=false, summary=false)
6492        @Description(shortDefinition="Mime type to compare against the 'Content-Type' header", formalDefinition="The mime-type contents to compare against the request or response message 'Content-Type' header." )
6493        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/mimetypes")
6494        protected CodeType contentType;
6495
6496        /**
6497         * The default manual completion outcome applied to this assertion.
6498         */
6499        @Child(name = "defaultManualCompletion", type = {CodeType.class}, order=8, min=0, max=1, modifier=false, summary=false)
6500        @Description(shortDefinition="fail | pass | skip | stop", formalDefinition="The default manual completion outcome applied to this assertion." )
6501        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/assert-manual-completion-codes")
6502        protected Enumeration<AssertionManualCompletionType> defaultManualCompletion;
6503
6504        /**
6505         * The FHIRPath expression to be evaluated against the request or response message contents - HTTP headers and payload.
6506         */
6507        @Child(name = "expression", type = {StringType.class}, order=9, min=0, max=1, modifier=false, summary=false)
6508        @Description(shortDefinition="The FHIRPath expression to be evaluated", formalDefinition="The FHIRPath expression to be evaluated against the request or response message contents - HTTP headers and payload." )
6509        protected StringType expression;
6510
6511        /**
6512         * The HTTP header field name e.g. 'Location'.
6513         */
6514        @Child(name = "headerField", type = {StringType.class}, order=10, min=0, max=1, modifier=false, summary=false)
6515        @Description(shortDefinition="HTTP header field name", formalDefinition="The HTTP header field name e.g. 'Location'." )
6516        protected StringType headerField;
6517
6518        /**
6519         * The ID of a fixture. Asserts that the response contains at a minimum the fixture specified by minimumId.
6520         */
6521        @Child(name = "minimumId", type = {StringType.class}, order=11, min=0, max=1, modifier=false, summary=false)
6522        @Description(shortDefinition="Fixture Id of minimum content resource", formalDefinition="The ID of a fixture. Asserts that the response contains at a minimum the fixture specified by minimumId." )
6523        protected StringType minimumId;
6524
6525        /**
6526         * Whether or not the test execution performs validation on the bundle navigation links.
6527         */
6528        @Child(name = "navigationLinks", type = {BooleanType.class}, order=12, min=0, max=1, modifier=false, summary=false)
6529        @Description(shortDefinition="Perform validation on navigation links?", formalDefinition="Whether or not the test execution performs validation on the bundle navigation links." )
6530        protected BooleanType navigationLinks;
6531
6532        /**
6533         * The operator type defines the conditional behavior of the assert.
6534         */
6535        @Child(name = "operator", type = {CodeType.class}, order=13, min=0, max=1, modifier=false, summary=false)
6536        @Description(shortDefinition="equals | notEquals | in | notIn | greaterThan | lessThan | empty | notEmpty | contains | notContains | eval | manualEval", formalDefinition="The operator type defines the conditional behavior of the assert." )
6537        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/assert-operator-codes")
6538        protected Enumeration<AssertionOperatorType> operator;
6539
6540        /**
6541         * The XPath or JSONPath expression to be evaluated against the fixture representing the response received from server.
6542         */
6543        @Child(name = "path", type = {StringType.class}, order=14, min=0, max=1, modifier=false, summary=false)
6544        @Description(shortDefinition="XPath or JSONPath expression", formalDefinition="The XPath or JSONPath expression to be evaluated against the fixture representing the response received from server." )
6545        protected StringType path;
6546
6547        /**
6548         * The request method or HTTP operation code to compare against that used by the client system under test.
6549         */
6550        @Child(name = "requestMethod", type = {CodeType.class}, order=15, min=0, max=1, modifier=false, summary=false)
6551        @Description(shortDefinition="delete | get | options | patch | post | put | head", formalDefinition="The request method or HTTP operation code to compare against that used by the client system under test." )
6552        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/http-operations")
6553        protected Enumeration<TestScriptRequestMethodCode> requestMethod;
6554
6555        /**
6556         * The value to use in a comparison against the request URL path string.
6557         */
6558        @Child(name = "requestURL", type = {StringType.class}, order=16, min=0, max=1, modifier=false, summary=false)
6559        @Description(shortDefinition="Request URL comparison value", formalDefinition="The value to use in a comparison against the request URL path string." )
6560        protected StringType requestURL;
6561
6562        /**
6563         * The type of the resource.  See the [resource list](resourcelist.html).
6564         */
6565        @Child(name = "resource", type = {UriType.class}, order=17, min=0, max=1, modifier=false, summary=false)
6566        @Description(shortDefinition="Resource type", formalDefinition="The type of the resource.  See the [resource list](resourcelist.html)." )
6567        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/concrete-fhir-types")
6568        protected UriType resource;
6569
6570        /**
6571         * continue | switchingProtocols | okay | created | accepted | nonAuthoritativeInformation | noContent | resetContent | partialContent | multipleChoices | movedPermanently | found | seeOther | notModified | useProxy | temporaryRedirect | permanentRedirect | badRequest | unauthorized | paymentRequired | forbidden | notFound | methodNotAllowed | notAcceptable | proxyAuthenticationRequired | requestTimeout | conflict | gone | lengthRequired | preconditionFailed | contentTooLarge | uriTooLong | unsupportedMediaType | rangeNotSatisfiable | expectationFailed | misdirectedRequest | unprocessableContent | upgradeRequired | internalServerError | notImplemented | badGateway | serviceUnavailable | gatewayTimeout | httpVersionNotSupported.
6572         */
6573        @Child(name = "response", type = {CodeType.class}, order=18, min=0, max=1, modifier=false, summary=false)
6574        @Description(shortDefinition="continue | switchingProtocols | okay | created | accepted | nonAuthoritativeInformation | noContent | resetContent | partialContent | multipleChoices | movedPermanently | found | seeOther | notModified | useProxy | temporaryRedirect | permanentRedirect | badRequest | unauthorized | paymentRequired | forbidden | notFound | methodNotAllowed | notAcceptable | proxyAuthenticationRequired | requestTimeout | conflict | gone | lengthRequired | preconditionFailed | contentTooLarge | uriTooLong | unsupportedMediaType | rangeNotSatisfiable | expectationFailed | misdirectedRequest | unprocessableContent | upgradeRequired | internalServerError | notImplemented | badGateway | serviceUnavailable | gatewayTimeout | httpVersionNotSupported", formalDefinition="continue | switchingProtocols | okay | created | accepted | nonAuthoritativeInformation | noContent | resetContent | partialContent | multipleChoices | movedPermanently | found | seeOther | notModified | useProxy | temporaryRedirect | permanentRedirect | badRequest | unauthorized | paymentRequired | forbidden | notFound | methodNotAllowed | notAcceptable | proxyAuthenticationRequired | requestTimeout | conflict | gone | lengthRequired | preconditionFailed | contentTooLarge | uriTooLong | unsupportedMediaType | rangeNotSatisfiable | expectationFailed | misdirectedRequest | unprocessableContent | upgradeRequired | internalServerError | notImplemented | badGateway | serviceUnavailable | gatewayTimeout | httpVersionNotSupported." )
6575        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/assert-response-code-types")
6576        protected Enumeration<AssertionResponseTypes> response;
6577
6578        /**
6579         * The value of the HTTP response code to be tested.
6580         */
6581        @Child(name = "responseCode", type = {StringType.class}, order=19, min=0, max=1, modifier=false, summary=false)
6582        @Description(shortDefinition="HTTP response code to test", formalDefinition="The value of the HTTP response code to be tested." )
6583        protected StringType responseCode;
6584
6585        /**
6586         * Fixture to evaluate the XPath/JSONPath expression or the headerField  against.
6587         */
6588        @Child(name = "sourceId", type = {IdType.class}, order=20, min=0, max=1, modifier=false, summary=false)
6589        @Description(shortDefinition="Fixture Id of source expression or headerField", formalDefinition="Fixture to evaluate the XPath/JSONPath expression or the headerField  against." )
6590        protected IdType sourceId;
6591
6592        /**
6593         * Whether or not the current test execution will stop on failure for this assert.
6594         */
6595        @Child(name = "stopTestOnFail", type = {BooleanType.class}, order=21, min=1, max=1, modifier=false, summary=false)
6596        @Description(shortDefinition="If this assert fails, will the current test execution stop?", formalDefinition="Whether or not the current test execution will stop on failure for this assert." )
6597        protected BooleanType stopTestOnFail;
6598
6599        /**
6600         * The ID of the Profile to validate against.
6601         */
6602        @Child(name = "validateProfileId", type = {IdType.class}, order=22, min=0, max=1, modifier=false, summary=false)
6603        @Description(shortDefinition="Profile Id of validation profile reference", formalDefinition="The ID of the Profile to validate against." )
6604        protected IdType validateProfileId;
6605
6606        /**
6607         * The value to compare to.
6608         */
6609        @Child(name = "value", type = {StringType.class}, order=23, min=0, max=1, modifier=false, summary=false)
6610        @Description(shortDefinition="The value to compare to", formalDefinition="The value to compare to." )
6611        protected StringType value;
6612
6613        /**
6614         * Whether or not the test execution will produce a warning only on error for this assert.
6615         */
6616        @Child(name = "warningOnly", type = {BooleanType.class}, order=24, min=1, max=1, modifier=false, summary=false)
6617        @Description(shortDefinition="Will this assert produce a warning only on error?", formalDefinition="Whether or not the test execution will produce a warning only on error for this assert." )
6618        protected BooleanType warningOnly;
6619
6620        /**
6621         * Links or references providing traceability to the testing requirements for this assert.
6622         */
6623        @Child(name = "requirement", type = {}, order=25, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
6624        @Description(shortDefinition="Links or references to the testing requirements", formalDefinition="Links or references providing traceability to the testing requirements for this assert." )
6625        protected List<SetupActionAssertRequirementComponent> requirement;
6626
6627        private static final long serialVersionUID = -1269963728L;
6628
6629    /**
6630     * Constructor
6631     */
6632      public SetupActionAssertComponent() {
6633        super();
6634      }
6635
6636    /**
6637     * Constructor
6638     */
6639      public SetupActionAssertComponent(boolean stopTestOnFail, boolean warningOnly) {
6640        super();
6641        this.setStopTestOnFail(stopTestOnFail);
6642        this.setWarningOnly(warningOnly);
6643      }
6644
6645        /**
6646         * @return {@link #label} (The label would be used for tracking/logging purposes by test engines.). This is the underlying object with id, value and extensions. The accessor "getLabel" gives direct access to the value
6647         */
6648        public StringType getLabelElement() { 
6649          if (this.label == null)
6650            if (Configuration.errorOnAutoCreate())
6651              throw new Error("Attempt to auto-create SetupActionAssertComponent.label");
6652            else if (Configuration.doAutoCreate())
6653              this.label = new StringType(); // bb
6654          return this.label;
6655        }
6656
6657        public boolean hasLabelElement() { 
6658          return this.label != null && !this.label.isEmpty();
6659        }
6660
6661        public boolean hasLabel() { 
6662          return this.label != null && !this.label.isEmpty();
6663        }
6664
6665        /**
6666         * @param value {@link #label} (The label would be used for tracking/logging purposes by test engines.). This is the underlying object with id, value and extensions. The accessor "getLabel" gives direct access to the value
6667         */
6668        public SetupActionAssertComponent setLabelElement(StringType value) { 
6669          this.label = value;
6670          return this;
6671        }
6672
6673        /**
6674         * @return The label would be used for tracking/logging purposes by test engines.
6675         */
6676        public String getLabel() { 
6677          return this.label == null ? null : this.label.getValue();
6678        }
6679
6680        /**
6681         * @param value The label would be used for tracking/logging purposes by test engines.
6682         */
6683        public SetupActionAssertComponent setLabel(String value) { 
6684          if (Utilities.noString(value))
6685            this.label = null;
6686          else {
6687            if (this.label == null)
6688              this.label = new StringType();
6689            this.label.setValue(value);
6690          }
6691          return this;
6692        }
6693
6694        /**
6695         * @return {@link #description} (The description would be used by test engines for tracking and reporting purposes.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
6696         */
6697        public StringType getDescriptionElement() { 
6698          if (this.description == null)
6699            if (Configuration.errorOnAutoCreate())
6700              throw new Error("Attempt to auto-create SetupActionAssertComponent.description");
6701            else if (Configuration.doAutoCreate())
6702              this.description = new StringType(); // bb
6703          return this.description;
6704        }
6705
6706        public boolean hasDescriptionElement() { 
6707          return this.description != null && !this.description.isEmpty();
6708        }
6709
6710        public boolean hasDescription() { 
6711          return this.description != null && !this.description.isEmpty();
6712        }
6713
6714        /**
6715         * @param value {@link #description} (The description would be used by test engines for tracking and reporting purposes.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
6716         */
6717        public SetupActionAssertComponent setDescriptionElement(StringType value) { 
6718          this.description = value;
6719          return this;
6720        }
6721
6722        /**
6723         * @return The description would be used by test engines for tracking and reporting purposes.
6724         */
6725        public String getDescription() { 
6726          return this.description == null ? null : this.description.getValue();
6727        }
6728
6729        /**
6730         * @param value The description would be used by test engines for tracking and reporting purposes.
6731         */
6732        public SetupActionAssertComponent setDescription(String value) { 
6733          if (Utilities.noString(value))
6734            this.description = null;
6735          else {
6736            if (this.description == null)
6737              this.description = new StringType();
6738            this.description.setValue(value);
6739          }
6740          return this;
6741        }
6742
6743        /**
6744         * @return {@link #direction} (The direction to use for the assertion.). This is the underlying object with id, value and extensions. The accessor "getDirection" gives direct access to the value
6745         */
6746        public Enumeration<AssertionDirectionType> getDirectionElement() { 
6747          if (this.direction == null)
6748            if (Configuration.errorOnAutoCreate())
6749              throw new Error("Attempt to auto-create SetupActionAssertComponent.direction");
6750            else if (Configuration.doAutoCreate())
6751              this.direction = new Enumeration<AssertionDirectionType>(new AssertionDirectionTypeEnumFactory()); // bb
6752          return this.direction;
6753        }
6754
6755        public boolean hasDirectionElement() { 
6756          return this.direction != null && !this.direction.isEmpty();
6757        }
6758
6759        public boolean hasDirection() { 
6760          return this.direction != null && !this.direction.isEmpty();
6761        }
6762
6763        /**
6764         * @param value {@link #direction} (The direction to use for the assertion.). This is the underlying object with id, value and extensions. The accessor "getDirection" gives direct access to the value
6765         */
6766        public SetupActionAssertComponent setDirectionElement(Enumeration<AssertionDirectionType> value) { 
6767          this.direction = value;
6768          return this;
6769        }
6770
6771        /**
6772         * @return The direction to use for the assertion.
6773         */
6774        public AssertionDirectionType getDirection() { 
6775          return this.direction == null ? null : this.direction.getValue();
6776        }
6777
6778        /**
6779         * @param value The direction to use for the assertion.
6780         */
6781        public SetupActionAssertComponent setDirection(AssertionDirectionType value) { 
6782          if (value == null)
6783            this.direction = null;
6784          else {
6785            if (this.direction == null)
6786              this.direction = new Enumeration<AssertionDirectionType>(new AssertionDirectionTypeEnumFactory());
6787            this.direction.setValue(value);
6788          }
6789          return this;
6790        }
6791
6792        /**
6793         * @return {@link #compareToSourceId} (Id of the source fixture used as the contents to be evaluated by either the "source/expression" or "sourceId/path" definition.). This is the underlying object with id, value and extensions. The accessor "getCompareToSourceId" gives direct access to the value
6794         */
6795        public StringType getCompareToSourceIdElement() { 
6796          if (this.compareToSourceId == null)
6797            if (Configuration.errorOnAutoCreate())
6798              throw new Error("Attempt to auto-create SetupActionAssertComponent.compareToSourceId");
6799            else if (Configuration.doAutoCreate())
6800              this.compareToSourceId = new StringType(); // bb
6801          return this.compareToSourceId;
6802        }
6803
6804        public boolean hasCompareToSourceIdElement() { 
6805          return this.compareToSourceId != null && !this.compareToSourceId.isEmpty();
6806        }
6807
6808        public boolean hasCompareToSourceId() { 
6809          return this.compareToSourceId != null && !this.compareToSourceId.isEmpty();
6810        }
6811
6812        /**
6813         * @param value {@link #compareToSourceId} (Id of the source fixture used as the contents to be evaluated by either the "source/expression" or "sourceId/path" definition.). This is the underlying object with id, value and extensions. The accessor "getCompareToSourceId" gives direct access to the value
6814         */
6815        public SetupActionAssertComponent setCompareToSourceIdElement(StringType value) { 
6816          this.compareToSourceId = value;
6817          return this;
6818        }
6819
6820        /**
6821         * @return Id of the source fixture used as the contents to be evaluated by either the "source/expression" or "sourceId/path" definition.
6822         */
6823        public String getCompareToSourceId() { 
6824          return this.compareToSourceId == null ? null : this.compareToSourceId.getValue();
6825        }
6826
6827        /**
6828         * @param value Id of the source fixture used as the contents to be evaluated by either the "source/expression" or "sourceId/path" definition.
6829         */
6830        public SetupActionAssertComponent setCompareToSourceId(String value) { 
6831          if (Utilities.noString(value))
6832            this.compareToSourceId = null;
6833          else {
6834            if (this.compareToSourceId == null)
6835              this.compareToSourceId = new StringType();
6836            this.compareToSourceId.setValue(value);
6837          }
6838          return this;
6839        }
6840
6841        /**
6842         * @return {@link #compareToSourceExpression} (The FHIRPath expression for a specific value to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.). This is the underlying object with id, value and extensions. The accessor "getCompareToSourceExpression" gives direct access to the value
6843         */
6844        public StringType getCompareToSourceExpressionElement() { 
6845          if (this.compareToSourceExpression == null)
6846            if (Configuration.errorOnAutoCreate())
6847              throw new Error("Attempt to auto-create SetupActionAssertComponent.compareToSourceExpression");
6848            else if (Configuration.doAutoCreate())
6849              this.compareToSourceExpression = new StringType(); // bb
6850          return this.compareToSourceExpression;
6851        }
6852
6853        public boolean hasCompareToSourceExpressionElement() { 
6854          return this.compareToSourceExpression != null && !this.compareToSourceExpression.isEmpty();
6855        }
6856
6857        public boolean hasCompareToSourceExpression() { 
6858          return this.compareToSourceExpression != null && !this.compareToSourceExpression.isEmpty();
6859        }
6860
6861        /**
6862         * @param value {@link #compareToSourceExpression} (The FHIRPath expression for a specific value to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.). This is the underlying object with id, value and extensions. The accessor "getCompareToSourceExpression" gives direct access to the value
6863         */
6864        public SetupActionAssertComponent setCompareToSourceExpressionElement(StringType value) { 
6865          this.compareToSourceExpression = value;
6866          return this;
6867        }
6868
6869        /**
6870         * @return The FHIRPath expression for a specific value to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.
6871         */
6872        public String getCompareToSourceExpression() { 
6873          return this.compareToSourceExpression == null ? null : this.compareToSourceExpression.getValue();
6874        }
6875
6876        /**
6877         * @param value The FHIRPath expression for a specific value to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.
6878         */
6879        public SetupActionAssertComponent setCompareToSourceExpression(String value) { 
6880          if (Utilities.noString(value))
6881            this.compareToSourceExpression = null;
6882          else {
6883            if (this.compareToSourceExpression == null)
6884              this.compareToSourceExpression = new StringType();
6885            this.compareToSourceExpression.setValue(value);
6886          }
6887          return this;
6888        }
6889
6890        /**
6891         * @return {@link #compareToSourcePath} (XPath or JSONPath expression to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.). This is the underlying object with id, value and extensions. The accessor "getCompareToSourcePath" gives direct access to the value
6892         */
6893        public StringType getCompareToSourcePathElement() { 
6894          if (this.compareToSourcePath == null)
6895            if (Configuration.errorOnAutoCreate())
6896              throw new Error("Attempt to auto-create SetupActionAssertComponent.compareToSourcePath");
6897            else if (Configuration.doAutoCreate())
6898              this.compareToSourcePath = new StringType(); // bb
6899          return this.compareToSourcePath;
6900        }
6901
6902        public boolean hasCompareToSourcePathElement() { 
6903          return this.compareToSourcePath != null && !this.compareToSourcePath.isEmpty();
6904        }
6905
6906        public boolean hasCompareToSourcePath() { 
6907          return this.compareToSourcePath != null && !this.compareToSourcePath.isEmpty();
6908        }
6909
6910        /**
6911         * @param value {@link #compareToSourcePath} (XPath or JSONPath expression to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.). This is the underlying object with id, value and extensions. The accessor "getCompareToSourcePath" gives direct access to the value
6912         */
6913        public SetupActionAssertComponent setCompareToSourcePathElement(StringType value) { 
6914          this.compareToSourcePath = value;
6915          return this;
6916        }
6917
6918        /**
6919         * @return XPath or JSONPath expression to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.
6920         */
6921        public String getCompareToSourcePath() { 
6922          return this.compareToSourcePath == null ? null : this.compareToSourcePath.getValue();
6923        }
6924
6925        /**
6926         * @param value XPath or JSONPath expression to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.
6927         */
6928        public SetupActionAssertComponent setCompareToSourcePath(String value) { 
6929          if (Utilities.noString(value))
6930            this.compareToSourcePath = null;
6931          else {
6932            if (this.compareToSourcePath == null)
6933              this.compareToSourcePath = new StringType();
6934            this.compareToSourcePath.setValue(value);
6935          }
6936          return this;
6937        }
6938
6939        /**
6940         * @return {@link #contentType} (The mime-type contents to compare against the request or response message 'Content-Type' header.). This is the underlying object with id, value and extensions. The accessor "getContentType" gives direct access to the value
6941         */
6942        public CodeType getContentTypeElement() { 
6943          if (this.contentType == null)
6944            if (Configuration.errorOnAutoCreate())
6945              throw new Error("Attempt to auto-create SetupActionAssertComponent.contentType");
6946            else if (Configuration.doAutoCreate())
6947              this.contentType = new CodeType(); // bb
6948          return this.contentType;
6949        }
6950
6951        public boolean hasContentTypeElement() { 
6952          return this.contentType != null && !this.contentType.isEmpty();
6953        }
6954
6955        public boolean hasContentType() { 
6956          return this.contentType != null && !this.contentType.isEmpty();
6957        }
6958
6959        /**
6960         * @param value {@link #contentType} (The mime-type contents to compare against the request or response message 'Content-Type' header.). This is the underlying object with id, value and extensions. The accessor "getContentType" gives direct access to the value
6961         */
6962        public SetupActionAssertComponent setContentTypeElement(CodeType value) { 
6963          this.contentType = value;
6964          return this;
6965        }
6966
6967        /**
6968         * @return The mime-type contents to compare against the request or response message 'Content-Type' header.
6969         */
6970        public String getContentType() { 
6971          return this.contentType == null ? null : this.contentType.getValue();
6972        }
6973
6974        /**
6975         * @param value The mime-type contents to compare against the request or response message 'Content-Type' header.
6976         */
6977        public SetupActionAssertComponent setContentType(String value) { 
6978          if (Utilities.noString(value))
6979            this.contentType = null;
6980          else {
6981            if (this.contentType == null)
6982              this.contentType = new CodeType();
6983            this.contentType.setValue(value);
6984          }
6985          return this;
6986        }
6987
6988        /**
6989         * @return {@link #defaultManualCompletion} (The default manual completion outcome applied to this assertion.). This is the underlying object with id, value and extensions. The accessor "getDefaultManualCompletion" gives direct access to the value
6990         */
6991        public Enumeration<AssertionManualCompletionType> getDefaultManualCompletionElement() { 
6992          if (this.defaultManualCompletion == null)
6993            if (Configuration.errorOnAutoCreate())
6994              throw new Error("Attempt to auto-create SetupActionAssertComponent.defaultManualCompletion");
6995            else if (Configuration.doAutoCreate())
6996              this.defaultManualCompletion = new Enumeration<AssertionManualCompletionType>(new AssertionManualCompletionTypeEnumFactory()); // bb
6997          return this.defaultManualCompletion;
6998        }
6999
7000        public boolean hasDefaultManualCompletionElement() { 
7001          return this.defaultManualCompletion != null && !this.defaultManualCompletion.isEmpty();
7002        }
7003
7004        public boolean hasDefaultManualCompletion() { 
7005          return this.defaultManualCompletion != null && !this.defaultManualCompletion.isEmpty();
7006        }
7007
7008        /**
7009         * @param value {@link #defaultManualCompletion} (The default manual completion outcome applied to this assertion.). This is the underlying object with id, value and extensions. The accessor "getDefaultManualCompletion" gives direct access to the value
7010         */
7011        public SetupActionAssertComponent setDefaultManualCompletionElement(Enumeration<AssertionManualCompletionType> value) { 
7012          this.defaultManualCompletion = value;
7013          return this;
7014        }
7015
7016        /**
7017         * @return The default manual completion outcome applied to this assertion.
7018         */
7019        public AssertionManualCompletionType getDefaultManualCompletion() { 
7020          return this.defaultManualCompletion == null ? null : this.defaultManualCompletion.getValue();
7021        }
7022
7023        /**
7024         * @param value The default manual completion outcome applied to this assertion.
7025         */
7026        public SetupActionAssertComponent setDefaultManualCompletion(AssertionManualCompletionType value) { 
7027          if (value == null)
7028            this.defaultManualCompletion = null;
7029          else {
7030            if (this.defaultManualCompletion == null)
7031              this.defaultManualCompletion = new Enumeration<AssertionManualCompletionType>(new AssertionManualCompletionTypeEnumFactory());
7032            this.defaultManualCompletion.setValue(value);
7033          }
7034          return this;
7035        }
7036
7037        /**
7038         * @return {@link #expression} (The FHIRPath expression to be evaluated against the request or response message contents - HTTP headers and payload.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value
7039         */
7040        public StringType getExpressionElement() { 
7041          if (this.expression == null)
7042            if (Configuration.errorOnAutoCreate())
7043              throw new Error("Attempt to auto-create SetupActionAssertComponent.expression");
7044            else if (Configuration.doAutoCreate())
7045              this.expression = new StringType(); // bb
7046          return this.expression;
7047        }
7048
7049        public boolean hasExpressionElement() { 
7050          return this.expression != null && !this.expression.isEmpty();
7051        }
7052
7053        public boolean hasExpression() { 
7054          return this.expression != null && !this.expression.isEmpty();
7055        }
7056
7057        /**
7058         * @param value {@link #expression} (The FHIRPath expression to be evaluated against the request or response message contents - HTTP headers and payload.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value
7059         */
7060        public SetupActionAssertComponent setExpressionElement(StringType value) { 
7061          this.expression = value;
7062          return this;
7063        }
7064
7065        /**
7066         * @return The FHIRPath expression to be evaluated against the request or response message contents - HTTP headers and payload.
7067         */
7068        public String getExpression() { 
7069          return this.expression == null ? null : this.expression.getValue();
7070        }
7071
7072        /**
7073         * @param value The FHIRPath expression to be evaluated against the request or response message contents - HTTP headers and payload.
7074         */
7075        public SetupActionAssertComponent setExpression(String value) { 
7076          if (Utilities.noString(value))
7077            this.expression = null;
7078          else {
7079            if (this.expression == null)
7080              this.expression = new StringType();
7081            this.expression.setValue(value);
7082          }
7083          return this;
7084        }
7085
7086        /**
7087         * @return {@link #headerField} (The HTTP header field name e.g. 'Location'.). This is the underlying object with id, value and extensions. The accessor "getHeaderField" gives direct access to the value
7088         */
7089        public StringType getHeaderFieldElement() { 
7090          if (this.headerField == null)
7091            if (Configuration.errorOnAutoCreate())
7092              throw new Error("Attempt to auto-create SetupActionAssertComponent.headerField");
7093            else if (Configuration.doAutoCreate())
7094              this.headerField = new StringType(); // bb
7095          return this.headerField;
7096        }
7097
7098        public boolean hasHeaderFieldElement() { 
7099          return this.headerField != null && !this.headerField.isEmpty();
7100        }
7101
7102        public boolean hasHeaderField() { 
7103          return this.headerField != null && !this.headerField.isEmpty();
7104        }
7105
7106        /**
7107         * @param value {@link #headerField} (The HTTP header field name e.g. 'Location'.). This is the underlying object with id, value and extensions. The accessor "getHeaderField" gives direct access to the value
7108         */
7109        public SetupActionAssertComponent setHeaderFieldElement(StringType value) { 
7110          this.headerField = value;
7111          return this;
7112        }
7113
7114        /**
7115         * @return The HTTP header field name e.g. 'Location'.
7116         */
7117        public String getHeaderField() { 
7118          return this.headerField == null ? null : this.headerField.getValue();
7119        }
7120
7121        /**
7122         * @param value The HTTP header field name e.g. 'Location'.
7123         */
7124        public SetupActionAssertComponent setHeaderField(String value) { 
7125          if (Utilities.noString(value))
7126            this.headerField = null;
7127          else {
7128            if (this.headerField == null)
7129              this.headerField = new StringType();
7130            this.headerField.setValue(value);
7131          }
7132          return this;
7133        }
7134
7135        /**
7136         * @return {@link #minimumId} (The ID of a fixture. Asserts that the response contains at a minimum the fixture specified by minimumId.). This is the underlying object with id, value and extensions. The accessor "getMinimumId" gives direct access to the value
7137         */
7138        public StringType getMinimumIdElement() { 
7139          if (this.minimumId == null)
7140            if (Configuration.errorOnAutoCreate())
7141              throw new Error("Attempt to auto-create SetupActionAssertComponent.minimumId");
7142            else if (Configuration.doAutoCreate())
7143              this.minimumId = new StringType(); // bb
7144          return this.minimumId;
7145        }
7146
7147        public boolean hasMinimumIdElement() { 
7148          return this.minimumId != null && !this.minimumId.isEmpty();
7149        }
7150
7151        public boolean hasMinimumId() { 
7152          return this.minimumId != null && !this.minimumId.isEmpty();
7153        }
7154
7155        /**
7156         * @param value {@link #minimumId} (The ID of a fixture. Asserts that the response contains at a minimum the fixture specified by minimumId.). This is the underlying object with id, value and extensions. The accessor "getMinimumId" gives direct access to the value
7157         */
7158        public SetupActionAssertComponent setMinimumIdElement(StringType value) { 
7159          this.minimumId = value;
7160          return this;
7161        }
7162
7163        /**
7164         * @return The ID of a fixture. Asserts that the response contains at a minimum the fixture specified by minimumId.
7165         */
7166        public String getMinimumId() { 
7167          return this.minimumId == null ? null : this.minimumId.getValue();
7168        }
7169
7170        /**
7171         * @param value The ID of a fixture. Asserts that the response contains at a minimum the fixture specified by minimumId.
7172         */
7173        public SetupActionAssertComponent setMinimumId(String value) { 
7174          if (Utilities.noString(value))
7175            this.minimumId = null;
7176          else {
7177            if (this.minimumId == null)
7178              this.minimumId = new StringType();
7179            this.minimumId.setValue(value);
7180          }
7181          return this;
7182        }
7183
7184        /**
7185         * @return {@link #navigationLinks} (Whether or not the test execution performs validation on the bundle navigation links.). This is the underlying object with id, value and extensions. The accessor "getNavigationLinks" gives direct access to the value
7186         */
7187        public BooleanType getNavigationLinksElement() { 
7188          if (this.navigationLinks == null)
7189            if (Configuration.errorOnAutoCreate())
7190              throw new Error("Attempt to auto-create SetupActionAssertComponent.navigationLinks");
7191            else if (Configuration.doAutoCreate())
7192              this.navigationLinks = new BooleanType(); // bb
7193          return this.navigationLinks;
7194        }
7195
7196        public boolean hasNavigationLinksElement() { 
7197          return this.navigationLinks != null && !this.navigationLinks.isEmpty();
7198        }
7199
7200        public boolean hasNavigationLinks() { 
7201          return this.navigationLinks != null && !this.navigationLinks.isEmpty();
7202        }
7203
7204        /**
7205         * @param value {@link #navigationLinks} (Whether or not the test execution performs validation on the bundle navigation links.). This is the underlying object with id, value and extensions. The accessor "getNavigationLinks" gives direct access to the value
7206         */
7207        public SetupActionAssertComponent setNavigationLinksElement(BooleanType value) { 
7208          this.navigationLinks = value;
7209          return this;
7210        }
7211
7212        /**
7213         * @return Whether or not the test execution performs validation on the bundle navigation links.
7214         */
7215        public boolean getNavigationLinks() { 
7216          return this.navigationLinks == null || this.navigationLinks.isEmpty() ? false : this.navigationLinks.getValue();
7217        }
7218
7219        /**
7220         * @param value Whether or not the test execution performs validation on the bundle navigation links.
7221         */
7222        public SetupActionAssertComponent setNavigationLinks(boolean value) { 
7223            if (this.navigationLinks == null)
7224              this.navigationLinks = new BooleanType();
7225            this.navigationLinks.setValue(value);
7226          return this;
7227        }
7228
7229        /**
7230         * @return {@link #operator} (The operator type defines the conditional behavior of the assert.). This is the underlying object with id, value and extensions. The accessor "getOperator" gives direct access to the value
7231         */
7232        public Enumeration<AssertionOperatorType> getOperatorElement() { 
7233          if (this.operator == null)
7234            if (Configuration.errorOnAutoCreate())
7235              throw new Error("Attempt to auto-create SetupActionAssertComponent.operator");
7236            else if (Configuration.doAutoCreate())
7237              this.operator = new Enumeration<AssertionOperatorType>(new AssertionOperatorTypeEnumFactory()); // bb
7238          return this.operator;
7239        }
7240
7241        public boolean hasOperatorElement() { 
7242          return this.operator != null && !this.operator.isEmpty();
7243        }
7244
7245        public boolean hasOperator() { 
7246          return this.operator != null && !this.operator.isEmpty();
7247        }
7248
7249        /**
7250         * @param value {@link #operator} (The operator type defines the conditional behavior of the assert.). This is the underlying object with id, value and extensions. The accessor "getOperator" gives direct access to the value
7251         */
7252        public SetupActionAssertComponent setOperatorElement(Enumeration<AssertionOperatorType> value) { 
7253          this.operator = value;
7254          return this;
7255        }
7256
7257        /**
7258         * @return The operator type defines the conditional behavior of the assert.
7259         */
7260        public AssertionOperatorType getOperator() { 
7261          return this.operator == null ? null : this.operator.getValue();
7262        }
7263
7264        /**
7265         * @param value The operator type defines the conditional behavior of the assert.
7266         */
7267        public SetupActionAssertComponent setOperator(AssertionOperatorType value) { 
7268          if (value == null)
7269            this.operator = null;
7270          else {
7271            if (this.operator == null)
7272              this.operator = new Enumeration<AssertionOperatorType>(new AssertionOperatorTypeEnumFactory());
7273            this.operator.setValue(value);
7274          }
7275          return this;
7276        }
7277
7278        /**
7279         * @return {@link #path} (The XPath or JSONPath expression to be evaluated against the fixture representing the response received from server.). This is the underlying object with id, value and extensions. The accessor "getPath" gives direct access to the value
7280         */
7281        public StringType getPathElement() { 
7282          if (this.path == null)
7283            if (Configuration.errorOnAutoCreate())
7284              throw new Error("Attempt to auto-create SetupActionAssertComponent.path");
7285            else if (Configuration.doAutoCreate())
7286              this.path = new StringType(); // bb
7287          return this.path;
7288        }
7289
7290        public boolean hasPathElement() { 
7291          return this.path != null && !this.path.isEmpty();
7292        }
7293
7294        public boolean hasPath() { 
7295          return this.path != null && !this.path.isEmpty();
7296        }
7297
7298        /**
7299         * @param value {@link #path} (The XPath or JSONPath expression to be evaluated against the fixture representing the response received from server.). This is the underlying object with id, value and extensions. The accessor "getPath" gives direct access to the value
7300         */
7301        public SetupActionAssertComponent setPathElement(StringType value) { 
7302          this.path = value;
7303          return this;
7304        }
7305
7306        /**
7307         * @return The XPath or JSONPath expression to be evaluated against the fixture representing the response received from server.
7308         */
7309        public String getPath() { 
7310          return this.path == null ? null : this.path.getValue();
7311        }
7312
7313        /**
7314         * @param value The XPath or JSONPath expression to be evaluated against the fixture representing the response received from server.
7315         */
7316        public SetupActionAssertComponent setPath(String value) { 
7317          if (Utilities.noString(value))
7318            this.path = null;
7319          else {
7320            if (this.path == null)
7321              this.path = new StringType();
7322            this.path.setValue(value);
7323          }
7324          return this;
7325        }
7326
7327        /**
7328         * @return {@link #requestMethod} (The request method or HTTP operation code to compare against that used by the client system under test.). This is the underlying object with id, value and extensions. The accessor "getRequestMethod" gives direct access to the value
7329         */
7330        public Enumeration<TestScriptRequestMethodCode> getRequestMethodElement() { 
7331          if (this.requestMethod == null)
7332            if (Configuration.errorOnAutoCreate())
7333              throw new Error("Attempt to auto-create SetupActionAssertComponent.requestMethod");
7334            else if (Configuration.doAutoCreate())
7335              this.requestMethod = new Enumeration<TestScriptRequestMethodCode>(new TestScriptRequestMethodCodeEnumFactory()); // bb
7336          return this.requestMethod;
7337        }
7338
7339        public boolean hasRequestMethodElement() { 
7340          return this.requestMethod != null && !this.requestMethod.isEmpty();
7341        }
7342
7343        public boolean hasRequestMethod() { 
7344          return this.requestMethod != null && !this.requestMethod.isEmpty();
7345        }
7346
7347        /**
7348         * @param value {@link #requestMethod} (The request method or HTTP operation code to compare against that used by the client system under test.). This is the underlying object with id, value and extensions. The accessor "getRequestMethod" gives direct access to the value
7349         */
7350        public SetupActionAssertComponent setRequestMethodElement(Enumeration<TestScriptRequestMethodCode> value) { 
7351          this.requestMethod = value;
7352          return this;
7353        }
7354
7355        /**
7356         * @return The request method or HTTP operation code to compare against that used by the client system under test.
7357         */
7358        public TestScriptRequestMethodCode getRequestMethod() { 
7359          return this.requestMethod == null ? null : this.requestMethod.getValue();
7360        }
7361
7362        /**
7363         * @param value The request method or HTTP operation code to compare against that used by the client system under test.
7364         */
7365        public SetupActionAssertComponent setRequestMethod(TestScriptRequestMethodCode value) { 
7366          if (value == null)
7367            this.requestMethod = null;
7368          else {
7369            if (this.requestMethod == null)
7370              this.requestMethod = new Enumeration<TestScriptRequestMethodCode>(new TestScriptRequestMethodCodeEnumFactory());
7371            this.requestMethod.setValue(value);
7372          }
7373          return this;
7374        }
7375
7376        /**
7377         * @return {@link #requestURL} (The value to use in a comparison against the request URL path string.). This is the underlying object with id, value and extensions. The accessor "getRequestURL" gives direct access to the value
7378         */
7379        public StringType getRequestURLElement() { 
7380          if (this.requestURL == null)
7381            if (Configuration.errorOnAutoCreate())
7382              throw new Error("Attempt to auto-create SetupActionAssertComponent.requestURL");
7383            else if (Configuration.doAutoCreate())
7384              this.requestURL = new StringType(); // bb
7385          return this.requestURL;
7386        }
7387
7388        public boolean hasRequestURLElement() { 
7389          return this.requestURL != null && !this.requestURL.isEmpty();
7390        }
7391
7392        public boolean hasRequestURL() { 
7393          return this.requestURL != null && !this.requestURL.isEmpty();
7394        }
7395
7396        /**
7397         * @param value {@link #requestURL} (The value to use in a comparison against the request URL path string.). This is the underlying object with id, value and extensions. The accessor "getRequestURL" gives direct access to the value
7398         */
7399        public SetupActionAssertComponent setRequestURLElement(StringType value) { 
7400          this.requestURL = value;
7401          return this;
7402        }
7403
7404        /**
7405         * @return The value to use in a comparison against the request URL path string.
7406         */
7407        public String getRequestURL() { 
7408          return this.requestURL == null ? null : this.requestURL.getValue();
7409        }
7410
7411        /**
7412         * @param value The value to use in a comparison against the request URL path string.
7413         */
7414        public SetupActionAssertComponent setRequestURL(String value) { 
7415          if (Utilities.noString(value))
7416            this.requestURL = null;
7417          else {
7418            if (this.requestURL == null)
7419              this.requestURL = new StringType();
7420            this.requestURL.setValue(value);
7421          }
7422          return this;
7423        }
7424
7425        /**
7426         * @return {@link #resource} (The type of the resource.  See the [resource list](resourcelist.html).). This is the underlying object with id, value and extensions. The accessor "getResource" gives direct access to the value
7427         */
7428        public UriType getResourceElement() { 
7429          if (this.resource == null)
7430            if (Configuration.errorOnAutoCreate())
7431              throw new Error("Attempt to auto-create SetupActionAssertComponent.resource");
7432            else if (Configuration.doAutoCreate())
7433              this.resource = new UriType(); // bb
7434          return this.resource;
7435        }
7436
7437        public boolean hasResourceElement() { 
7438          return this.resource != null && !this.resource.isEmpty();
7439        }
7440
7441        public boolean hasResource() { 
7442          return this.resource != null && !this.resource.isEmpty();
7443        }
7444
7445        /**
7446         * @param value {@link #resource} (The type of the resource.  See the [resource list](resourcelist.html).). This is the underlying object with id, value and extensions. The accessor "getResource" gives direct access to the value
7447         */
7448        public SetupActionAssertComponent setResourceElement(UriType value) { 
7449          this.resource = value;
7450          return this;
7451        }
7452
7453        /**
7454         * @return The type of the resource.  See the [resource list](resourcelist.html).
7455         */
7456        public String getResource() { 
7457          return this.resource == null ? null : this.resource.getValue();
7458        }
7459
7460        /**
7461         * @param value The type of the resource.  See the [resource list](resourcelist.html).
7462         */
7463        public SetupActionAssertComponent setResource(String value) { 
7464          if (Utilities.noString(value))
7465            this.resource = null;
7466          else {
7467            if (this.resource == null)
7468              this.resource = new UriType();
7469            this.resource.setValue(value);
7470          }
7471          return this;
7472        }
7473
7474        /**
7475         * @return {@link #response} (continue | switchingProtocols | okay | created | accepted | nonAuthoritativeInformation | noContent | resetContent | partialContent | multipleChoices | movedPermanently | found | seeOther | notModified | useProxy | temporaryRedirect | permanentRedirect | badRequest | unauthorized | paymentRequired | forbidden | notFound | methodNotAllowed | notAcceptable | proxyAuthenticationRequired | requestTimeout | conflict | gone | lengthRequired | preconditionFailed | contentTooLarge | uriTooLong | unsupportedMediaType | rangeNotSatisfiable | expectationFailed | misdirectedRequest | unprocessableContent | upgradeRequired | internalServerError | notImplemented | badGateway | serviceUnavailable | gatewayTimeout | httpVersionNotSupported.). This is the underlying object with id, value and extensions. The accessor "getResponse" gives direct access to the value
7476         */
7477        public Enumeration<AssertionResponseTypes> getResponseElement() { 
7478          if (this.response == null)
7479            if (Configuration.errorOnAutoCreate())
7480              throw new Error("Attempt to auto-create SetupActionAssertComponent.response");
7481            else if (Configuration.doAutoCreate())
7482              this.response = new Enumeration<AssertionResponseTypes>(new AssertionResponseTypesEnumFactory()); // bb
7483          return this.response;
7484        }
7485
7486        public boolean hasResponseElement() { 
7487          return this.response != null && !this.response.isEmpty();
7488        }
7489
7490        public boolean hasResponse() { 
7491          return this.response != null && !this.response.isEmpty();
7492        }
7493
7494        /**
7495         * @param value {@link #response} (continue | switchingProtocols | okay | created | accepted | nonAuthoritativeInformation | noContent | resetContent | partialContent | multipleChoices | movedPermanently | found | seeOther | notModified | useProxy | temporaryRedirect | permanentRedirect | badRequest | unauthorized | paymentRequired | forbidden | notFound | methodNotAllowed | notAcceptable | proxyAuthenticationRequired | requestTimeout | conflict | gone | lengthRequired | preconditionFailed | contentTooLarge | uriTooLong | unsupportedMediaType | rangeNotSatisfiable | expectationFailed | misdirectedRequest | unprocessableContent | upgradeRequired | internalServerError | notImplemented | badGateway | serviceUnavailable | gatewayTimeout | httpVersionNotSupported.). This is the underlying object with id, value and extensions. The accessor "getResponse" gives direct access to the value
7496         */
7497        public SetupActionAssertComponent setResponseElement(Enumeration<AssertionResponseTypes> value) { 
7498          this.response = value;
7499          return this;
7500        }
7501
7502        /**
7503         * @return continue | switchingProtocols | okay | created | accepted | nonAuthoritativeInformation | noContent | resetContent | partialContent | multipleChoices | movedPermanently | found | seeOther | notModified | useProxy | temporaryRedirect | permanentRedirect | badRequest | unauthorized | paymentRequired | forbidden | notFound | methodNotAllowed | notAcceptable | proxyAuthenticationRequired | requestTimeout | conflict | gone | lengthRequired | preconditionFailed | contentTooLarge | uriTooLong | unsupportedMediaType | rangeNotSatisfiable | expectationFailed | misdirectedRequest | unprocessableContent | upgradeRequired | internalServerError | notImplemented | badGateway | serviceUnavailable | gatewayTimeout | httpVersionNotSupported.
7504         */
7505        public AssertionResponseTypes getResponse() { 
7506          return this.response == null ? null : this.response.getValue();
7507        }
7508
7509        /**
7510         * @param value continue | switchingProtocols | okay | created | accepted | nonAuthoritativeInformation | noContent | resetContent | partialContent | multipleChoices | movedPermanently | found | seeOther | notModified | useProxy | temporaryRedirect | permanentRedirect | badRequest | unauthorized | paymentRequired | forbidden | notFound | methodNotAllowed | notAcceptable | proxyAuthenticationRequired | requestTimeout | conflict | gone | lengthRequired | preconditionFailed | contentTooLarge | uriTooLong | unsupportedMediaType | rangeNotSatisfiable | expectationFailed | misdirectedRequest | unprocessableContent | upgradeRequired | internalServerError | notImplemented | badGateway | serviceUnavailable | gatewayTimeout | httpVersionNotSupported.
7511         */
7512        public SetupActionAssertComponent setResponse(AssertionResponseTypes value) { 
7513          if (value == null)
7514            this.response = null;
7515          else {
7516            if (this.response == null)
7517              this.response = new Enumeration<AssertionResponseTypes>(new AssertionResponseTypesEnumFactory());
7518            this.response.setValue(value);
7519          }
7520          return this;
7521        }
7522
7523        /**
7524         * @return {@link #responseCode} (The value of the HTTP response code to be tested.). This is the underlying object with id, value and extensions. The accessor "getResponseCode" gives direct access to the value
7525         */
7526        public StringType getResponseCodeElement() { 
7527          if (this.responseCode == null)
7528            if (Configuration.errorOnAutoCreate())
7529              throw new Error("Attempt to auto-create SetupActionAssertComponent.responseCode");
7530            else if (Configuration.doAutoCreate())
7531              this.responseCode = new StringType(); // bb
7532          return this.responseCode;
7533        }
7534
7535        public boolean hasResponseCodeElement() { 
7536          return this.responseCode != null && !this.responseCode.isEmpty();
7537        }
7538
7539        public boolean hasResponseCode() { 
7540          return this.responseCode != null && !this.responseCode.isEmpty();
7541        }
7542
7543        /**
7544         * @param value {@link #responseCode} (The value of the HTTP response code to be tested.). This is the underlying object with id, value and extensions. The accessor "getResponseCode" gives direct access to the value
7545         */
7546        public SetupActionAssertComponent setResponseCodeElement(StringType value) { 
7547          this.responseCode = value;
7548          return this;
7549        }
7550
7551        /**
7552         * @return The value of the HTTP response code to be tested.
7553         */
7554        public String getResponseCode() { 
7555          return this.responseCode == null ? null : this.responseCode.getValue();
7556        }
7557
7558        /**
7559         * @param value The value of the HTTP response code to be tested.
7560         */
7561        public SetupActionAssertComponent setResponseCode(String value) { 
7562          if (Utilities.noString(value))
7563            this.responseCode = null;
7564          else {
7565            if (this.responseCode == null)
7566              this.responseCode = new StringType();
7567            this.responseCode.setValue(value);
7568          }
7569          return this;
7570        }
7571
7572        /**
7573         * @return {@link #sourceId} (Fixture to evaluate the XPath/JSONPath expression or the headerField  against.). This is the underlying object with id, value and extensions. The accessor "getSourceId" gives direct access to the value
7574         */
7575        public IdType getSourceIdElement() { 
7576          if (this.sourceId == null)
7577            if (Configuration.errorOnAutoCreate())
7578              throw new Error("Attempt to auto-create SetupActionAssertComponent.sourceId");
7579            else if (Configuration.doAutoCreate())
7580              this.sourceId = new IdType(); // bb
7581          return this.sourceId;
7582        }
7583
7584        public boolean hasSourceIdElement() { 
7585          return this.sourceId != null && !this.sourceId.isEmpty();
7586        }
7587
7588        public boolean hasSourceId() { 
7589          return this.sourceId != null && !this.sourceId.isEmpty();
7590        }
7591
7592        /**
7593         * @param value {@link #sourceId} (Fixture to evaluate the XPath/JSONPath expression or the headerField  against.). This is the underlying object with id, value and extensions. The accessor "getSourceId" gives direct access to the value
7594         */
7595        public SetupActionAssertComponent setSourceIdElement(IdType value) { 
7596          this.sourceId = value;
7597          return this;
7598        }
7599
7600        /**
7601         * @return Fixture to evaluate the XPath/JSONPath expression or the headerField  against.
7602         */
7603        public String getSourceId() { 
7604          return this.sourceId == null ? null : this.sourceId.getValue();
7605        }
7606
7607        /**
7608         * @param value Fixture to evaluate the XPath/JSONPath expression or the headerField  against.
7609         */
7610        public SetupActionAssertComponent setSourceId(String value) { 
7611          if (Utilities.noString(value))
7612            this.sourceId = null;
7613          else {
7614            if (this.sourceId == null)
7615              this.sourceId = new IdType();
7616            this.sourceId.setValue(value);
7617          }
7618          return this;
7619        }
7620
7621        /**
7622         * @return {@link #stopTestOnFail} (Whether or not the current test execution will stop on failure for this assert.). This is the underlying object with id, value and extensions. The accessor "getStopTestOnFail" gives direct access to the value
7623         */
7624        public BooleanType getStopTestOnFailElement() { 
7625          if (this.stopTestOnFail == null)
7626            if (Configuration.errorOnAutoCreate())
7627              throw new Error("Attempt to auto-create SetupActionAssertComponent.stopTestOnFail");
7628            else if (Configuration.doAutoCreate())
7629              this.stopTestOnFail = new BooleanType(); // bb
7630          return this.stopTestOnFail;
7631        }
7632
7633        public boolean hasStopTestOnFailElement() { 
7634          return this.stopTestOnFail != null && !this.stopTestOnFail.isEmpty();
7635        }
7636
7637        public boolean hasStopTestOnFail() { 
7638          return this.stopTestOnFail != null && !this.stopTestOnFail.isEmpty();
7639        }
7640
7641        /**
7642         * @param value {@link #stopTestOnFail} (Whether or not the current test execution will stop on failure for this assert.). This is the underlying object with id, value and extensions. The accessor "getStopTestOnFail" gives direct access to the value
7643         */
7644        public SetupActionAssertComponent setStopTestOnFailElement(BooleanType value) { 
7645          this.stopTestOnFail = value;
7646          return this;
7647        }
7648
7649        /**
7650         * @return Whether or not the current test execution will stop on failure for this assert.
7651         */
7652        public boolean getStopTestOnFail() { 
7653          return this.stopTestOnFail == null || this.stopTestOnFail.isEmpty() ? false : this.stopTestOnFail.getValue();
7654        }
7655
7656        /**
7657         * @param value Whether or not the current test execution will stop on failure for this assert.
7658         */
7659        public SetupActionAssertComponent setStopTestOnFail(boolean value) { 
7660            if (this.stopTestOnFail == null)
7661              this.stopTestOnFail = new BooleanType();
7662            this.stopTestOnFail.setValue(value);
7663          return this;
7664        }
7665
7666        /**
7667         * @return {@link #validateProfileId} (The ID of the Profile to validate against.). This is the underlying object with id, value and extensions. The accessor "getValidateProfileId" gives direct access to the value
7668         */
7669        public IdType getValidateProfileIdElement() { 
7670          if (this.validateProfileId == null)
7671            if (Configuration.errorOnAutoCreate())
7672              throw new Error("Attempt to auto-create SetupActionAssertComponent.validateProfileId");
7673            else if (Configuration.doAutoCreate())
7674              this.validateProfileId = new IdType(); // bb
7675          return this.validateProfileId;
7676        }
7677
7678        public boolean hasValidateProfileIdElement() { 
7679          return this.validateProfileId != null && !this.validateProfileId.isEmpty();
7680        }
7681
7682        public boolean hasValidateProfileId() { 
7683          return this.validateProfileId != null && !this.validateProfileId.isEmpty();
7684        }
7685
7686        /**
7687         * @param value {@link #validateProfileId} (The ID of the Profile to validate against.). This is the underlying object with id, value and extensions. The accessor "getValidateProfileId" gives direct access to the value
7688         */
7689        public SetupActionAssertComponent setValidateProfileIdElement(IdType value) { 
7690          this.validateProfileId = value;
7691          return this;
7692        }
7693
7694        /**
7695         * @return The ID of the Profile to validate against.
7696         */
7697        public String getValidateProfileId() { 
7698          return this.validateProfileId == null ? null : this.validateProfileId.getValue();
7699        }
7700
7701        /**
7702         * @param value The ID of the Profile to validate against.
7703         */
7704        public SetupActionAssertComponent setValidateProfileId(String value) { 
7705          if (Utilities.noString(value))
7706            this.validateProfileId = null;
7707          else {
7708            if (this.validateProfileId == null)
7709              this.validateProfileId = new IdType();
7710            this.validateProfileId.setValue(value);
7711          }
7712          return this;
7713        }
7714
7715        /**
7716         * @return {@link #value} (The value to compare to.). This is the underlying object with id, value and extensions. The accessor "getValue" gives direct access to the value
7717         */
7718        public StringType getValueElement() { 
7719          if (this.value == null)
7720            if (Configuration.errorOnAutoCreate())
7721              throw new Error("Attempt to auto-create SetupActionAssertComponent.value");
7722            else if (Configuration.doAutoCreate())
7723              this.value = new StringType(); // bb
7724          return this.value;
7725        }
7726
7727        public boolean hasValueElement() { 
7728          return this.value != null && !this.value.isEmpty();
7729        }
7730
7731        public boolean hasValue() { 
7732          return this.value != null && !this.value.isEmpty();
7733        }
7734
7735        /**
7736         * @param value {@link #value} (The value to compare to.). This is the underlying object with id, value and extensions. The accessor "getValue" gives direct access to the value
7737         */
7738        public SetupActionAssertComponent setValueElement(StringType value) { 
7739          this.value = value;
7740          return this;
7741        }
7742
7743        /**
7744         * @return The value to compare to.
7745         */
7746        public String getValue() { 
7747          return this.value == null ? null : this.value.getValue();
7748        }
7749
7750        /**
7751         * @param value The value to compare to.
7752         */
7753        public SetupActionAssertComponent setValue(String value) { 
7754          if (Utilities.noString(value))
7755            this.value = null;
7756          else {
7757            if (this.value == null)
7758              this.value = new StringType();
7759            this.value.setValue(value);
7760          }
7761          return this;
7762        }
7763
7764        /**
7765         * @return {@link #warningOnly} (Whether or not the test execution will produce a warning only on error for this assert.). This is the underlying object with id, value and extensions. The accessor "getWarningOnly" gives direct access to the value
7766         */
7767        public BooleanType getWarningOnlyElement() { 
7768          if (this.warningOnly == null)
7769            if (Configuration.errorOnAutoCreate())
7770              throw new Error("Attempt to auto-create SetupActionAssertComponent.warningOnly");
7771            else if (Configuration.doAutoCreate())
7772              this.warningOnly = new BooleanType(); // bb
7773          return this.warningOnly;
7774        }
7775
7776        public boolean hasWarningOnlyElement() { 
7777          return this.warningOnly != null && !this.warningOnly.isEmpty();
7778        }
7779
7780        public boolean hasWarningOnly() { 
7781          return this.warningOnly != null && !this.warningOnly.isEmpty();
7782        }
7783
7784        /**
7785         * @param value {@link #warningOnly} (Whether or not the test execution will produce a warning only on error for this assert.). This is the underlying object with id, value and extensions. The accessor "getWarningOnly" gives direct access to the value
7786         */
7787        public SetupActionAssertComponent setWarningOnlyElement(BooleanType value) { 
7788          this.warningOnly = value;
7789          return this;
7790        }
7791
7792        /**
7793         * @return Whether or not the test execution will produce a warning only on error for this assert.
7794         */
7795        public boolean getWarningOnly() { 
7796          return this.warningOnly == null || this.warningOnly.isEmpty() ? false : this.warningOnly.getValue();
7797        }
7798
7799        /**
7800         * @param value Whether or not the test execution will produce a warning only on error for this assert.
7801         */
7802        public SetupActionAssertComponent setWarningOnly(boolean value) { 
7803            if (this.warningOnly == null)
7804              this.warningOnly = new BooleanType();
7805            this.warningOnly.setValue(value);
7806          return this;
7807        }
7808
7809        /**
7810         * @return {@link #requirement} (Links or references providing traceability to the testing requirements for this assert.)
7811         */
7812        public List<SetupActionAssertRequirementComponent> getRequirement() { 
7813          if (this.requirement == null)
7814            this.requirement = new ArrayList<SetupActionAssertRequirementComponent>();
7815          return this.requirement;
7816        }
7817
7818        /**
7819         * @return Returns a reference to <code>this</code> for easy method chaining
7820         */
7821        public SetupActionAssertComponent setRequirement(List<SetupActionAssertRequirementComponent> theRequirement) { 
7822          this.requirement = theRequirement;
7823          return this;
7824        }
7825
7826        public boolean hasRequirement() { 
7827          if (this.requirement == null)
7828            return false;
7829          for (SetupActionAssertRequirementComponent item : this.requirement)
7830            if (!item.isEmpty())
7831              return true;
7832          return false;
7833        }
7834
7835        public SetupActionAssertRequirementComponent addRequirement() { //3
7836          SetupActionAssertRequirementComponent t = new SetupActionAssertRequirementComponent();
7837          if (this.requirement == null)
7838            this.requirement = new ArrayList<SetupActionAssertRequirementComponent>();
7839          this.requirement.add(t);
7840          return t;
7841        }
7842
7843        public SetupActionAssertComponent addRequirement(SetupActionAssertRequirementComponent t) { //3
7844          if (t == null)
7845            return this;
7846          if (this.requirement == null)
7847            this.requirement = new ArrayList<SetupActionAssertRequirementComponent>();
7848          this.requirement.add(t);
7849          return this;
7850        }
7851
7852        /**
7853         * @return The first repetition of repeating field {@link #requirement}, creating it if it does not already exist {3}
7854         */
7855        public SetupActionAssertRequirementComponent getRequirementFirstRep() { 
7856          if (getRequirement().isEmpty()) {
7857            addRequirement();
7858          }
7859          return getRequirement().get(0);
7860        }
7861
7862        protected void listChildren(List<Property> children) {
7863          super.listChildren(children);
7864          children.add(new Property("label", "string", "The label would be used for tracking/logging purposes by test engines.", 0, 1, label));
7865          children.add(new Property("description", "string", "The description would be used by test engines for tracking and reporting purposes.", 0, 1, description));
7866          children.add(new Property("direction", "code", "The direction to use for the assertion.", 0, 1, direction));
7867          children.add(new Property("compareToSourceId", "string", "Id of the source fixture used as the contents to be evaluated by either the \"source/expression\" or \"sourceId/path\" definition.", 0, 1, compareToSourceId));
7868          children.add(new Property("compareToSourceExpression", "string", "The FHIRPath expression for a specific value to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.", 0, 1, compareToSourceExpression));
7869          children.add(new Property("compareToSourcePath", "string", "XPath or JSONPath expression to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.", 0, 1, compareToSourcePath));
7870          children.add(new Property("contentType", "code", "The mime-type contents to compare against the request or response message 'Content-Type' header.", 0, 1, contentType));
7871          children.add(new Property("defaultManualCompletion", "code", "The default manual completion outcome applied to this assertion.", 0, 1, defaultManualCompletion));
7872          children.add(new Property("expression", "string", "The FHIRPath expression to be evaluated against the request or response message contents - HTTP headers and payload.", 0, 1, expression));
7873          children.add(new Property("headerField", "string", "The HTTP header field name e.g. 'Location'.", 0, 1, headerField));
7874          children.add(new Property("minimumId", "string", "The ID of a fixture. Asserts that the response contains at a minimum the fixture specified by minimumId.", 0, 1, minimumId));
7875          children.add(new Property("navigationLinks", "boolean", "Whether or not the test execution performs validation on the bundle navigation links.", 0, 1, navigationLinks));
7876          children.add(new Property("operator", "code", "The operator type defines the conditional behavior of the assert.", 0, 1, operator));
7877          children.add(new Property("path", "string", "The XPath or JSONPath expression to be evaluated against the fixture representing the response received from server.", 0, 1, path));
7878          children.add(new Property("requestMethod", "code", "The request method or HTTP operation code to compare against that used by the client system under test.", 0, 1, requestMethod));
7879          children.add(new Property("requestURL", "string", "The value to use in a comparison against the request URL path string.", 0, 1, requestURL));
7880          children.add(new Property("resource", "uri", "The type of the resource.  See the [resource list](resourcelist.html).", 0, 1, resource));
7881          children.add(new Property("response", "code", "continue | switchingProtocols | okay | created | accepted | nonAuthoritativeInformation | noContent | resetContent | partialContent | multipleChoices | movedPermanently | found | seeOther | notModified | useProxy | temporaryRedirect | permanentRedirect | badRequest | unauthorized | paymentRequired | forbidden | notFound | methodNotAllowed | notAcceptable | proxyAuthenticationRequired | requestTimeout | conflict | gone | lengthRequired | preconditionFailed | contentTooLarge | uriTooLong | unsupportedMediaType | rangeNotSatisfiable | expectationFailed | misdirectedRequest | unprocessableContent | upgradeRequired | internalServerError | notImplemented | badGateway | serviceUnavailable | gatewayTimeout | httpVersionNotSupported.", 0, 1, response));
7882          children.add(new Property("responseCode", "string", "The value of the HTTP response code to be tested.", 0, 1, responseCode));
7883          children.add(new Property("sourceId", "id", "Fixture to evaluate the XPath/JSONPath expression or the headerField  against.", 0, 1, sourceId));
7884          children.add(new Property("stopTestOnFail", "boolean", "Whether or not the current test execution will stop on failure for this assert.", 0, 1, stopTestOnFail));
7885          children.add(new Property("validateProfileId", "id", "The ID of the Profile to validate against.", 0, 1, validateProfileId));
7886          children.add(new Property("value", "string", "The value to compare to.", 0, 1, value));
7887          children.add(new Property("warningOnly", "boolean", "Whether or not the test execution will produce a warning only on error for this assert.", 0, 1, warningOnly));
7888          children.add(new Property("requirement", "", "Links or references providing traceability to the testing requirements for this assert.", 0, java.lang.Integer.MAX_VALUE, requirement));
7889        }
7890
7891        @Override
7892        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
7893          switch (_hash) {
7894          case 102727412: /*label*/  return new Property("label", "string", "The label would be used for tracking/logging purposes by test engines.", 0, 1, label);
7895          case -1724546052: /*description*/  return new Property("description", "string", "The description would be used by test engines for tracking and reporting purposes.", 0, 1, description);
7896          case -962590849: /*direction*/  return new Property("direction", "code", "The direction to use for the assertion.", 0, 1, direction);
7897          case 2081856758: /*compareToSourceId*/  return new Property("compareToSourceId", "string", "Id of the source fixture used as the contents to be evaluated by either the \"source/expression\" or \"sourceId/path\" definition.", 0, 1, compareToSourceId);
7898          case -1415702669: /*compareToSourceExpression*/  return new Property("compareToSourceExpression", "string", "The FHIRPath expression for a specific value to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.", 0, 1, compareToSourceExpression);
7899          case -790206144: /*compareToSourcePath*/  return new Property("compareToSourcePath", "string", "XPath or JSONPath expression to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.", 0, 1, compareToSourcePath);
7900          case -389131437: /*contentType*/  return new Property("contentType", "code", "The mime-type contents to compare against the request or response message 'Content-Type' header.", 0, 1, contentType);
7901          case 1448452259: /*defaultManualCompletion*/  return new Property("defaultManualCompletion", "code", "The default manual completion outcome applied to this assertion.", 0, 1, defaultManualCompletion);
7902          case -1795452264: /*expression*/  return new Property("expression", "string", "The FHIRPath expression to be evaluated against the request or response message contents - HTTP headers and payload.", 0, 1, expression);
7903          case 1160732269: /*headerField*/  return new Property("headerField", "string", "The HTTP header field name e.g. 'Location'.", 0, 1, headerField);
7904          case 818925001: /*minimumId*/  return new Property("minimumId", "string", "The ID of a fixture. Asserts that the response contains at a minimum the fixture specified by minimumId.", 0, 1, minimumId);
7905          case 1001488901: /*navigationLinks*/  return new Property("navigationLinks", "boolean", "Whether or not the test execution performs validation on the bundle navigation links.", 0, 1, navigationLinks);
7906          case -500553564: /*operator*/  return new Property("operator", "code", "The operator type defines the conditional behavior of the assert.", 0, 1, operator);
7907          case 3433509: /*path*/  return new Property("path", "string", "The XPath or JSONPath expression to be evaluated against the fixture representing the response received from server.", 0, 1, path);
7908          case 1217874000: /*requestMethod*/  return new Property("requestMethod", "code", "The request method or HTTP operation code to compare against that used by the client system under test.", 0, 1, requestMethod);
7909          case 37099616: /*requestURL*/  return new Property("requestURL", "string", "The value to use in a comparison against the request URL path string.", 0, 1, requestURL);
7910          case -341064690: /*resource*/  return new Property("resource", "uri", "The type of the resource.  See the [resource list](resourcelist.html).", 0, 1, resource);
7911          case -340323263: /*response*/  return new Property("response", "code", "continue | switchingProtocols | okay | created | accepted | nonAuthoritativeInformation | noContent | resetContent | partialContent | multipleChoices | movedPermanently | found | seeOther | notModified | useProxy | temporaryRedirect | permanentRedirect | badRequest | unauthorized | paymentRequired | forbidden | notFound | methodNotAllowed | notAcceptable | proxyAuthenticationRequired | requestTimeout | conflict | gone | lengthRequired | preconditionFailed | contentTooLarge | uriTooLong | unsupportedMediaType | rangeNotSatisfiable | expectationFailed | misdirectedRequest | unprocessableContent | upgradeRequired | internalServerError | notImplemented | badGateway | serviceUnavailable | gatewayTimeout | httpVersionNotSupported.", 0, 1, response);
7912          case 1438723534: /*responseCode*/  return new Property("responseCode", "string", "The value of the HTTP response code to be tested.", 0, 1, responseCode);
7913          case 1746327190: /*sourceId*/  return new Property("sourceId", "id", "Fixture to evaluate the XPath/JSONPath expression or the headerField  against.", 0, 1, sourceId);
7914          case -626616719: /*stopTestOnFail*/  return new Property("stopTestOnFail", "boolean", "Whether or not the current test execution will stop on failure for this assert.", 0, 1, stopTestOnFail);
7915          case 1555541038: /*validateProfileId*/  return new Property("validateProfileId", "id", "The ID of the Profile to validate against.", 0, 1, validateProfileId);
7916          case 111972721: /*value*/  return new Property("value", "string", "The value to compare to.", 0, 1, value);
7917          case -481159832: /*warningOnly*/  return new Property("warningOnly", "boolean", "Whether or not the test execution will produce a warning only on error for this assert.", 0, 1, warningOnly);
7918          case 363387971: /*requirement*/  return new Property("requirement", "", "Links or references providing traceability to the testing requirements for this assert.", 0, java.lang.Integer.MAX_VALUE, requirement);
7919          default: return super.getNamedProperty(_hash, _name, _checkValid);
7920          }
7921
7922        }
7923
7924      @Override
7925      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
7926        switch (hash) {
7927        case 102727412: /*label*/ return this.label == null ? new Base[0] : new Base[] {this.label}; // StringType
7928        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType
7929        case -962590849: /*direction*/ return this.direction == null ? new Base[0] : new Base[] {this.direction}; // Enumeration<AssertionDirectionType>
7930        case 2081856758: /*compareToSourceId*/ return this.compareToSourceId == null ? new Base[0] : new Base[] {this.compareToSourceId}; // StringType
7931        case -1415702669: /*compareToSourceExpression*/ return this.compareToSourceExpression == null ? new Base[0] : new Base[] {this.compareToSourceExpression}; // StringType
7932        case -790206144: /*compareToSourcePath*/ return this.compareToSourcePath == null ? new Base[0] : new Base[] {this.compareToSourcePath}; // StringType
7933        case -389131437: /*contentType*/ return this.contentType == null ? new Base[0] : new Base[] {this.contentType}; // CodeType
7934        case 1448452259: /*defaultManualCompletion*/ return this.defaultManualCompletion == null ? new Base[0] : new Base[] {this.defaultManualCompletion}; // Enumeration<AssertionManualCompletionType>
7935        case -1795452264: /*expression*/ return this.expression == null ? new Base[0] : new Base[] {this.expression}; // StringType
7936        case 1160732269: /*headerField*/ return this.headerField == null ? new Base[0] : new Base[] {this.headerField}; // StringType
7937        case 818925001: /*minimumId*/ return this.minimumId == null ? new Base[0] : new Base[] {this.minimumId}; // StringType
7938        case 1001488901: /*navigationLinks*/ return this.navigationLinks == null ? new Base[0] : new Base[] {this.navigationLinks}; // BooleanType
7939        case -500553564: /*operator*/ return this.operator == null ? new Base[0] : new Base[] {this.operator}; // Enumeration<AssertionOperatorType>
7940        case 3433509: /*path*/ return this.path == null ? new Base[0] : new Base[] {this.path}; // StringType
7941        case 1217874000: /*requestMethod*/ return this.requestMethod == null ? new Base[0] : new Base[] {this.requestMethod}; // Enumeration<TestScriptRequestMethodCode>
7942        case 37099616: /*requestURL*/ return this.requestURL == null ? new Base[0] : new Base[] {this.requestURL}; // StringType
7943        case -341064690: /*resource*/ return this.resource == null ? new Base[0] : new Base[] {this.resource}; // UriType
7944        case -340323263: /*response*/ return this.response == null ? new Base[0] : new Base[] {this.response}; // Enumeration<AssertionResponseTypes>
7945        case 1438723534: /*responseCode*/ return this.responseCode == null ? new Base[0] : new Base[] {this.responseCode}; // StringType
7946        case 1746327190: /*sourceId*/ return this.sourceId == null ? new Base[0] : new Base[] {this.sourceId}; // IdType
7947        case -626616719: /*stopTestOnFail*/ return this.stopTestOnFail == null ? new Base[0] : new Base[] {this.stopTestOnFail}; // BooleanType
7948        case 1555541038: /*validateProfileId*/ return this.validateProfileId == null ? new Base[0] : new Base[] {this.validateProfileId}; // IdType
7949        case 111972721: /*value*/ return this.value == null ? new Base[0] : new Base[] {this.value}; // StringType
7950        case -481159832: /*warningOnly*/ return this.warningOnly == null ? new Base[0] : new Base[] {this.warningOnly}; // BooleanType
7951        case 363387971: /*requirement*/ return this.requirement == null ? new Base[0] : this.requirement.toArray(new Base[this.requirement.size()]); // SetupActionAssertRequirementComponent
7952        default: return super.getProperty(hash, name, checkValid);
7953        }
7954
7955      }
7956
7957      @Override
7958      public Base setProperty(int hash, String name, Base value) throws FHIRException {
7959        switch (hash) {
7960        case 102727412: // label
7961          this.label = TypeConvertor.castToString(value); // StringType
7962          return value;
7963        case -1724546052: // description
7964          this.description = TypeConvertor.castToString(value); // StringType
7965          return value;
7966        case -962590849: // direction
7967          value = new AssertionDirectionTypeEnumFactory().fromType(TypeConvertor.castToCode(value));
7968          this.direction = (Enumeration) value; // Enumeration<AssertionDirectionType>
7969          return value;
7970        case 2081856758: // compareToSourceId
7971          this.compareToSourceId = TypeConvertor.castToString(value); // StringType
7972          return value;
7973        case -1415702669: // compareToSourceExpression
7974          this.compareToSourceExpression = TypeConvertor.castToString(value); // StringType
7975          return value;
7976        case -790206144: // compareToSourcePath
7977          this.compareToSourcePath = TypeConvertor.castToString(value); // StringType
7978          return value;
7979        case -389131437: // contentType
7980          this.contentType = TypeConvertor.castToCode(value); // CodeType
7981          return value;
7982        case 1448452259: // defaultManualCompletion
7983          value = new AssertionManualCompletionTypeEnumFactory().fromType(TypeConvertor.castToCode(value));
7984          this.defaultManualCompletion = (Enumeration) value; // Enumeration<AssertionManualCompletionType>
7985          return value;
7986        case -1795452264: // expression
7987          this.expression = TypeConvertor.castToString(value); // StringType
7988          return value;
7989        case 1160732269: // headerField
7990          this.headerField = TypeConvertor.castToString(value); // StringType
7991          return value;
7992        case 818925001: // minimumId
7993          this.minimumId = TypeConvertor.castToString(value); // StringType
7994          return value;
7995        case 1001488901: // navigationLinks
7996          this.navigationLinks = TypeConvertor.castToBoolean(value); // BooleanType
7997          return value;
7998        case -500553564: // operator
7999          value = new AssertionOperatorTypeEnumFactory().fromType(TypeConvertor.castToCode(value));
8000          this.operator = (Enumeration) value; // Enumeration<AssertionOperatorType>
8001          return value;
8002        case 3433509: // path
8003          this.path = TypeConvertor.castToString(value); // StringType
8004          return value;
8005        case 1217874000: // requestMethod
8006          value = new TestScriptRequestMethodCodeEnumFactory().fromType(TypeConvertor.castToCode(value));
8007          this.requestMethod = (Enumeration) value; // Enumeration<TestScriptRequestMethodCode>
8008          return value;
8009        case 37099616: // requestURL
8010          this.requestURL = TypeConvertor.castToString(value); // StringType
8011          return value;
8012        case -341064690: // resource
8013          this.resource = TypeConvertor.castToUri(value); // UriType
8014          return value;
8015        case -340323263: // response
8016          value = new AssertionResponseTypesEnumFactory().fromType(TypeConvertor.castToCode(value));
8017          this.response = (Enumeration) value; // Enumeration<AssertionResponseTypes>
8018          return value;
8019        case 1438723534: // responseCode
8020          this.responseCode = TypeConvertor.castToString(value); // StringType
8021          return value;
8022        case 1746327190: // sourceId
8023          this.sourceId = TypeConvertor.castToId(value); // IdType
8024          return value;
8025        case -626616719: // stopTestOnFail
8026          this.stopTestOnFail = TypeConvertor.castToBoolean(value); // BooleanType
8027          return value;
8028        case 1555541038: // validateProfileId
8029          this.validateProfileId = TypeConvertor.castToId(value); // IdType
8030          return value;
8031        case 111972721: // value
8032          this.value = TypeConvertor.castToString(value); // StringType
8033          return value;
8034        case -481159832: // warningOnly
8035          this.warningOnly = TypeConvertor.castToBoolean(value); // BooleanType
8036          return value;
8037        case 363387971: // requirement
8038          this.getRequirement().add((SetupActionAssertRequirementComponent) value); // SetupActionAssertRequirementComponent
8039          return value;
8040        default: return super.setProperty(hash, name, value);
8041        }
8042
8043      }
8044
8045      @Override
8046      public Base setProperty(String name, Base value) throws FHIRException {
8047        if (name.equals("label")) {
8048          this.label = TypeConvertor.castToString(value); // StringType
8049        } else if (name.equals("description")) {
8050          this.description = TypeConvertor.castToString(value); // StringType
8051        } else if (name.equals("direction")) {
8052          value = new AssertionDirectionTypeEnumFactory().fromType(TypeConvertor.castToCode(value));
8053          this.direction = (Enumeration) value; // Enumeration<AssertionDirectionType>
8054        } else if (name.equals("compareToSourceId")) {
8055          this.compareToSourceId = TypeConvertor.castToString(value); // StringType
8056        } else if (name.equals("compareToSourceExpression")) {
8057          this.compareToSourceExpression = TypeConvertor.castToString(value); // StringType
8058        } else if (name.equals("compareToSourcePath")) {
8059          this.compareToSourcePath = TypeConvertor.castToString(value); // StringType
8060        } else if (name.equals("contentType")) {
8061          this.contentType = TypeConvertor.castToCode(value); // CodeType
8062        } else if (name.equals("defaultManualCompletion")) {
8063          value = new AssertionManualCompletionTypeEnumFactory().fromType(TypeConvertor.castToCode(value));
8064          this.defaultManualCompletion = (Enumeration) value; // Enumeration<AssertionManualCompletionType>
8065        } else if (name.equals("expression")) {
8066          this.expression = TypeConvertor.castToString(value); // StringType
8067        } else if (name.equals("headerField")) {
8068          this.headerField = TypeConvertor.castToString(value); // StringType
8069        } else if (name.equals("minimumId")) {
8070          this.minimumId = TypeConvertor.castToString(value); // StringType
8071        } else if (name.equals("navigationLinks")) {
8072          this.navigationLinks = TypeConvertor.castToBoolean(value); // BooleanType
8073        } else if (name.equals("operator")) {
8074          value = new AssertionOperatorTypeEnumFactory().fromType(TypeConvertor.castToCode(value));
8075          this.operator = (Enumeration) value; // Enumeration<AssertionOperatorType>
8076        } else if (name.equals("path")) {
8077          this.path = TypeConvertor.castToString(value); // StringType
8078        } else if (name.equals("requestMethod")) {
8079          value = new TestScriptRequestMethodCodeEnumFactory().fromType(TypeConvertor.castToCode(value));
8080          this.requestMethod = (Enumeration) value; // Enumeration<TestScriptRequestMethodCode>
8081        } else if (name.equals("requestURL")) {
8082          this.requestURL = TypeConvertor.castToString(value); // StringType
8083        } else if (name.equals("resource")) {
8084          this.resource = TypeConvertor.castToUri(value); // UriType
8085        } else if (name.equals("response")) {
8086          value = new AssertionResponseTypesEnumFactory().fromType(TypeConvertor.castToCode(value));
8087          this.response = (Enumeration) value; // Enumeration<AssertionResponseTypes>
8088        } else if (name.equals("responseCode")) {
8089          this.responseCode = TypeConvertor.castToString(value); // StringType
8090        } else if (name.equals("sourceId")) {
8091          this.sourceId = TypeConvertor.castToId(value); // IdType
8092        } else if (name.equals("stopTestOnFail")) {
8093          this.stopTestOnFail = TypeConvertor.castToBoolean(value); // BooleanType
8094        } else if (name.equals("validateProfileId")) {
8095          this.validateProfileId = TypeConvertor.castToId(value); // IdType
8096        } else if (name.equals("value")) {
8097          this.value = TypeConvertor.castToString(value); // StringType
8098        } else if (name.equals("warningOnly")) {
8099          this.warningOnly = TypeConvertor.castToBoolean(value); // BooleanType
8100        } else if (name.equals("requirement")) {
8101          this.getRequirement().add((SetupActionAssertRequirementComponent) value);
8102        } else
8103          return super.setProperty(name, value);
8104        return value;
8105      }
8106
8107      @Override
8108      public Base makeProperty(int hash, String name) throws FHIRException {
8109        switch (hash) {
8110        case 102727412:  return getLabelElement();
8111        case -1724546052:  return getDescriptionElement();
8112        case -962590849:  return getDirectionElement();
8113        case 2081856758:  return getCompareToSourceIdElement();
8114        case -1415702669:  return getCompareToSourceExpressionElement();
8115        case -790206144:  return getCompareToSourcePathElement();
8116        case -389131437:  return getContentTypeElement();
8117        case 1448452259:  return getDefaultManualCompletionElement();
8118        case -1795452264:  return getExpressionElement();
8119        case 1160732269:  return getHeaderFieldElement();
8120        case 818925001:  return getMinimumIdElement();
8121        case 1001488901:  return getNavigationLinksElement();
8122        case -500553564:  return getOperatorElement();
8123        case 3433509:  return getPathElement();
8124        case 1217874000:  return getRequestMethodElement();
8125        case 37099616:  return getRequestURLElement();
8126        case -341064690:  return getResourceElement();
8127        case -340323263:  return getResponseElement();
8128        case 1438723534:  return getResponseCodeElement();
8129        case 1746327190:  return getSourceIdElement();
8130        case -626616719:  return getStopTestOnFailElement();
8131        case 1555541038:  return getValidateProfileIdElement();
8132        case 111972721:  return getValueElement();
8133        case -481159832:  return getWarningOnlyElement();
8134        case 363387971:  return addRequirement(); 
8135        default: return super.makeProperty(hash, name);
8136        }
8137
8138      }
8139
8140      @Override
8141      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
8142        switch (hash) {
8143        case 102727412: /*label*/ return new String[] {"string"};
8144        case -1724546052: /*description*/ return new String[] {"string"};
8145        case -962590849: /*direction*/ return new String[] {"code"};
8146        case 2081856758: /*compareToSourceId*/ return new String[] {"string"};
8147        case -1415702669: /*compareToSourceExpression*/ return new String[] {"string"};
8148        case -790206144: /*compareToSourcePath*/ return new String[] {"string"};
8149        case -389131437: /*contentType*/ return new String[] {"code"};
8150        case 1448452259: /*defaultManualCompletion*/ return new String[] {"code"};
8151        case -1795452264: /*expression*/ return new String[] {"string"};
8152        case 1160732269: /*headerField*/ return new String[] {"string"};
8153        case 818925001: /*minimumId*/ return new String[] {"string"};
8154        case 1001488901: /*navigationLinks*/ return new String[] {"boolean"};
8155        case -500553564: /*operator*/ return new String[] {"code"};
8156        case 3433509: /*path*/ return new String[] {"string"};
8157        case 1217874000: /*requestMethod*/ return new String[] {"code"};
8158        case 37099616: /*requestURL*/ return new String[] {"string"};
8159        case -341064690: /*resource*/ return new String[] {"uri"};
8160        case -340323263: /*response*/ return new String[] {"code"};
8161        case 1438723534: /*responseCode*/ return new String[] {"string"};
8162        case 1746327190: /*sourceId*/ return new String[] {"id"};
8163        case -626616719: /*stopTestOnFail*/ return new String[] {"boolean"};
8164        case 1555541038: /*validateProfileId*/ return new String[] {"id"};
8165        case 111972721: /*value*/ return new String[] {"string"};
8166        case -481159832: /*warningOnly*/ return new String[] {"boolean"};
8167        case 363387971: /*requirement*/ return new String[] {};
8168        default: return super.getTypesForProperty(hash, name);
8169        }
8170
8171      }
8172
8173      @Override
8174      public Base addChild(String name) throws FHIRException {
8175        if (name.equals("label")) {
8176          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.label");
8177        }
8178        else if (name.equals("description")) {
8179          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.description");
8180        }
8181        else if (name.equals("direction")) {
8182          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.direction");
8183        }
8184        else if (name.equals("compareToSourceId")) {
8185          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.compareToSourceId");
8186        }
8187        else if (name.equals("compareToSourceExpression")) {
8188          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.compareToSourceExpression");
8189        }
8190        else if (name.equals("compareToSourcePath")) {
8191          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.compareToSourcePath");
8192        }
8193        else if (name.equals("contentType")) {
8194          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.contentType");
8195        }
8196        else if (name.equals("defaultManualCompletion")) {
8197          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.defaultManualCompletion");
8198        }
8199        else if (name.equals("expression")) {
8200          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.expression");
8201        }
8202        else if (name.equals("headerField")) {
8203          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.headerField");
8204        }
8205        else if (name.equals("minimumId")) {
8206          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.minimumId");
8207        }
8208        else if (name.equals("navigationLinks")) {
8209          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.navigationLinks");
8210        }
8211        else if (name.equals("operator")) {
8212          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.operator");
8213        }
8214        else if (name.equals("path")) {
8215          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.path");
8216        }
8217        else if (name.equals("requestMethod")) {
8218          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.requestMethod");
8219        }
8220        else if (name.equals("requestURL")) {
8221          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.requestURL");
8222        }
8223        else if (name.equals("resource")) {
8224          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.resource");
8225        }
8226        else if (name.equals("response")) {
8227          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.response");
8228        }
8229        else if (name.equals("responseCode")) {
8230          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.responseCode");
8231        }
8232        else if (name.equals("sourceId")) {
8233          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.sourceId");
8234        }
8235        else if (name.equals("stopTestOnFail")) {
8236          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.stopTestOnFail");
8237        }
8238        else if (name.equals("validateProfileId")) {
8239          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.validateProfileId");
8240        }
8241        else if (name.equals("value")) {
8242          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.value");
8243        }
8244        else if (name.equals("warningOnly")) {
8245          throw new FHIRException("Cannot call addChild on a singleton property TestScript.setup.action.assert.warningOnly");
8246        }
8247        else if (name.equals("requirement")) {
8248          return addRequirement();
8249        }
8250        else
8251          return super.addChild(name);
8252      }
8253
8254      public SetupActionAssertComponent copy() {
8255        SetupActionAssertComponent dst = new SetupActionAssertComponent();
8256        copyValues(dst);
8257        return dst;
8258      }
8259
8260      public void copyValues(SetupActionAssertComponent dst) {
8261        super.copyValues(dst);
8262        dst.label = label == null ? null : label.copy();
8263        dst.description = description == null ? null : description.copy();
8264        dst.direction = direction == null ? null : direction.copy();
8265        dst.compareToSourceId = compareToSourceId == null ? null : compareToSourceId.copy();
8266        dst.compareToSourceExpression = compareToSourceExpression == null ? null : compareToSourceExpression.copy();
8267        dst.compareToSourcePath = compareToSourcePath == null ? null : compareToSourcePath.copy();
8268        dst.contentType = contentType == null ? null : contentType.copy();
8269        dst.defaultManualCompletion = defaultManualCompletion == null ? null : defaultManualCompletion.copy();
8270        dst.expression = expression == null ? null : expression.copy();
8271        dst.headerField = headerField == null ? null : headerField.copy();
8272        dst.minimumId = minimumId == null ? null : minimumId.copy();
8273        dst.navigationLinks = navigationLinks == null ? null : navigationLinks.copy();
8274        dst.operator = operator == null ? null : operator.copy();
8275        dst.path = path == null ? null : path.copy();
8276        dst.requestMethod = requestMethod == null ? null : requestMethod.copy();
8277        dst.requestURL = requestURL == null ? null : requestURL.copy();
8278        dst.resource = resource == null ? null : resource.copy();
8279        dst.response = response == null ? null : response.copy();
8280        dst.responseCode = responseCode == null ? null : responseCode.copy();
8281        dst.sourceId = sourceId == null ? null : sourceId.copy();
8282        dst.stopTestOnFail = stopTestOnFail == null ? null : stopTestOnFail.copy();
8283        dst.validateProfileId = validateProfileId == null ? null : validateProfileId.copy();
8284        dst.value = value == null ? null : value.copy();
8285        dst.warningOnly = warningOnly == null ? null : warningOnly.copy();
8286        if (requirement != null) {
8287          dst.requirement = new ArrayList<SetupActionAssertRequirementComponent>();
8288          for (SetupActionAssertRequirementComponent i : requirement)
8289            dst.requirement.add(i.copy());
8290        };
8291      }
8292
8293      @Override
8294      public boolean equalsDeep(Base other_) {
8295        if (!super.equalsDeep(other_))
8296          return false;
8297        if (!(other_ instanceof SetupActionAssertComponent))
8298          return false;
8299        SetupActionAssertComponent o = (SetupActionAssertComponent) other_;
8300        return compareDeep(label, o.label, true) && compareDeep(description, o.description, true) && compareDeep(direction, o.direction, true)
8301           && compareDeep(compareToSourceId, o.compareToSourceId, true) && compareDeep(compareToSourceExpression, o.compareToSourceExpression, true)
8302           && compareDeep(compareToSourcePath, o.compareToSourcePath, true) && compareDeep(contentType, o.contentType, true)
8303           && compareDeep(defaultManualCompletion, o.defaultManualCompletion, true) && compareDeep(expression, o.expression, true)
8304           && compareDeep(headerField, o.headerField, true) && compareDeep(minimumId, o.minimumId, true) && compareDeep(navigationLinks, o.navigationLinks, true)
8305           && compareDeep(operator, o.operator, true) && compareDeep(path, o.path, true) && compareDeep(requestMethod, o.requestMethod, true)
8306           && compareDeep(requestURL, o.requestURL, true) && compareDeep(resource, o.resource, true) && compareDeep(response, o.response, true)
8307           && compareDeep(responseCode, o.responseCode, true) && compareDeep(sourceId, o.sourceId, true) && compareDeep(stopTestOnFail, o.stopTestOnFail, true)
8308           && compareDeep(validateProfileId, o.validateProfileId, true) && compareDeep(value, o.value, true)
8309           && compareDeep(warningOnly, o.warningOnly, true) && compareDeep(requirement, o.requirement, true)
8310          ;
8311      }
8312
8313      @Override
8314      public boolean equalsShallow(Base other_) {
8315        if (!super.equalsShallow(other_))
8316          return false;
8317        if (!(other_ instanceof SetupActionAssertComponent))
8318          return false;
8319        SetupActionAssertComponent o = (SetupActionAssertComponent) other_;
8320        return compareValues(label, o.label, true) && compareValues(description, o.description, true) && compareValues(direction, o.direction, true)
8321           && compareValues(compareToSourceId, o.compareToSourceId, true) && compareValues(compareToSourceExpression, o.compareToSourceExpression, true)
8322           && compareValues(compareToSourcePath, o.compareToSourcePath, true) && compareValues(contentType, o.contentType, true)
8323           && compareValues(defaultManualCompletion, o.defaultManualCompletion, true) && compareValues(expression, o.expression, true)
8324           && compareValues(headerField, o.headerField, true) && compareValues(minimumId, o.minimumId, true) && compareValues(navigationLinks, o.navigationLinks, true)
8325           && compareValues(operator, o.operator, true) && compareValues(path, o.path, true) && compareValues(requestMethod, o.requestMethod, true)
8326           && compareValues(requestURL, o.requestURL, true) && compareValues(resource, o.resource, true) && compareValues(response, o.response, true)
8327           && compareValues(responseCode, o.responseCode, true) && compareValues(sourceId, o.sourceId, true) && compareValues(stopTestOnFail, o.stopTestOnFail, true)
8328           && compareValues(validateProfileId, o.validateProfileId, true) && compareValues(value, o.value, true)
8329           && compareValues(warningOnly, o.warningOnly, true);
8330      }
8331
8332      public boolean isEmpty() {
8333        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(label, description, direction
8334          , compareToSourceId, compareToSourceExpression, compareToSourcePath, contentType, defaultManualCompletion
8335          , expression, headerField, minimumId, navigationLinks, operator, path, requestMethod
8336          , requestURL, resource, response, responseCode, sourceId, stopTestOnFail, validateProfileId
8337          , value, warningOnly, requirement);
8338      }
8339
8340  public String fhirType() {
8341    return "TestScript.setup.action.assert";
8342
8343  }
8344
8345  }
8346
8347    @Block()
8348    public static class SetupActionAssertRequirementComponent extends BackboneElement implements IBaseBackboneElement {
8349        /**
8350         * Link or reference providing traceability to the testing requirement for this test.
8351         */
8352        @Child(name = "link", type = {UriType.class, CanonicalType.class}, order=1, min=0, max=1, modifier=false, summary=false)
8353        @Description(shortDefinition="Link or reference to the testing requirement", formalDefinition="Link or reference providing traceability to the testing requirement for this test." )
8354        protected DataType link;
8355
8356        private static final long serialVersionUID = -91187948L;
8357
8358    /**
8359     * Constructor
8360     */
8361      public SetupActionAssertRequirementComponent() {
8362        super();
8363      }
8364
8365        /**
8366         * @return {@link #link} (Link or reference providing traceability to the testing requirement for this test.)
8367         */
8368        public DataType getLink() { 
8369          return this.link;
8370        }
8371
8372        /**
8373         * @return {@link #link} (Link or reference providing traceability to the testing requirement for this test.)
8374         */
8375        public UriType getLinkUriType() throws FHIRException { 
8376          if (this.link == null)
8377            this.link = new UriType();
8378          if (!(this.link instanceof UriType))
8379            throw new FHIRException("Type mismatch: the type UriType was expected, but "+this.link.getClass().getName()+" was encountered");
8380          return (UriType) this.link;
8381        }
8382
8383        public boolean hasLinkUriType() { 
8384          return this != null && this.link instanceof UriType;
8385        }
8386
8387        /**
8388         * @return {@link #link} (Link or reference providing traceability to the testing requirement for this test.)
8389         */
8390        public CanonicalType getLinkCanonicalType() throws FHIRException { 
8391          if (this.link == null)
8392            this.link = new CanonicalType();
8393          if (!(this.link instanceof CanonicalType))
8394            throw new FHIRException("Type mismatch: the type CanonicalType was expected, but "+this.link.getClass().getName()+" was encountered");
8395          return (CanonicalType) this.link;
8396        }
8397
8398        public boolean hasLinkCanonicalType() { 
8399          return this != null && this.link instanceof CanonicalType;
8400        }
8401
8402        public boolean hasLink() { 
8403          return this.link != null && !this.link.isEmpty();
8404        }
8405
8406        /**
8407         * @param value {@link #link} (Link or reference providing traceability to the testing requirement for this test.)
8408         */
8409        public SetupActionAssertRequirementComponent setLink(DataType value) { 
8410          if (value != null && !(value instanceof UriType || value instanceof CanonicalType))
8411            throw new FHIRException("Not the right type for TestScript.setup.action.assert.requirement.link[x]: "+value.fhirType());
8412          this.link = value;
8413          return this;
8414        }
8415
8416        protected void listChildren(List<Property> children) {
8417          super.listChildren(children);
8418          children.add(new Property("link[x]", "uri|canonical(Requirements)", "Link or reference providing traceability to the testing requirement for this test.", 0, 1, link));
8419        }
8420
8421        @Override
8422        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
8423          switch (_hash) {
8424          case 177076806: /*link[x]*/  return new Property("link[x]", "uri|canonical(Requirements)", "Link or reference providing traceability to the testing requirement for this test.", 0, 1, link);
8425          case 3321850: /*link*/  return new Property("link[x]", "uri|canonical(Requirements)", "Link or reference providing traceability to the testing requirement for this test.", 0, 1, link);
8426          case 177070866: /*linkUri*/  return new Property("link[x]", "uri", "Link or reference providing traceability to the testing requirement for this test.", 0, 1, link);
8427          case -2064880102: /*linkCanonical*/  return new Property("link[x]", "canonical(Requirements)", "Link or reference providing traceability to the testing requirement for this test.", 0, 1, link);
8428          default: return super.getNamedProperty(_hash, _name, _checkValid);
8429          }
8430
8431        }
8432
8433      @Override
8434      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
8435        switch (hash) {
8436        case 3321850: /*link*/ return this.link == null ? new Base[0] : new Base[] {this.link}; // DataType
8437        default: return super.getProperty(hash, name, checkValid);
8438        }
8439
8440      }
8441
8442      @Override
8443      public Base setProperty(int hash, String name, Base value) throws FHIRException {
8444        switch (hash) {
8445        case 3321850: // link
8446          this.link = TypeConvertor.castToType(value); // DataType
8447          return value;
8448        default: return super.setProperty(hash, name, value);
8449        }
8450
8451      }
8452
8453      @Override
8454      public Base setProperty(String name, Base value) throws FHIRException {
8455        if (name.equals("link[x]")) {
8456          this.link = TypeConvertor.castToType(value); // DataType
8457        } else
8458          return super.setProperty(name, value);
8459        return value;
8460      }
8461
8462      @Override
8463      public Base makeProperty(int hash, String name) throws FHIRException {
8464        switch (hash) {
8465        case 177076806:  return getLink();
8466        case 3321850:  return getLink();
8467        default: return super.makeProperty(hash, name);
8468        }
8469
8470      }
8471
8472      @Override
8473      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
8474        switch (hash) {
8475        case 3321850: /*link*/ return new String[] {"uri", "canonical"};
8476        default: return super.getTypesForProperty(hash, name);
8477        }
8478
8479      }
8480
8481      @Override
8482      public Base addChild(String name) throws FHIRException {
8483        if (name.equals("linkUri")) {
8484          this.link = new UriType();
8485          return this.link;
8486        }
8487        else if (name.equals("linkCanonical")) {
8488          this.link = new CanonicalType();
8489          return this.link;
8490        }
8491        else
8492          return super.addChild(name);
8493      }
8494
8495      public SetupActionAssertRequirementComponent copy() {
8496        SetupActionAssertRequirementComponent dst = new SetupActionAssertRequirementComponent();
8497        copyValues(dst);
8498        return dst;
8499      }
8500
8501      public void copyValues(SetupActionAssertRequirementComponent dst) {
8502        super.copyValues(dst);
8503        dst.link = link == null ? null : link.copy();
8504      }
8505
8506      @Override
8507      public boolean equalsDeep(Base other_) {
8508        if (!super.equalsDeep(other_))
8509          return false;
8510        if (!(other_ instanceof SetupActionAssertRequirementComponent))
8511          return false;
8512        SetupActionAssertRequirementComponent o = (SetupActionAssertRequirementComponent) other_;
8513        return compareDeep(link, o.link, true);
8514      }
8515
8516      @Override
8517      public boolean equalsShallow(Base other_) {
8518        if (!super.equalsShallow(other_))
8519          return false;
8520        if (!(other_ instanceof SetupActionAssertRequirementComponent))
8521          return false;
8522        SetupActionAssertRequirementComponent o = (SetupActionAssertRequirementComponent) other_;
8523        return true;
8524      }
8525
8526      public boolean isEmpty() {
8527        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(link);
8528      }
8529
8530  public String fhirType() {
8531    return "TestScript.setup.action.assert.requirement";
8532
8533  }
8534
8535  }
8536
8537    @Block()
8538    public static class TestScriptTestComponent extends BackboneElement implements IBaseBackboneElement {
8539        /**
8540         * The name of this test used for tracking/logging purposes by test engines.
8541         */
8542        @Child(name = "name", type = {StringType.class}, order=1, min=0, max=1, modifier=false, summary=false)
8543        @Description(shortDefinition="Tracking/logging name of this test", formalDefinition="The name of this test used for tracking/logging purposes by test engines." )
8544        protected StringType name;
8545
8546        /**
8547         * A short description of the test used by test engines for tracking and reporting purposes.
8548         */
8549        @Child(name = "description", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=false)
8550        @Description(shortDefinition="Tracking/reporting short description of the test", formalDefinition="A short description of the test used by test engines for tracking and reporting purposes." )
8551        protected StringType description;
8552
8553        /**
8554         * Action would contain either an operation or an assertion.
8555         */
8556        @Child(name = "action", type = {}, order=3, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
8557        @Description(shortDefinition="A test operation or assert to perform", formalDefinition="Action would contain either an operation or an assertion." )
8558        protected List<TestActionComponent> action;
8559
8560        private static final long serialVersionUID = -865006110L;
8561
8562    /**
8563     * Constructor
8564     */
8565      public TestScriptTestComponent() {
8566        super();
8567      }
8568
8569    /**
8570     * Constructor
8571     */
8572      public TestScriptTestComponent(TestActionComponent action) {
8573        super();
8574        this.addAction(action);
8575      }
8576
8577        /**
8578         * @return {@link #name} (The name of this test used for tracking/logging purposes by test engines.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
8579         */
8580        public StringType getNameElement() { 
8581          if (this.name == null)
8582            if (Configuration.errorOnAutoCreate())
8583              throw new Error("Attempt to auto-create TestScriptTestComponent.name");
8584            else if (Configuration.doAutoCreate())
8585              this.name = new StringType(); // bb
8586          return this.name;
8587        }
8588
8589        public boolean hasNameElement() { 
8590          return this.name != null && !this.name.isEmpty();
8591        }
8592
8593        public boolean hasName() { 
8594          return this.name != null && !this.name.isEmpty();
8595        }
8596
8597        /**
8598         * @param value {@link #name} (The name of this test used for tracking/logging purposes by test engines.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
8599         */
8600        public TestScriptTestComponent setNameElement(StringType value) { 
8601          this.name = value;
8602          return this;
8603        }
8604
8605        /**
8606         * @return The name of this test used for tracking/logging purposes by test engines.
8607         */
8608        public String getName() { 
8609          return this.name == null ? null : this.name.getValue();
8610        }
8611
8612        /**
8613         * @param value The name of this test used for tracking/logging purposes by test engines.
8614         */
8615        public TestScriptTestComponent setName(String value) { 
8616          if (Utilities.noString(value))
8617            this.name = null;
8618          else {
8619            if (this.name == null)
8620              this.name = new StringType();
8621            this.name.setValue(value);
8622          }
8623          return this;
8624        }
8625
8626        /**
8627         * @return {@link #description} (A short description of the test used by test engines for tracking and reporting purposes.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
8628         */
8629        public StringType getDescriptionElement() { 
8630          if (this.description == null)
8631            if (Configuration.errorOnAutoCreate())
8632              throw new Error("Attempt to auto-create TestScriptTestComponent.description");
8633            else if (Configuration.doAutoCreate())
8634              this.description = new StringType(); // bb
8635          return this.description;
8636        }
8637
8638        public boolean hasDescriptionElement() { 
8639          return this.description != null && !this.description.isEmpty();
8640        }
8641
8642        public boolean hasDescription() { 
8643          return this.description != null && !this.description.isEmpty();
8644        }
8645
8646        /**
8647         * @param value {@link #description} (A short description of the test used by test engines for tracking and reporting purposes.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
8648         */
8649        public TestScriptTestComponent setDescriptionElement(StringType value) { 
8650          this.description = value;
8651          return this;
8652        }
8653
8654        /**
8655         * @return A short description of the test used by test engines for tracking and reporting purposes.
8656         */
8657        public String getDescription() { 
8658          return this.description == null ? null : this.description.getValue();
8659        }
8660
8661        /**
8662         * @param value A short description of the test used by test engines for tracking and reporting purposes.
8663         */
8664        public TestScriptTestComponent setDescription(String value) { 
8665          if (Utilities.noString(value))
8666            this.description = null;
8667          else {
8668            if (this.description == null)
8669              this.description = new StringType();
8670            this.description.setValue(value);
8671          }
8672          return this;
8673        }
8674
8675        /**
8676         * @return {@link #action} (Action would contain either an operation or an assertion.)
8677         */
8678        public List<TestActionComponent> getAction() { 
8679          if (this.action == null)
8680            this.action = new ArrayList<TestActionComponent>();
8681          return this.action;
8682        }
8683
8684        /**
8685         * @return Returns a reference to <code>this</code> for easy method chaining
8686         */
8687        public TestScriptTestComponent setAction(List<TestActionComponent> theAction) { 
8688          this.action = theAction;
8689          return this;
8690        }
8691
8692        public boolean hasAction() { 
8693          if (this.action == null)
8694            return false;
8695          for (TestActionComponent item : this.action)
8696            if (!item.isEmpty())
8697              return true;
8698          return false;
8699        }
8700
8701        public TestActionComponent addAction() { //3
8702          TestActionComponent t = new TestActionComponent();
8703          if (this.action == null)
8704            this.action = new ArrayList<TestActionComponent>();
8705          this.action.add(t);
8706          return t;
8707        }
8708
8709        public TestScriptTestComponent addAction(TestActionComponent t) { //3
8710          if (t == null)
8711            return this;
8712          if (this.action == null)
8713            this.action = new ArrayList<TestActionComponent>();
8714          this.action.add(t);
8715          return this;
8716        }
8717
8718        /**
8719         * @return The first repetition of repeating field {@link #action}, creating it if it does not already exist {3}
8720         */
8721        public TestActionComponent getActionFirstRep() { 
8722          if (getAction().isEmpty()) {
8723            addAction();
8724          }
8725          return getAction().get(0);
8726        }
8727
8728        protected void listChildren(List<Property> children) {
8729          super.listChildren(children);
8730          children.add(new Property("name", "string", "The name of this test used for tracking/logging purposes by test engines.", 0, 1, name));
8731          children.add(new Property("description", "string", "A short description of the test used by test engines for tracking and reporting purposes.", 0, 1, description));
8732          children.add(new Property("action", "", "Action would contain either an operation or an assertion.", 0, java.lang.Integer.MAX_VALUE, action));
8733        }
8734
8735        @Override
8736        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
8737          switch (_hash) {
8738          case 3373707: /*name*/  return new Property("name", "string", "The name of this test used for tracking/logging purposes by test engines.", 0, 1, name);
8739          case -1724546052: /*description*/  return new Property("description", "string", "A short description of the test used by test engines for tracking and reporting purposes.", 0, 1, description);
8740          case -1422950858: /*action*/  return new Property("action", "", "Action would contain either an operation or an assertion.", 0, java.lang.Integer.MAX_VALUE, action);
8741          default: return super.getNamedProperty(_hash, _name, _checkValid);
8742          }
8743
8744        }
8745
8746      @Override
8747      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
8748        switch (hash) {
8749        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
8750        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType
8751        case -1422950858: /*action*/ return this.action == null ? new Base[0] : this.action.toArray(new Base[this.action.size()]); // TestActionComponent
8752        default: return super.getProperty(hash, name, checkValid);
8753        }
8754
8755      }
8756
8757      @Override
8758      public Base setProperty(int hash, String name, Base value) throws FHIRException {
8759        switch (hash) {
8760        case 3373707: // name
8761          this.name = TypeConvertor.castToString(value); // StringType
8762          return value;
8763        case -1724546052: // description
8764          this.description = TypeConvertor.castToString(value); // StringType
8765          return value;
8766        case -1422950858: // action
8767          this.getAction().add((TestActionComponent) value); // TestActionComponent
8768          return value;
8769        default: return super.setProperty(hash, name, value);
8770        }
8771
8772      }
8773
8774      @Override
8775      public Base setProperty(String name, Base value) throws FHIRException {
8776        if (name.equals("name")) {
8777          this.name = TypeConvertor.castToString(value); // StringType
8778        } else if (name.equals("description")) {
8779          this.description = TypeConvertor.castToString(value); // StringType
8780        } else if (name.equals("action")) {
8781          this.getAction().add((TestActionComponent) value);
8782        } else
8783          return super.setProperty(name, value);
8784        return value;
8785      }
8786
8787      @Override
8788      public Base makeProperty(int hash, String name) throws FHIRException {
8789        switch (hash) {
8790        case 3373707:  return getNameElement();
8791        case -1724546052:  return getDescriptionElement();
8792        case -1422950858:  return addAction(); 
8793        default: return super.makeProperty(hash, name);
8794        }
8795
8796      }
8797
8798      @Override
8799      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
8800        switch (hash) {
8801        case 3373707: /*name*/ return new String[] {"string"};
8802        case -1724546052: /*description*/ return new String[] {"string"};
8803        case -1422950858: /*action*/ return new String[] {};
8804        default: return super.getTypesForProperty(hash, name);
8805        }
8806
8807      }
8808
8809      @Override
8810      public Base addChild(String name) throws FHIRException {
8811        if (name.equals("name")) {
8812          throw new FHIRException("Cannot call addChild on a singleton property TestScript.test.name");
8813        }
8814        else if (name.equals("description")) {
8815          throw new FHIRException("Cannot call addChild on a singleton property TestScript.test.description");
8816        }
8817        else if (name.equals("action")) {
8818          return addAction();
8819        }
8820        else
8821          return super.addChild(name);
8822      }
8823
8824      public TestScriptTestComponent copy() {
8825        TestScriptTestComponent dst = new TestScriptTestComponent();
8826        copyValues(dst);
8827        return dst;
8828      }
8829
8830      public void copyValues(TestScriptTestComponent dst) {
8831        super.copyValues(dst);
8832        dst.name = name == null ? null : name.copy();
8833        dst.description = description == null ? null : description.copy();
8834        if (action != null) {
8835          dst.action = new ArrayList<TestActionComponent>();
8836          for (TestActionComponent i : action)
8837            dst.action.add(i.copy());
8838        };
8839      }
8840
8841      @Override
8842      public boolean equalsDeep(Base other_) {
8843        if (!super.equalsDeep(other_))
8844          return false;
8845        if (!(other_ instanceof TestScriptTestComponent))
8846          return false;
8847        TestScriptTestComponent o = (TestScriptTestComponent) other_;
8848        return compareDeep(name, o.name, true) && compareDeep(description, o.description, true) && compareDeep(action, o.action, true)
8849          ;
8850      }
8851
8852      @Override
8853      public boolean equalsShallow(Base other_) {
8854        if (!super.equalsShallow(other_))
8855          return false;
8856        if (!(other_ instanceof TestScriptTestComponent))
8857          return false;
8858        TestScriptTestComponent o = (TestScriptTestComponent) other_;
8859        return compareValues(name, o.name, true) && compareValues(description, o.description, true);
8860      }
8861
8862      public boolean isEmpty() {
8863        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, description, action
8864          );
8865      }
8866
8867  public String fhirType() {
8868    return "TestScript.test";
8869
8870  }
8871
8872  }
8873
8874    @Block()
8875    public static class TestActionComponent extends BackboneElement implements IBaseBackboneElement {
8876        /**
8877         * An operation would involve a REST request to a server.
8878         */
8879        @Child(name = "operation", type = {SetupActionOperationComponent.class}, order=1, min=0, max=1, modifier=false, summary=false)
8880        @Description(shortDefinition="The setup operation to perform", formalDefinition="An operation would involve a REST request to a server." )
8881        protected SetupActionOperationComponent operation;
8882
8883        /**
8884         * Evaluates the results of previous operations to determine if the server under test behaves appropriately.
8885         */
8886        @Child(name = "assert", type = {SetupActionAssertComponent.class}, order=2, min=0, max=1, modifier=false, summary=false)
8887        @Description(shortDefinition="The setup assertion to perform", formalDefinition="Evaluates the results of previous operations to determine if the server under test behaves appropriately." )
8888        protected SetupActionAssertComponent assert_;
8889
8890        private static final long serialVersionUID = -252088305L;
8891
8892    /**
8893     * Constructor
8894     */
8895      public TestActionComponent() {
8896        super();
8897      }
8898
8899        /**
8900         * @return {@link #operation} (An operation would involve a REST request to a server.)
8901         */
8902        public SetupActionOperationComponent getOperation() { 
8903          if (this.operation == null)
8904            if (Configuration.errorOnAutoCreate())
8905              throw new Error("Attempt to auto-create TestActionComponent.operation");
8906            else if (Configuration.doAutoCreate())
8907              this.operation = new SetupActionOperationComponent(); // cc
8908          return this.operation;
8909        }
8910
8911        public boolean hasOperation() { 
8912          return this.operation != null && !this.operation.isEmpty();
8913        }
8914
8915        /**
8916         * @param value {@link #operation} (An operation would involve a REST request to a server.)
8917         */
8918        public TestActionComponent setOperation(SetupActionOperationComponent value) { 
8919          this.operation = value;
8920          return this;
8921        }
8922
8923        /**
8924         * @return {@link #assert_} (Evaluates the results of previous operations to determine if the server under test behaves appropriately.)
8925         */
8926        public SetupActionAssertComponent getAssert() { 
8927          if (this.assert_ == null)
8928            if (Configuration.errorOnAutoCreate())
8929              throw new Error("Attempt to auto-create TestActionComponent.assert_");
8930            else if (Configuration.doAutoCreate())
8931              this.assert_ = new SetupActionAssertComponent(); // cc
8932          return this.assert_;
8933        }
8934
8935        public boolean hasAssert() { 
8936          return this.assert_ != null && !this.assert_.isEmpty();
8937        }
8938
8939        /**
8940         * @param value {@link #assert_} (Evaluates the results of previous operations to determine if the server under test behaves appropriately.)
8941         */
8942        public TestActionComponent setAssert(SetupActionAssertComponent value) { 
8943          this.assert_ = value;
8944          return this;
8945        }
8946
8947        protected void listChildren(List<Property> children) {
8948          super.listChildren(children);
8949          children.add(new Property("operation", "@TestScript.setup.action.operation", "An operation would involve a REST request to a server.", 0, 1, operation));
8950          children.add(new Property("assert", "@TestScript.setup.action.assert", "Evaluates the results of previous operations to determine if the server under test behaves appropriately.", 0, 1, assert_));
8951        }
8952
8953        @Override
8954        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
8955          switch (_hash) {
8956          case 1662702951: /*operation*/  return new Property("operation", "@TestScript.setup.action.operation", "An operation would involve a REST request to a server.", 0, 1, operation);
8957          case -1408208058: /*assert*/  return new Property("assert", "@TestScript.setup.action.assert", "Evaluates the results of previous operations to determine if the server under test behaves appropriately.", 0, 1, assert_);
8958          default: return super.getNamedProperty(_hash, _name, _checkValid);
8959          }
8960
8961        }
8962
8963      @Override
8964      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
8965        switch (hash) {
8966        case 1662702951: /*operation*/ return this.operation == null ? new Base[0] : new Base[] {this.operation}; // SetupActionOperationComponent
8967        case -1408208058: /*assert*/ return this.assert_ == null ? new Base[0] : new Base[] {this.assert_}; // SetupActionAssertComponent
8968        default: return super.getProperty(hash, name, checkValid);
8969        }
8970
8971      }
8972
8973      @Override
8974      public Base setProperty(int hash, String name, Base value) throws FHIRException {
8975        switch (hash) {
8976        case 1662702951: // operation
8977          this.operation = (SetupActionOperationComponent) value; // SetupActionOperationComponent
8978          return value;
8979        case -1408208058: // assert
8980          this.assert_ = (SetupActionAssertComponent) value; // SetupActionAssertComponent
8981          return value;
8982        default: return super.setProperty(hash, name, value);
8983        }
8984
8985      }
8986
8987      @Override
8988      public Base setProperty(String name, Base value) throws FHIRException {
8989        if (name.equals("operation")) {
8990          this.operation = (SetupActionOperationComponent) value; // SetupActionOperationComponent
8991        } else if (name.equals("assert")) {
8992          this.assert_ = (SetupActionAssertComponent) value; // SetupActionAssertComponent
8993        } else
8994          return super.setProperty(name, value);
8995        return value;
8996      }
8997
8998      @Override
8999      public Base makeProperty(int hash, String name) throws FHIRException {
9000        switch (hash) {
9001        case 1662702951:  return getOperation();
9002        case -1408208058:  return getAssert();
9003        default: return super.makeProperty(hash, name);
9004        }
9005
9006      }
9007
9008      @Override
9009      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
9010        switch (hash) {
9011        case 1662702951: /*operation*/ return new String[] {"@TestScript.setup.action.operation"};
9012        case -1408208058: /*assert*/ return new String[] {"@TestScript.setup.action.assert"};
9013        default: return super.getTypesForProperty(hash, name);
9014        }
9015
9016      }
9017
9018      @Override
9019      public Base addChild(String name) throws FHIRException {
9020        if (name.equals("operation")) {
9021          this.operation = new SetupActionOperationComponent();
9022          return this.operation;
9023        }
9024        else if (name.equals("assert")) {
9025          this.assert_ = new SetupActionAssertComponent();
9026          return this.assert_;
9027        }
9028        else
9029          return super.addChild(name);
9030      }
9031
9032      public TestActionComponent copy() {
9033        TestActionComponent dst = new TestActionComponent();
9034        copyValues(dst);
9035        return dst;
9036      }
9037
9038      public void copyValues(TestActionComponent dst) {
9039        super.copyValues(dst);
9040        dst.operation = operation == null ? null : operation.copy();
9041        dst.assert_ = assert_ == null ? null : assert_.copy();
9042      }
9043
9044      @Override
9045      public boolean equalsDeep(Base other_) {
9046        if (!super.equalsDeep(other_))
9047          return false;
9048        if (!(other_ instanceof TestActionComponent))
9049          return false;
9050        TestActionComponent o = (TestActionComponent) other_;
9051        return compareDeep(operation, o.operation, true) && compareDeep(assert_, o.assert_, true);
9052      }
9053
9054      @Override
9055      public boolean equalsShallow(Base other_) {
9056        if (!super.equalsShallow(other_))
9057          return false;
9058        if (!(other_ instanceof TestActionComponent))
9059          return false;
9060        TestActionComponent o = (TestActionComponent) other_;
9061        return true;
9062      }
9063
9064      public boolean isEmpty() {
9065        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(operation, assert_);
9066      }
9067
9068  public String fhirType() {
9069    return "TestScript.test.action";
9070
9071  }
9072
9073  }
9074
9075    @Block()
9076    public static class TestScriptTeardownComponent extends BackboneElement implements IBaseBackboneElement {
9077        /**
9078         * The teardown action will only contain an operation.
9079         */
9080        @Child(name = "action", type = {}, order=1, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
9081        @Description(shortDefinition="One or more teardown operations to perform", formalDefinition="The teardown action will only contain an operation." )
9082        protected List<TeardownActionComponent> action;
9083
9084        private static final long serialVersionUID = 1168638089L;
9085
9086    /**
9087     * Constructor
9088     */
9089      public TestScriptTeardownComponent() {
9090        super();
9091      }
9092
9093    /**
9094     * Constructor
9095     */
9096      public TestScriptTeardownComponent(TeardownActionComponent action) {
9097        super();
9098        this.addAction(action);
9099      }
9100
9101        /**
9102         * @return {@link #action} (The teardown action will only contain an operation.)
9103         */
9104        public List<TeardownActionComponent> getAction() { 
9105          if (this.action == null)
9106            this.action = new ArrayList<TeardownActionComponent>();
9107          return this.action;
9108        }
9109
9110        /**
9111         * @return Returns a reference to <code>this</code> for easy method chaining
9112         */
9113        public TestScriptTeardownComponent setAction(List<TeardownActionComponent> theAction) { 
9114          this.action = theAction;
9115          return this;
9116        }
9117
9118        public boolean hasAction() { 
9119          if (this.action == null)
9120            return false;
9121          for (TeardownActionComponent item : this.action)
9122            if (!item.isEmpty())
9123              return true;
9124          return false;
9125        }
9126
9127        public TeardownActionComponent addAction() { //3
9128          TeardownActionComponent t = new TeardownActionComponent();
9129          if (this.action == null)
9130            this.action = new ArrayList<TeardownActionComponent>();
9131          this.action.add(t);
9132          return t;
9133        }
9134
9135        public TestScriptTeardownComponent addAction(TeardownActionComponent t) { //3
9136          if (t == null)
9137            return this;
9138          if (this.action == null)
9139            this.action = new ArrayList<TeardownActionComponent>();
9140          this.action.add(t);
9141          return this;
9142        }
9143
9144        /**
9145         * @return The first repetition of repeating field {@link #action}, creating it if it does not already exist {3}
9146         */
9147        public TeardownActionComponent getActionFirstRep() { 
9148          if (getAction().isEmpty()) {
9149            addAction();
9150          }
9151          return getAction().get(0);
9152        }
9153
9154        protected void listChildren(List<Property> children) {
9155          super.listChildren(children);
9156          children.add(new Property("action", "", "The teardown action will only contain an operation.", 0, java.lang.Integer.MAX_VALUE, action));
9157        }
9158
9159        @Override
9160        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
9161          switch (_hash) {
9162          case -1422950858: /*action*/  return new Property("action", "", "The teardown action will only contain an operation.", 0, java.lang.Integer.MAX_VALUE, action);
9163          default: return super.getNamedProperty(_hash, _name, _checkValid);
9164          }
9165
9166        }
9167
9168      @Override
9169      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
9170        switch (hash) {
9171        case -1422950858: /*action*/ return this.action == null ? new Base[0] : this.action.toArray(new Base[this.action.size()]); // TeardownActionComponent
9172        default: return super.getProperty(hash, name, checkValid);
9173        }
9174
9175      }
9176
9177      @Override
9178      public Base setProperty(int hash, String name, Base value) throws FHIRException {
9179        switch (hash) {
9180        case -1422950858: // action
9181          this.getAction().add((TeardownActionComponent) value); // TeardownActionComponent
9182          return value;
9183        default: return super.setProperty(hash, name, value);
9184        }
9185
9186      }
9187
9188      @Override
9189      public Base setProperty(String name, Base value) throws FHIRException {
9190        if (name.equals("action")) {
9191          this.getAction().add((TeardownActionComponent) value);
9192        } else
9193          return super.setProperty(name, value);
9194        return value;
9195      }
9196
9197      @Override
9198      public Base makeProperty(int hash, String name) throws FHIRException {
9199        switch (hash) {
9200        case -1422950858:  return addAction(); 
9201        default: return super.makeProperty(hash, name);
9202        }
9203
9204      }
9205
9206      @Override
9207      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
9208        switch (hash) {
9209        case -1422950858: /*action*/ return new String[] {};
9210        default: return super.getTypesForProperty(hash, name);
9211        }
9212
9213      }
9214
9215      @Override
9216      public Base addChild(String name) throws FHIRException {
9217        if (name.equals("action")) {
9218          return addAction();
9219        }
9220        else
9221          return super.addChild(name);
9222      }
9223
9224      public TestScriptTeardownComponent copy() {
9225        TestScriptTeardownComponent dst = new TestScriptTeardownComponent();
9226        copyValues(dst);
9227        return dst;
9228      }
9229
9230      public void copyValues(TestScriptTeardownComponent dst) {
9231        super.copyValues(dst);
9232        if (action != null) {
9233          dst.action = new ArrayList<TeardownActionComponent>();
9234          for (TeardownActionComponent i : action)
9235            dst.action.add(i.copy());
9236        };
9237      }
9238
9239      @Override
9240      public boolean equalsDeep(Base other_) {
9241        if (!super.equalsDeep(other_))
9242          return false;
9243        if (!(other_ instanceof TestScriptTeardownComponent))
9244          return false;
9245        TestScriptTeardownComponent o = (TestScriptTeardownComponent) other_;
9246        return compareDeep(action, o.action, true);
9247      }
9248
9249      @Override
9250      public boolean equalsShallow(Base other_) {
9251        if (!super.equalsShallow(other_))
9252          return false;
9253        if (!(other_ instanceof TestScriptTeardownComponent))
9254          return false;
9255        TestScriptTeardownComponent o = (TestScriptTeardownComponent) other_;
9256        return true;
9257      }
9258
9259      public boolean isEmpty() {
9260        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(action);
9261      }
9262
9263  public String fhirType() {
9264    return "TestScript.teardown";
9265
9266  }
9267
9268  }
9269
9270    @Block()
9271    public static class TeardownActionComponent extends BackboneElement implements IBaseBackboneElement {
9272        /**
9273         * An operation would involve a REST request to a server.
9274         */
9275        @Child(name = "operation", type = {SetupActionOperationComponent.class}, order=1, min=1, max=1, modifier=false, summary=false)
9276        @Description(shortDefinition="The teardown operation to perform", formalDefinition="An operation would involve a REST request to a server." )
9277        protected SetupActionOperationComponent operation;
9278
9279        private static final long serialVersionUID = -1099598054L;
9280
9281    /**
9282     * Constructor
9283     */
9284      public TeardownActionComponent() {
9285        super();
9286      }
9287
9288    /**
9289     * Constructor
9290     */
9291      public TeardownActionComponent(SetupActionOperationComponent operation) {
9292        super();
9293        this.setOperation(operation);
9294      }
9295
9296        /**
9297         * @return {@link #operation} (An operation would involve a REST request to a server.)
9298         */
9299        public SetupActionOperationComponent getOperation() { 
9300          if (this.operation == null)
9301            if (Configuration.errorOnAutoCreate())
9302              throw new Error("Attempt to auto-create TeardownActionComponent.operation");
9303            else if (Configuration.doAutoCreate())
9304              this.operation = new SetupActionOperationComponent(); // cc
9305          return this.operation;
9306        }
9307
9308        public boolean hasOperation() { 
9309          return this.operation != null && !this.operation.isEmpty();
9310        }
9311
9312        /**
9313         * @param value {@link #operation} (An operation would involve a REST request to a server.)
9314         */
9315        public TeardownActionComponent setOperation(SetupActionOperationComponent value) { 
9316          this.operation = value;
9317          return this;
9318        }
9319
9320        protected void listChildren(List<Property> children) {
9321          super.listChildren(children);
9322          children.add(new Property("operation", "@TestScript.setup.action.operation", "An operation would involve a REST request to a server.", 0, 1, operation));
9323        }
9324
9325        @Override
9326        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
9327          switch (_hash) {
9328          case 1662702951: /*operation*/  return new Property("operation", "@TestScript.setup.action.operation", "An operation would involve a REST request to a server.", 0, 1, operation);
9329          default: return super.getNamedProperty(_hash, _name, _checkValid);
9330          }
9331
9332        }
9333
9334      @Override
9335      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
9336        switch (hash) {
9337        case 1662702951: /*operation*/ return this.operation == null ? new Base[0] : new Base[] {this.operation}; // SetupActionOperationComponent
9338        default: return super.getProperty(hash, name, checkValid);
9339        }
9340
9341      }
9342
9343      @Override
9344      public Base setProperty(int hash, String name, Base value) throws FHIRException {
9345        switch (hash) {
9346        case 1662702951: // operation
9347          this.operation = (SetupActionOperationComponent) value; // SetupActionOperationComponent
9348          return value;
9349        default: return super.setProperty(hash, name, value);
9350        }
9351
9352      }
9353
9354      @Override
9355      public Base setProperty(String name, Base value) throws FHIRException {
9356        if (name.equals("operation")) {
9357          this.operation = (SetupActionOperationComponent) value; // SetupActionOperationComponent
9358        } else
9359          return super.setProperty(name, value);
9360        return value;
9361      }
9362
9363      @Override
9364      public Base makeProperty(int hash, String name) throws FHIRException {
9365        switch (hash) {
9366        case 1662702951:  return getOperation();
9367        default: return super.makeProperty(hash, name);
9368        }
9369
9370      }
9371
9372      @Override
9373      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
9374        switch (hash) {
9375        case 1662702951: /*operation*/ return new String[] {"@TestScript.setup.action.operation"};
9376        default: return super.getTypesForProperty(hash, name);
9377        }
9378
9379      }
9380
9381      @Override
9382      public Base addChild(String name) throws FHIRException {
9383        if (name.equals("operation")) {
9384          this.operation = new SetupActionOperationComponent();
9385          return this.operation;
9386        }
9387        else
9388          return super.addChild(name);
9389      }
9390
9391      public TeardownActionComponent copy() {
9392        TeardownActionComponent dst = new TeardownActionComponent();
9393        copyValues(dst);
9394        return dst;
9395      }
9396
9397      public void copyValues(TeardownActionComponent dst) {
9398        super.copyValues(dst);
9399        dst.operation = operation == null ? null : operation.copy();
9400      }
9401
9402      @Override
9403      public boolean equalsDeep(Base other_) {
9404        if (!super.equalsDeep(other_))
9405          return false;
9406        if (!(other_ instanceof TeardownActionComponent))
9407          return false;
9408        TeardownActionComponent o = (TeardownActionComponent) other_;
9409        return compareDeep(operation, o.operation, true);
9410      }
9411
9412      @Override
9413      public boolean equalsShallow(Base other_) {
9414        if (!super.equalsShallow(other_))
9415          return false;
9416        if (!(other_ instanceof TeardownActionComponent))
9417          return false;
9418        TeardownActionComponent o = (TeardownActionComponent) other_;
9419        return true;
9420      }
9421
9422      public boolean isEmpty() {
9423        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(operation);
9424      }
9425
9426  public String fhirType() {
9427    return "TestScript.teardown.action";
9428
9429  }
9430
9431  }
9432
9433    /**
9434     * An absolute URI that is used to identify this test script 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 test script is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the test script is stored on different servers.
9435     */
9436    @Child(name = "url", type = {UriType.class}, order=0, min=0, max=1, modifier=false, summary=true)
9437    @Description(shortDefinition="Canonical identifier for this test script, represented as a URI (globally unique)", formalDefinition="An absolute URI that is used to identify this test script 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 test script is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the test script is stored on different servers." )
9438    protected UriType url;
9439
9440    /**
9441     * A formal identifier that is used to identify this test script when it is represented in other formats, or referenced in a specification, model, design or an instance.
9442     */
9443    @Child(name = "identifier", type = {Identifier.class}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
9444    @Description(shortDefinition="Additional identifier for the test script", formalDefinition="A formal identifier that is used to identify this test script when it is represented in other formats, or referenced in a specification, model, design or an instance." )
9445    protected List<Identifier> identifier;
9446
9447    /**
9448     * The identifier that is used to identify this version of the test script when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the test script 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.
9449     */
9450    @Child(name = "version", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true)
9451    @Description(shortDefinition="Business version of the test script", formalDefinition="The identifier that is used to identify this version of the test script when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the test script 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." )
9452    protected StringType version;
9453
9454    /**
9455     * Indicates the mechanism used to compare versions to determine which is more current.
9456     */
9457    @Child(name = "versionAlgorithm", type = {StringType.class, Coding.class}, order=3, min=0, max=1, modifier=false, summary=true)
9458    @Description(shortDefinition="How to compare versions", formalDefinition="Indicates the mechanism used to compare versions to determine which is more current." )
9459    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/version-algorithm")
9460    protected DataType versionAlgorithm;
9461
9462    /**
9463     * A natural language name identifying the test script. This name should be usable as an identifier for the module by machine processing applications such as code generation.
9464     */
9465    @Child(name = "name", type = {StringType.class}, order=4, min=1, max=1, modifier=false, summary=true)
9466    @Description(shortDefinition="Name for this test script (computer friendly)", formalDefinition="A natural language name identifying the test script. This name should be usable as an identifier for the module by machine processing applications such as code generation." )
9467    protected StringType name;
9468
9469    /**
9470     * A short, descriptive, user-friendly title for the test script.
9471     */
9472    @Child(name = "title", type = {StringType.class}, order=5, min=0, max=1, modifier=false, summary=true)
9473    @Description(shortDefinition="Name for this test script (human friendly)", formalDefinition="A short, descriptive, user-friendly title for the test script." )
9474    protected StringType title;
9475
9476    /**
9477     * The status of this test script. Enables tracking the life-cycle of the content.
9478     */
9479    @Child(name = "status", type = {CodeType.class}, order=6, min=1, max=1, modifier=true, summary=true)
9480    @Description(shortDefinition="draft | active | retired | unknown", formalDefinition="The status of this test script. Enables tracking the life-cycle of the content." )
9481    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/publication-status")
9482    protected Enumeration<PublicationStatus> status;
9483
9484    /**
9485     * A Boolean value to indicate that this test script is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.
9486     */
9487    @Child(name = "experimental", type = {BooleanType.class}, order=7, min=0, max=1, modifier=false, summary=true)
9488    @Description(shortDefinition="For testing purposes, not real usage", formalDefinition="A Boolean value to indicate that this test script is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage." )
9489    protected BooleanType experimental;
9490
9491    /**
9492     * The date  (and optionally time) when the test script was last significantly changed. 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 test script changes.
9493     */
9494    @Child(name = "date", type = {DateTimeType.class}, order=8, min=0, max=1, modifier=false, summary=true)
9495    @Description(shortDefinition="Date last changed", formalDefinition="The date  (and optionally time) when the test script was last significantly changed. 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 test script changes." )
9496    protected DateTimeType date;
9497
9498    /**
9499     * The name of the organization or individual responsible for the release and ongoing maintenance of the test script.
9500     */
9501    @Child(name = "publisher", type = {StringType.class}, order=9, min=0, max=1, modifier=false, summary=true)
9502    @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 test script." )
9503    protected StringType publisher;
9504
9505    /**
9506     * Contact details to assist a user in finding and communicating with the publisher.
9507     */
9508    @Child(name = "contact", type = {ContactDetail.class}, order=10, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
9509    @Description(shortDefinition="Contact details for the publisher", formalDefinition="Contact details to assist a user in finding and communicating with the publisher." )
9510    protected List<ContactDetail> contact;
9511
9512    /**
9513     * A free text natural language description of the test script from a consumer's perspective.
9514     */
9515    @Child(name = "description", type = {MarkdownType.class}, order=11, min=0, max=1, modifier=false, summary=false)
9516    @Description(shortDefinition="Natural language description of the test script", formalDefinition="A free text natural language description of the test script from a consumer's perspective." )
9517    protected MarkdownType description;
9518
9519    /**
9520     * 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 test script instances.
9521     */
9522    @Child(name = "useContext", type = {UsageContext.class}, order=12, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
9523    @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 test script instances." )
9524    protected List<UsageContext> useContext;
9525
9526    /**
9527     * A legal or geographic region in which the test script is intended to be used.
9528     */
9529    @Child(name = "jurisdiction", type = {CodeableConcept.class}, order=13, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
9530    @Description(shortDefinition="Intended jurisdiction for test script (if applicable)", formalDefinition="A legal or geographic region in which the test script is intended to be used." )
9531    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/jurisdiction")
9532    protected List<CodeableConcept> jurisdiction;
9533
9534    /**
9535     * Explanation of why this test script is needed and why it has been designed as it has.
9536     */
9537    @Child(name = "purpose", type = {MarkdownType.class}, order=14, min=0, max=1, modifier=false, summary=false)
9538    @Description(shortDefinition="Why this test script is defined", formalDefinition="Explanation of why this test script is needed and why it has been designed as it has." )
9539    protected MarkdownType purpose;
9540
9541    /**
9542     * A copyright statement relating to the test script and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the test script.
9543     */
9544    @Child(name = "copyright", type = {MarkdownType.class}, order=15, min=0, max=1, modifier=false, summary=false)
9545    @Description(shortDefinition="Use and/or publishing restrictions", formalDefinition="A copyright statement relating to the test script and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the test script." )
9546    protected MarkdownType copyright;
9547
9548    /**
9549     * 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').
9550     */
9551    @Child(name = "copyrightLabel", type = {StringType.class}, order=16, min=0, max=1, modifier=false, summary=false)
9552    @Description(shortDefinition="Copyright holder and year(s)", formalDefinition="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')." )
9553    protected StringType copyrightLabel;
9554
9555    /**
9556     * An abstract server used in operations within this test script in the origin element.
9557     */
9558    @Child(name = "origin", type = {}, order=17, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
9559    @Description(shortDefinition="An abstract server representing a client or sender in a message exchange", formalDefinition="An abstract server used in operations within this test script in the origin element." )
9560    protected List<TestScriptOriginComponent> origin;
9561
9562    /**
9563     * An abstract server used in operations within this test script in the destination element.
9564     */
9565    @Child(name = "destination", type = {}, order=18, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
9566    @Description(shortDefinition="An abstract server representing a destination or receiver in a message exchange", formalDefinition="An abstract server used in operations within this test script in the destination element." )
9567    protected List<TestScriptDestinationComponent> destination;
9568
9569    /**
9570     * The required capability must exist and are assumed to function correctly on the FHIR server being tested.
9571     */
9572    @Child(name = "metadata", type = {}, order=19, min=0, max=1, modifier=false, summary=false)
9573    @Description(shortDefinition="Required capability that is assumed to function correctly on the FHIR server being tested", formalDefinition="The required capability must exist and are assumed to function correctly on the FHIR server being tested." )
9574    protected TestScriptMetadataComponent metadata;
9575
9576    /**
9577     * The scope indicates a conformance artifact that is tested by the test(s) within this test case and the expectation of the test outcome(s) as well as the intended test phase inclusion.
9578     */
9579    @Child(name = "scope", type = {}, order=20, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
9580    @Description(shortDefinition="Indication of the artifact(s) that are tested by this test case", formalDefinition="The scope indicates a conformance artifact that is tested by the test(s) within this test case and the expectation of the test outcome(s) as well as the intended test phase inclusion." )
9581    protected List<TestScriptScopeComponent> scope;
9582
9583    /**
9584     * Fixture in the test script - by reference (uri). All fixtures are required for the test script to execute.
9585     */
9586    @Child(name = "fixture", type = {}, order=21, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
9587    @Description(shortDefinition="Fixture in the test script - by reference (uri)", formalDefinition="Fixture in the test script - by reference (uri). All fixtures are required for the test script to execute." )
9588    protected List<TestScriptFixtureComponent> fixture;
9589
9590    /**
9591     * Reference to the profile to be used for validation.
9592     */
9593    @Child(name = "profile", type = {CanonicalType.class}, order=22, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
9594    @Description(shortDefinition="Reference of the validation profile", formalDefinition="Reference to the profile to be used for validation." )
9595    protected List<CanonicalType> profile;
9596
9597    /**
9598     * Variable is set based either on element value in response body or on header field value in the response headers.
9599     */
9600    @Child(name = "variable", type = {}, order=23, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
9601    @Description(shortDefinition="Placeholder for evaluated elements", formalDefinition="Variable is set based either on element value in response body or on header field value in the response headers." )
9602    protected List<TestScriptVariableComponent> variable;
9603
9604    /**
9605     * A series of required setup operations before tests are executed.
9606     */
9607    @Child(name = "setup", type = {}, order=24, min=0, max=1, modifier=false, summary=false)
9608    @Description(shortDefinition="A series of required setup operations before tests are executed", formalDefinition="A series of required setup operations before tests are executed." )
9609    protected TestScriptSetupComponent setup;
9610
9611    /**
9612     * A test in this script.
9613     */
9614    @Child(name = "test", type = {}, order=25, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
9615    @Description(shortDefinition="A test in this script", formalDefinition="A test in this script." )
9616    protected List<TestScriptTestComponent> test;
9617
9618    /**
9619     * A series of operations required to clean up after all the tests are executed (successfully or otherwise).
9620     */
9621    @Child(name = "teardown", type = {}, order=26, min=0, max=1, modifier=false, summary=false)
9622    @Description(shortDefinition="A series of required clean up steps", formalDefinition="A series of operations required to clean up after all the tests are executed (successfully or otherwise)." )
9623    protected TestScriptTeardownComponent teardown;
9624
9625    private static final long serialVersionUID = 1566648997L;
9626
9627  /**
9628   * Constructor
9629   */
9630    public TestScript() {
9631      super();
9632    }
9633
9634  /**
9635   * Constructor
9636   */
9637    public TestScript(String name, PublicationStatus status) {
9638      super();
9639      this.setName(name);
9640      this.setStatus(status);
9641    }
9642
9643    /**
9644     * @return {@link #url} (An absolute URI that is used to identify this test script 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 test script is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the test script is stored on different servers.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
9645     */
9646    public UriType getUrlElement() { 
9647      if (this.url == null)
9648        if (Configuration.errorOnAutoCreate())
9649          throw new Error("Attempt to auto-create TestScript.url");
9650        else if (Configuration.doAutoCreate())
9651          this.url = new UriType(); // bb
9652      return this.url;
9653    }
9654
9655    public boolean hasUrlElement() { 
9656      return this.url != null && !this.url.isEmpty();
9657    }
9658
9659    public boolean hasUrl() { 
9660      return this.url != null && !this.url.isEmpty();
9661    }
9662
9663    /**
9664     * @param value {@link #url} (An absolute URI that is used to identify this test script 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 test script is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the test script is stored on different servers.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
9665     */
9666    public TestScript setUrlElement(UriType value) { 
9667      this.url = value;
9668      return this;
9669    }
9670
9671    /**
9672     * @return An absolute URI that is used to identify this test script 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 test script is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the test script is stored on different servers.
9673     */
9674    public String getUrl() { 
9675      return this.url == null ? null : this.url.getValue();
9676    }
9677
9678    /**
9679     * @param value An absolute URI that is used to identify this test script 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 test script is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the test script is stored on different servers.
9680     */
9681    public TestScript setUrl(String value) { 
9682      if (Utilities.noString(value))
9683        this.url = null;
9684      else {
9685        if (this.url == null)
9686          this.url = new UriType();
9687        this.url.setValue(value);
9688      }
9689      return this;
9690    }
9691
9692    /**
9693     * @return {@link #identifier} (A formal identifier that is used to identify this test script when it is represented in other formats, or referenced in a specification, model, design or an instance.)
9694     */
9695    public List<Identifier> getIdentifier() { 
9696      if (this.identifier == null)
9697        this.identifier = new ArrayList<Identifier>();
9698      return this.identifier;
9699    }
9700
9701    /**
9702     * @return Returns a reference to <code>this</code> for easy method chaining
9703     */
9704    public TestScript setIdentifier(List<Identifier> theIdentifier) { 
9705      this.identifier = theIdentifier;
9706      return this;
9707    }
9708
9709    public boolean hasIdentifier() { 
9710      if (this.identifier == null)
9711        return false;
9712      for (Identifier item : this.identifier)
9713        if (!item.isEmpty())
9714          return true;
9715      return false;
9716    }
9717
9718    public Identifier addIdentifier() { //3
9719      Identifier t = new Identifier();
9720      if (this.identifier == null)
9721        this.identifier = new ArrayList<Identifier>();
9722      this.identifier.add(t);
9723      return t;
9724    }
9725
9726    public TestScript addIdentifier(Identifier t) { //3
9727      if (t == null)
9728        return this;
9729      if (this.identifier == null)
9730        this.identifier = new ArrayList<Identifier>();
9731      this.identifier.add(t);
9732      return this;
9733    }
9734
9735    /**
9736     * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist {3}
9737     */
9738    public Identifier getIdentifierFirstRep() { 
9739      if (getIdentifier().isEmpty()) {
9740        addIdentifier();
9741      }
9742      return getIdentifier().get(0);
9743    }
9744
9745    /**
9746     * @return {@link #version} (The identifier that is used to identify this version of the test script when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the test script 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
9747     */
9748    public StringType getVersionElement() { 
9749      if (this.version == null)
9750        if (Configuration.errorOnAutoCreate())
9751          throw new Error("Attempt to auto-create TestScript.version");
9752        else if (Configuration.doAutoCreate())
9753          this.version = new StringType(); // bb
9754      return this.version;
9755    }
9756
9757    public boolean hasVersionElement() { 
9758      return this.version != null && !this.version.isEmpty();
9759    }
9760
9761    public boolean hasVersion() { 
9762      return this.version != null && !this.version.isEmpty();
9763    }
9764
9765    /**
9766     * @param value {@link #version} (The identifier that is used to identify this version of the test script when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the test script 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
9767     */
9768    public TestScript setVersionElement(StringType value) { 
9769      this.version = value;
9770      return this;
9771    }
9772
9773    /**
9774     * @return The identifier that is used to identify this version of the test script when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the test script 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.
9775     */
9776    public String getVersion() { 
9777      return this.version == null ? null : this.version.getValue();
9778    }
9779
9780    /**
9781     * @param value The identifier that is used to identify this version of the test script when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the test script 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.
9782     */
9783    public TestScript setVersion(String value) { 
9784      if (Utilities.noString(value))
9785        this.version = null;
9786      else {
9787        if (this.version == null)
9788          this.version = new StringType();
9789        this.version.setValue(value);
9790      }
9791      return this;
9792    }
9793
9794    /**
9795     * @return {@link #versionAlgorithm} (Indicates the mechanism used to compare versions to determine which is more current.)
9796     */
9797    public DataType getVersionAlgorithm() { 
9798      return this.versionAlgorithm;
9799    }
9800
9801    /**
9802     * @return {@link #versionAlgorithm} (Indicates the mechanism used to compare versions to determine which is more current.)
9803     */
9804    public StringType getVersionAlgorithmStringType() throws FHIRException { 
9805      if (this.versionAlgorithm == null)
9806        this.versionAlgorithm = new StringType();
9807      if (!(this.versionAlgorithm instanceof StringType))
9808        throw new FHIRException("Type mismatch: the type StringType was expected, but "+this.versionAlgorithm.getClass().getName()+" was encountered");
9809      return (StringType) this.versionAlgorithm;
9810    }
9811
9812    public boolean hasVersionAlgorithmStringType() { 
9813      return this != null && this.versionAlgorithm instanceof StringType;
9814    }
9815
9816    /**
9817     * @return {@link #versionAlgorithm} (Indicates the mechanism used to compare versions to determine which is more current.)
9818     */
9819    public Coding getVersionAlgorithmCoding() throws FHIRException { 
9820      if (this.versionAlgorithm == null)
9821        this.versionAlgorithm = new Coding();
9822      if (!(this.versionAlgorithm instanceof Coding))
9823        throw new FHIRException("Type mismatch: the type Coding was expected, but "+this.versionAlgorithm.getClass().getName()+" was encountered");
9824      return (Coding) this.versionAlgorithm;
9825    }
9826
9827    public boolean hasVersionAlgorithmCoding() { 
9828      return this != null && this.versionAlgorithm instanceof Coding;
9829    }
9830
9831    public boolean hasVersionAlgorithm() { 
9832      return this.versionAlgorithm != null && !this.versionAlgorithm.isEmpty();
9833    }
9834
9835    /**
9836     * @param value {@link #versionAlgorithm} (Indicates the mechanism used to compare versions to determine which is more current.)
9837     */
9838    public TestScript setVersionAlgorithm(DataType value) { 
9839      if (value != null && !(value instanceof StringType || value instanceof Coding))
9840        throw new FHIRException("Not the right type for TestScript.versionAlgorithm[x]: "+value.fhirType());
9841      this.versionAlgorithm = value;
9842      return this;
9843    }
9844
9845    /**
9846     * @return {@link #name} (A natural language name identifying the test script. 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
9847     */
9848    public StringType getNameElement() { 
9849      if (this.name == null)
9850        if (Configuration.errorOnAutoCreate())
9851          throw new Error("Attempt to auto-create TestScript.name");
9852        else if (Configuration.doAutoCreate())
9853          this.name = new StringType(); // bb
9854      return this.name;
9855    }
9856
9857    public boolean hasNameElement() { 
9858      return this.name != null && !this.name.isEmpty();
9859    }
9860
9861    public boolean hasName() { 
9862      return this.name != null && !this.name.isEmpty();
9863    }
9864
9865    /**
9866     * @param value {@link #name} (A natural language name identifying the test script. 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
9867     */
9868    public TestScript setNameElement(StringType value) { 
9869      this.name = value;
9870      return this;
9871    }
9872
9873    /**
9874     * @return A natural language name identifying the test script. This name should be usable as an identifier for the module by machine processing applications such as code generation.
9875     */
9876    public String getName() { 
9877      return this.name == null ? null : this.name.getValue();
9878    }
9879
9880    /**
9881     * @param value A natural language name identifying the test script. This name should be usable as an identifier for the module by machine processing applications such as code generation.
9882     */
9883    public TestScript setName(String value) { 
9884        if (this.name == null)
9885          this.name = new StringType();
9886        this.name.setValue(value);
9887      return this;
9888    }
9889
9890    /**
9891     * @return {@link #title} (A short, descriptive, user-friendly title for the test script.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
9892     */
9893    public StringType getTitleElement() { 
9894      if (this.title == null)
9895        if (Configuration.errorOnAutoCreate())
9896          throw new Error("Attempt to auto-create TestScript.title");
9897        else if (Configuration.doAutoCreate())
9898          this.title = new StringType(); // bb
9899      return this.title;
9900    }
9901
9902    public boolean hasTitleElement() { 
9903      return this.title != null && !this.title.isEmpty();
9904    }
9905
9906    public boolean hasTitle() { 
9907      return this.title != null && !this.title.isEmpty();
9908    }
9909
9910    /**
9911     * @param value {@link #title} (A short, descriptive, user-friendly title for the test script.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
9912     */
9913    public TestScript setTitleElement(StringType value) { 
9914      this.title = value;
9915      return this;
9916    }
9917
9918    /**
9919     * @return A short, descriptive, user-friendly title for the test script.
9920     */
9921    public String getTitle() { 
9922      return this.title == null ? null : this.title.getValue();
9923    }
9924
9925    /**
9926     * @param value A short, descriptive, user-friendly title for the test script.
9927     */
9928    public TestScript setTitle(String value) { 
9929      if (Utilities.noString(value))
9930        this.title = null;
9931      else {
9932        if (this.title == null)
9933          this.title = new StringType();
9934        this.title.setValue(value);
9935      }
9936      return this;
9937    }
9938
9939    /**
9940     * @return {@link #status} (The status of this test script. 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
9941     */
9942    public Enumeration<PublicationStatus> getStatusElement() { 
9943      if (this.status == null)
9944        if (Configuration.errorOnAutoCreate())
9945          throw new Error("Attempt to auto-create TestScript.status");
9946        else if (Configuration.doAutoCreate())
9947          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb
9948      return this.status;
9949    }
9950
9951    public boolean hasStatusElement() { 
9952      return this.status != null && !this.status.isEmpty();
9953    }
9954
9955    public boolean hasStatus() { 
9956      return this.status != null && !this.status.isEmpty();
9957    }
9958
9959    /**
9960     * @param value {@link #status} (The status of this test script. 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
9961     */
9962    public TestScript setStatusElement(Enumeration<PublicationStatus> value) { 
9963      this.status = value;
9964      return this;
9965    }
9966
9967    /**
9968     * @return The status of this test script. Enables tracking the life-cycle of the content.
9969     */
9970    public PublicationStatus getStatus() { 
9971      return this.status == null ? null : this.status.getValue();
9972    }
9973
9974    /**
9975     * @param value The status of this test script. Enables tracking the life-cycle of the content.
9976     */
9977    public TestScript setStatus(PublicationStatus value) { 
9978        if (this.status == null)
9979          this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory());
9980        this.status.setValue(value);
9981      return this;
9982    }
9983
9984    /**
9985     * @return {@link #experimental} (A Boolean value to indicate that this test script 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
9986     */
9987    public BooleanType getExperimentalElement() { 
9988      if (this.experimental == null)
9989        if (Configuration.errorOnAutoCreate())
9990          throw new Error("Attempt to auto-create TestScript.experimental");
9991        else if (Configuration.doAutoCreate())
9992          this.experimental = new BooleanType(); // bb
9993      return this.experimental;
9994    }
9995
9996    public boolean hasExperimentalElement() { 
9997      return this.experimental != null && !this.experimental.isEmpty();
9998    }
9999
10000    public boolean hasExperimental() { 
10001      return this.experimental != null && !this.experimental.isEmpty();
10002    }
10003
10004    /**
10005     * @param value {@link #experimental} (A Boolean value to indicate that this test script 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
10006     */
10007    public TestScript setExperimentalElement(BooleanType value) { 
10008      this.experimental = value;
10009      return this;
10010    }
10011
10012    /**
10013     * @return A Boolean value to indicate that this test script is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.
10014     */
10015    public boolean getExperimental() { 
10016      return this.experimental == null || this.experimental.isEmpty() ? false : this.experimental.getValue();
10017    }
10018
10019    /**
10020     * @param value A Boolean value to indicate that this test script is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.
10021     */
10022    public TestScript setExperimental(boolean value) { 
10023        if (this.experimental == null)
10024          this.experimental = new BooleanType();
10025        this.experimental.setValue(value);
10026      return this;
10027    }
10028
10029    /**
10030     * @return {@link #date} (The date  (and optionally time) when the test script was last significantly changed. 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 test script changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
10031     */
10032    public DateTimeType getDateElement() { 
10033      if (this.date == null)
10034        if (Configuration.errorOnAutoCreate())
10035          throw new Error("Attempt to auto-create TestScript.date");
10036        else if (Configuration.doAutoCreate())
10037          this.date = new DateTimeType(); // bb
10038      return this.date;
10039    }
10040
10041    public boolean hasDateElement() { 
10042      return this.date != null && !this.date.isEmpty();
10043    }
10044
10045    public boolean hasDate() { 
10046      return this.date != null && !this.date.isEmpty();
10047    }
10048
10049    /**
10050     * @param value {@link #date} (The date  (and optionally time) when the test script was last significantly changed. 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 test script changes.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
10051     */
10052    public TestScript setDateElement(DateTimeType value) { 
10053      this.date = value;
10054      return this;
10055    }
10056
10057    /**
10058     * @return The date  (and optionally time) when the test script was last significantly changed. 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 test script changes.
10059     */
10060    public Date getDate() { 
10061      return this.date == null ? null : this.date.getValue();
10062    }
10063
10064    /**
10065     * @param value The date  (and optionally time) when the test script was last significantly changed. 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 test script changes.
10066     */
10067    public TestScript setDate(Date value) { 
10068      if (value == null)
10069        this.date = null;
10070      else {
10071        if (this.date == null)
10072          this.date = new DateTimeType();
10073        this.date.setValue(value);
10074      }
10075      return this;
10076    }
10077
10078    /**
10079     * @return {@link #publisher} (The name of the organization or individual responsible for the release and ongoing maintenance of the test script.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
10080     */
10081    public StringType getPublisherElement() { 
10082      if (this.publisher == null)
10083        if (Configuration.errorOnAutoCreate())
10084          throw new Error("Attempt to auto-create TestScript.publisher");
10085        else if (Configuration.doAutoCreate())
10086          this.publisher = new StringType(); // bb
10087      return this.publisher;
10088    }
10089
10090    public boolean hasPublisherElement() { 
10091      return this.publisher != null && !this.publisher.isEmpty();
10092    }
10093
10094    public boolean hasPublisher() { 
10095      return this.publisher != null && !this.publisher.isEmpty();
10096    }
10097
10098    /**
10099     * @param value {@link #publisher} (The name of the organization or individual responsible for the release and ongoing maintenance of the test script.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
10100     */
10101    public TestScript setPublisherElement(StringType value) { 
10102      this.publisher = value;
10103      return this;
10104    }
10105
10106    /**
10107     * @return The name of the organization or individual responsible for the release and ongoing maintenance of the test script.
10108     */
10109    public String getPublisher() { 
10110      return this.publisher == null ? null : this.publisher.getValue();
10111    }
10112
10113    /**
10114     * @param value The name of the organization or individual responsible for the release and ongoing maintenance of the test script.
10115     */
10116    public TestScript setPublisher(String value) { 
10117      if (Utilities.noString(value))
10118        this.publisher = null;
10119      else {
10120        if (this.publisher == null)
10121          this.publisher = new StringType();
10122        this.publisher.setValue(value);
10123      }
10124      return this;
10125    }
10126
10127    /**
10128     * @return {@link #contact} (Contact details to assist a user in finding and communicating with the publisher.)
10129     */
10130    public List<ContactDetail> getContact() { 
10131      if (this.contact == null)
10132        this.contact = new ArrayList<ContactDetail>();
10133      return this.contact;
10134    }
10135
10136    /**
10137     * @return Returns a reference to <code>this</code> for easy method chaining
10138     */
10139    public TestScript setContact(List<ContactDetail> theContact) { 
10140      this.contact = theContact;
10141      return this;
10142    }
10143
10144    public boolean hasContact() { 
10145      if (this.contact == null)
10146        return false;
10147      for (ContactDetail item : this.contact)
10148        if (!item.isEmpty())
10149          return true;
10150      return false;
10151    }
10152
10153    public ContactDetail addContact() { //3
10154      ContactDetail t = new ContactDetail();
10155      if (this.contact == null)
10156        this.contact = new ArrayList<ContactDetail>();
10157      this.contact.add(t);
10158      return t;
10159    }
10160
10161    public TestScript addContact(ContactDetail t) { //3
10162      if (t == null)
10163        return this;
10164      if (this.contact == null)
10165        this.contact = new ArrayList<ContactDetail>();
10166      this.contact.add(t);
10167      return this;
10168    }
10169
10170    /**
10171     * @return The first repetition of repeating field {@link #contact}, creating it if it does not already exist {3}
10172     */
10173    public ContactDetail getContactFirstRep() { 
10174      if (getContact().isEmpty()) {
10175        addContact();
10176      }
10177      return getContact().get(0);
10178    }
10179
10180    /**
10181     * @return {@link #description} (A free text natural language description of the test script from a consumer's perspective.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
10182     */
10183    public MarkdownType getDescriptionElement() { 
10184      if (this.description == null)
10185        if (Configuration.errorOnAutoCreate())
10186          throw new Error("Attempt to auto-create TestScript.description");
10187        else if (Configuration.doAutoCreate())
10188          this.description = new MarkdownType(); // bb
10189      return this.description;
10190    }
10191
10192    public boolean hasDescriptionElement() { 
10193      return this.description != null && !this.description.isEmpty();
10194    }
10195
10196    public boolean hasDescription() { 
10197      return this.description != null && !this.description.isEmpty();
10198    }
10199
10200    /**
10201     * @param value {@link #description} (A free text natural language description of the test script from a consumer's perspective.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
10202     */
10203    public TestScript setDescriptionElement(MarkdownType value) { 
10204      this.description = value;
10205      return this;
10206    }
10207
10208    /**
10209     * @return A free text natural language description of the test script from a consumer's perspective.
10210     */
10211    public String getDescription() { 
10212      return this.description == null ? null : this.description.getValue();
10213    }
10214
10215    /**
10216     * @param value A free text natural language description of the test script from a consumer's perspective.
10217     */
10218    public TestScript setDescription(String value) { 
10219      if (Utilities.noString(value))
10220        this.description = null;
10221      else {
10222        if (this.description == null)
10223          this.description = new MarkdownType();
10224        this.description.setValue(value);
10225      }
10226      return this;
10227    }
10228
10229    /**
10230     * @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 test script instances.)
10231     */
10232    public List<UsageContext> getUseContext() { 
10233      if (this.useContext == null)
10234        this.useContext = new ArrayList<UsageContext>();
10235      return this.useContext;
10236    }
10237
10238    /**
10239     * @return Returns a reference to <code>this</code> for easy method chaining
10240     */
10241    public TestScript setUseContext(List<UsageContext> theUseContext) { 
10242      this.useContext = theUseContext;
10243      return this;
10244    }
10245
10246    public boolean hasUseContext() { 
10247      if (this.useContext == null)
10248        return false;
10249      for (UsageContext item : this.useContext)
10250        if (!item.isEmpty())
10251          return true;
10252      return false;
10253    }
10254
10255    public UsageContext addUseContext() { //3
10256      UsageContext t = new UsageContext();
10257      if (this.useContext == null)
10258        this.useContext = new ArrayList<UsageContext>();
10259      this.useContext.add(t);
10260      return t;
10261    }
10262
10263    public TestScript addUseContext(UsageContext t) { //3
10264      if (t == null)
10265        return this;
10266      if (this.useContext == null)
10267        this.useContext = new ArrayList<UsageContext>();
10268      this.useContext.add(t);
10269      return this;
10270    }
10271
10272    /**
10273     * @return The first repetition of repeating field {@link #useContext}, creating it if it does not already exist {3}
10274     */
10275    public UsageContext getUseContextFirstRep() { 
10276      if (getUseContext().isEmpty()) {
10277        addUseContext();
10278      }
10279      return getUseContext().get(0);
10280    }
10281
10282    /**
10283     * @return {@link #jurisdiction} (A legal or geographic region in which the test script is intended to be used.)
10284     */
10285    public List<CodeableConcept> getJurisdiction() { 
10286      if (this.jurisdiction == null)
10287        this.jurisdiction = new ArrayList<CodeableConcept>();
10288      return this.jurisdiction;
10289    }
10290
10291    /**
10292     * @return Returns a reference to <code>this</code> for easy method chaining
10293     */
10294    public TestScript setJurisdiction(List<CodeableConcept> theJurisdiction) { 
10295      this.jurisdiction = theJurisdiction;
10296      return this;
10297    }
10298
10299    public boolean hasJurisdiction() { 
10300      if (this.jurisdiction == null)
10301        return false;
10302      for (CodeableConcept item : this.jurisdiction)
10303        if (!item.isEmpty())
10304          return true;
10305      return false;
10306    }
10307
10308    public CodeableConcept addJurisdiction() { //3
10309      CodeableConcept t = new CodeableConcept();
10310      if (this.jurisdiction == null)
10311        this.jurisdiction = new ArrayList<CodeableConcept>();
10312      this.jurisdiction.add(t);
10313      return t;
10314    }
10315
10316    public TestScript addJurisdiction(CodeableConcept t) { //3
10317      if (t == null)
10318        return this;
10319      if (this.jurisdiction == null)
10320        this.jurisdiction = new ArrayList<CodeableConcept>();
10321      this.jurisdiction.add(t);
10322      return this;
10323    }
10324
10325    /**
10326     * @return The first repetition of repeating field {@link #jurisdiction}, creating it if it does not already exist {3}
10327     */
10328    public CodeableConcept getJurisdictionFirstRep() { 
10329      if (getJurisdiction().isEmpty()) {
10330        addJurisdiction();
10331      }
10332      return getJurisdiction().get(0);
10333    }
10334
10335    /**
10336     * @return {@link #purpose} (Explanation of why this test script 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
10337     */
10338    public MarkdownType getPurposeElement() { 
10339      if (this.purpose == null)
10340        if (Configuration.errorOnAutoCreate())
10341          throw new Error("Attempt to auto-create TestScript.purpose");
10342        else if (Configuration.doAutoCreate())
10343          this.purpose = new MarkdownType(); // bb
10344      return this.purpose;
10345    }
10346
10347    public boolean hasPurposeElement() { 
10348      return this.purpose != null && !this.purpose.isEmpty();
10349    }
10350
10351    public boolean hasPurpose() { 
10352      return this.purpose != null && !this.purpose.isEmpty();
10353    }
10354
10355    /**
10356     * @param value {@link #purpose} (Explanation of why this test script 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
10357     */
10358    public TestScript setPurposeElement(MarkdownType value) { 
10359      this.purpose = value;
10360      return this;
10361    }
10362
10363    /**
10364     * @return Explanation of why this test script is needed and why it has been designed as it has.
10365     */
10366    public String getPurpose() { 
10367      return this.purpose == null ? null : this.purpose.getValue();
10368    }
10369
10370    /**
10371     * @param value Explanation of why this test script is needed and why it has been designed as it has.
10372     */
10373    public TestScript setPurpose(String value) { 
10374      if (Utilities.noString(value))
10375        this.purpose = null;
10376      else {
10377        if (this.purpose == null)
10378          this.purpose = new MarkdownType();
10379        this.purpose.setValue(value);
10380      }
10381      return this;
10382    }
10383
10384    /**
10385     * @return {@link #copyright} (A copyright statement relating to the test script and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the test script.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value
10386     */
10387    public MarkdownType getCopyrightElement() { 
10388      if (this.copyright == null)
10389        if (Configuration.errorOnAutoCreate())
10390          throw new Error("Attempt to auto-create TestScript.copyright");
10391        else if (Configuration.doAutoCreate())
10392          this.copyright = new MarkdownType(); // bb
10393      return this.copyright;
10394    }
10395
10396    public boolean hasCopyrightElement() { 
10397      return this.copyright != null && !this.copyright.isEmpty();
10398    }
10399
10400    public boolean hasCopyright() { 
10401      return this.copyright != null && !this.copyright.isEmpty();
10402    }
10403
10404    /**
10405     * @param value {@link #copyright} (A copyright statement relating to the test script and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the test script.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value
10406     */
10407    public TestScript setCopyrightElement(MarkdownType value) { 
10408      this.copyright = value;
10409      return this;
10410    }
10411
10412    /**
10413     * @return A copyright statement relating to the test script and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the test script.
10414     */
10415    public String getCopyright() { 
10416      return this.copyright == null ? null : this.copyright.getValue();
10417    }
10418
10419    /**
10420     * @param value A copyright statement relating to the test script and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the test script.
10421     */
10422    public TestScript setCopyright(String value) { 
10423      if (Utilities.noString(value))
10424        this.copyright = null;
10425      else {
10426        if (this.copyright == null)
10427          this.copyright = new MarkdownType();
10428        this.copyright.setValue(value);
10429      }
10430      return this;
10431    }
10432
10433    /**
10434     * @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
10435     */
10436    public StringType getCopyrightLabelElement() { 
10437      if (this.copyrightLabel == null)
10438        if (Configuration.errorOnAutoCreate())
10439          throw new Error("Attempt to auto-create TestScript.copyrightLabel");
10440        else if (Configuration.doAutoCreate())
10441          this.copyrightLabel = new StringType(); // bb
10442      return this.copyrightLabel;
10443    }
10444
10445    public boolean hasCopyrightLabelElement() { 
10446      return this.copyrightLabel != null && !this.copyrightLabel.isEmpty();
10447    }
10448
10449    public boolean hasCopyrightLabel() { 
10450      return this.copyrightLabel != null && !this.copyrightLabel.isEmpty();
10451    }
10452
10453    /**
10454     * @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
10455     */
10456    public TestScript setCopyrightLabelElement(StringType value) { 
10457      this.copyrightLabel = value;
10458      return this;
10459    }
10460
10461    /**
10462     * @return 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').
10463     */
10464    public String getCopyrightLabel() { 
10465      return this.copyrightLabel == null ? null : this.copyrightLabel.getValue();
10466    }
10467
10468    /**
10469     * @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').
10470     */
10471    public TestScript setCopyrightLabel(String value) { 
10472      if (Utilities.noString(value))
10473        this.copyrightLabel = null;
10474      else {
10475        if (this.copyrightLabel == null)
10476          this.copyrightLabel = new StringType();
10477        this.copyrightLabel.setValue(value);
10478      }
10479      return this;
10480    }
10481
10482    /**
10483     * @return {@link #origin} (An abstract server used in operations within this test script in the origin element.)
10484     */
10485    public List<TestScriptOriginComponent> getOrigin() { 
10486      if (this.origin == null)
10487        this.origin = new ArrayList<TestScriptOriginComponent>();
10488      return this.origin;
10489    }
10490
10491    /**
10492     * @return Returns a reference to <code>this</code> for easy method chaining
10493     */
10494    public TestScript setOrigin(List<TestScriptOriginComponent> theOrigin) { 
10495      this.origin = theOrigin;
10496      return this;
10497    }
10498
10499    public boolean hasOrigin() { 
10500      if (this.origin == null)
10501        return false;
10502      for (TestScriptOriginComponent item : this.origin)
10503        if (!item.isEmpty())
10504          return true;
10505      return false;
10506    }
10507
10508    public TestScriptOriginComponent addOrigin() { //3
10509      TestScriptOriginComponent t = new TestScriptOriginComponent();
10510      if (this.origin == null)
10511        this.origin = new ArrayList<TestScriptOriginComponent>();
10512      this.origin.add(t);
10513      return t;
10514    }
10515
10516    public TestScript addOrigin(TestScriptOriginComponent t) { //3
10517      if (t == null)
10518        return this;
10519      if (this.origin == null)
10520        this.origin = new ArrayList<TestScriptOriginComponent>();
10521      this.origin.add(t);
10522      return this;
10523    }
10524
10525    /**
10526     * @return The first repetition of repeating field {@link #origin}, creating it if it does not already exist {3}
10527     */
10528    public TestScriptOriginComponent getOriginFirstRep() { 
10529      if (getOrigin().isEmpty()) {
10530        addOrigin();
10531      }
10532      return getOrigin().get(0);
10533    }
10534
10535    /**
10536     * @return {@link #destination} (An abstract server used in operations within this test script in the destination element.)
10537     */
10538    public List<TestScriptDestinationComponent> getDestination() { 
10539      if (this.destination == null)
10540        this.destination = new ArrayList<TestScriptDestinationComponent>();
10541      return this.destination;
10542    }
10543
10544    /**
10545     * @return Returns a reference to <code>this</code> for easy method chaining
10546     */
10547    public TestScript setDestination(List<TestScriptDestinationComponent> theDestination) { 
10548      this.destination = theDestination;
10549      return this;
10550    }
10551
10552    public boolean hasDestination() { 
10553      if (this.destination == null)
10554        return false;
10555      for (TestScriptDestinationComponent item : this.destination)
10556        if (!item.isEmpty())
10557          return true;
10558      return false;
10559    }
10560
10561    public TestScriptDestinationComponent addDestination() { //3
10562      TestScriptDestinationComponent t = new TestScriptDestinationComponent();
10563      if (this.destination == null)
10564        this.destination = new ArrayList<TestScriptDestinationComponent>();
10565      this.destination.add(t);
10566      return t;
10567    }
10568
10569    public TestScript addDestination(TestScriptDestinationComponent t) { //3
10570      if (t == null)
10571        return this;
10572      if (this.destination == null)
10573        this.destination = new ArrayList<TestScriptDestinationComponent>();
10574      this.destination.add(t);
10575      return this;
10576    }
10577
10578    /**
10579     * @return The first repetition of repeating field {@link #destination}, creating it if it does not already exist {3}
10580     */
10581    public TestScriptDestinationComponent getDestinationFirstRep() { 
10582      if (getDestination().isEmpty()) {
10583        addDestination();
10584      }
10585      return getDestination().get(0);
10586    }
10587
10588    /**
10589     * @return {@link #metadata} (The required capability must exist and are assumed to function correctly on the FHIR server being tested.)
10590     */
10591    public TestScriptMetadataComponent getMetadata() { 
10592      if (this.metadata == null)
10593        if (Configuration.errorOnAutoCreate())
10594          throw new Error("Attempt to auto-create TestScript.metadata");
10595        else if (Configuration.doAutoCreate())
10596          this.metadata = new TestScriptMetadataComponent(); // cc
10597      return this.metadata;
10598    }
10599
10600    public boolean hasMetadata() { 
10601      return this.metadata != null && !this.metadata.isEmpty();
10602    }
10603
10604    /**
10605     * @param value {@link #metadata} (The required capability must exist and are assumed to function correctly on the FHIR server being tested.)
10606     */
10607    public TestScript setMetadata(TestScriptMetadataComponent value) { 
10608      this.metadata = value;
10609      return this;
10610    }
10611
10612    /**
10613     * @return {@link #scope} (The scope indicates a conformance artifact that is tested by the test(s) within this test case and the expectation of the test outcome(s) as well as the intended test phase inclusion.)
10614     */
10615    public List<TestScriptScopeComponent> getScope() { 
10616      if (this.scope == null)
10617        this.scope = new ArrayList<TestScriptScopeComponent>();
10618      return this.scope;
10619    }
10620
10621    /**
10622     * @return Returns a reference to <code>this</code> for easy method chaining
10623     */
10624    public TestScript setScope(List<TestScriptScopeComponent> theScope) { 
10625      this.scope = theScope;
10626      return this;
10627    }
10628
10629    public boolean hasScope() { 
10630      if (this.scope == null)
10631        return false;
10632      for (TestScriptScopeComponent item : this.scope)
10633        if (!item.isEmpty())
10634          return true;
10635      return false;
10636    }
10637
10638    public TestScriptScopeComponent addScope() { //3
10639      TestScriptScopeComponent t = new TestScriptScopeComponent();
10640      if (this.scope == null)
10641        this.scope = new ArrayList<TestScriptScopeComponent>();
10642      this.scope.add(t);
10643      return t;
10644    }
10645
10646    public TestScript addScope(TestScriptScopeComponent t) { //3
10647      if (t == null)
10648        return this;
10649      if (this.scope == null)
10650        this.scope = new ArrayList<TestScriptScopeComponent>();
10651      this.scope.add(t);
10652      return this;
10653    }
10654
10655    /**
10656     * @return The first repetition of repeating field {@link #scope}, creating it if it does not already exist {3}
10657     */
10658    public TestScriptScopeComponent getScopeFirstRep() { 
10659      if (getScope().isEmpty()) {
10660        addScope();
10661      }
10662      return getScope().get(0);
10663    }
10664
10665    /**
10666     * @return {@link #fixture} (Fixture in the test script - by reference (uri). All fixtures are required for the test script to execute.)
10667     */
10668    public List<TestScriptFixtureComponent> getFixture() { 
10669      if (this.fixture == null)
10670        this.fixture = new ArrayList<TestScriptFixtureComponent>();
10671      return this.fixture;
10672    }
10673
10674    /**
10675     * @return Returns a reference to <code>this</code> for easy method chaining
10676     */
10677    public TestScript setFixture(List<TestScriptFixtureComponent> theFixture) { 
10678      this.fixture = theFixture;
10679      return this;
10680    }
10681
10682    public boolean hasFixture() { 
10683      if (this.fixture == null)
10684        return false;
10685      for (TestScriptFixtureComponent item : this.fixture)
10686        if (!item.isEmpty())
10687          return true;
10688      return false;
10689    }
10690
10691    public TestScriptFixtureComponent addFixture() { //3
10692      TestScriptFixtureComponent t = new TestScriptFixtureComponent();
10693      if (this.fixture == null)
10694        this.fixture = new ArrayList<TestScriptFixtureComponent>();
10695      this.fixture.add(t);
10696      return t;
10697    }
10698
10699    public TestScript addFixture(TestScriptFixtureComponent t) { //3
10700      if (t == null)
10701        return this;
10702      if (this.fixture == null)
10703        this.fixture = new ArrayList<TestScriptFixtureComponent>();
10704      this.fixture.add(t);
10705      return this;
10706    }
10707
10708    /**
10709     * @return The first repetition of repeating field {@link #fixture}, creating it if it does not already exist {3}
10710     */
10711    public TestScriptFixtureComponent getFixtureFirstRep() { 
10712      if (getFixture().isEmpty()) {
10713        addFixture();
10714      }
10715      return getFixture().get(0);
10716    }
10717
10718    /**
10719     * @return {@link #profile} (Reference to the profile to be used for validation.)
10720     */
10721    public List<CanonicalType> getProfile() { 
10722      if (this.profile == null)
10723        this.profile = new ArrayList<CanonicalType>();
10724      return this.profile;
10725    }
10726
10727    /**
10728     * @return Returns a reference to <code>this</code> for easy method chaining
10729     */
10730    public TestScript setProfile(List<CanonicalType> theProfile) { 
10731      this.profile = theProfile;
10732      return this;
10733    }
10734
10735    public boolean hasProfile() { 
10736      if (this.profile == null)
10737        return false;
10738      for (CanonicalType item : this.profile)
10739        if (!item.isEmpty())
10740          return true;
10741      return false;
10742    }
10743
10744    /**
10745     * @return {@link #profile} (Reference to the profile to be used for validation.)
10746     */
10747    public CanonicalType addProfileElement() {//2 
10748      CanonicalType t = new CanonicalType();
10749      if (this.profile == null)
10750        this.profile = new ArrayList<CanonicalType>();
10751      this.profile.add(t);
10752      return t;
10753    }
10754
10755    /**
10756     * @param value {@link #profile} (Reference to the profile to be used for validation.)
10757     */
10758    public TestScript addProfile(String value) { //1
10759      CanonicalType t = new CanonicalType();
10760      t.setValue(value);
10761      if (this.profile == null)
10762        this.profile = new ArrayList<CanonicalType>();
10763      this.profile.add(t);
10764      return this;
10765    }
10766
10767    /**
10768     * @param value {@link #profile} (Reference to the profile to be used for validation.)
10769     */
10770    public boolean hasProfile(String value) { 
10771      if (this.profile == null)
10772        return false;
10773      for (CanonicalType v : this.profile)
10774        if (v.getValue().equals(value)) // canonical
10775          return true;
10776      return false;
10777    }
10778
10779    /**
10780     * @return {@link #variable} (Variable is set based either on element value in response body or on header field value in the response headers.)
10781     */
10782    public List<TestScriptVariableComponent> getVariable() { 
10783      if (this.variable == null)
10784        this.variable = new ArrayList<TestScriptVariableComponent>();
10785      return this.variable;
10786    }
10787
10788    /**
10789     * @return Returns a reference to <code>this</code> for easy method chaining
10790     */
10791    public TestScript setVariable(List<TestScriptVariableComponent> theVariable) { 
10792      this.variable = theVariable;
10793      return this;
10794    }
10795
10796    public boolean hasVariable() { 
10797      if (this.variable == null)
10798        return false;
10799      for (TestScriptVariableComponent item : this.variable)
10800        if (!item.isEmpty())
10801          return true;
10802      return false;
10803    }
10804
10805    public TestScriptVariableComponent addVariable() { //3
10806      TestScriptVariableComponent t = new TestScriptVariableComponent();
10807      if (this.variable == null)
10808        this.variable = new ArrayList<TestScriptVariableComponent>();
10809      this.variable.add(t);
10810      return t;
10811    }
10812
10813    public TestScript addVariable(TestScriptVariableComponent t) { //3
10814      if (t == null)
10815        return this;
10816      if (this.variable == null)
10817        this.variable = new ArrayList<TestScriptVariableComponent>();
10818      this.variable.add(t);
10819      return this;
10820    }
10821
10822    /**
10823     * @return The first repetition of repeating field {@link #variable}, creating it if it does not already exist {3}
10824     */
10825    public TestScriptVariableComponent getVariableFirstRep() { 
10826      if (getVariable().isEmpty()) {
10827        addVariable();
10828      }
10829      return getVariable().get(0);
10830    }
10831
10832    /**
10833     * @return {@link #setup} (A series of required setup operations before tests are executed.)
10834     */
10835    public TestScriptSetupComponent getSetup() { 
10836      if (this.setup == null)
10837        if (Configuration.errorOnAutoCreate())
10838          throw new Error("Attempt to auto-create TestScript.setup");
10839        else if (Configuration.doAutoCreate())
10840          this.setup = new TestScriptSetupComponent(); // cc
10841      return this.setup;
10842    }
10843
10844    public boolean hasSetup() { 
10845      return this.setup != null && !this.setup.isEmpty();
10846    }
10847
10848    /**
10849     * @param value {@link #setup} (A series of required setup operations before tests are executed.)
10850     */
10851    public TestScript setSetup(TestScriptSetupComponent value) { 
10852      this.setup = value;
10853      return this;
10854    }
10855
10856    /**
10857     * @return {@link #test} (A test in this script.)
10858     */
10859    public List<TestScriptTestComponent> getTest() { 
10860      if (this.test == null)
10861        this.test = new ArrayList<TestScriptTestComponent>();
10862      return this.test;
10863    }
10864
10865    /**
10866     * @return Returns a reference to <code>this</code> for easy method chaining
10867     */
10868    public TestScript setTest(List<TestScriptTestComponent> theTest) { 
10869      this.test = theTest;
10870      return this;
10871    }
10872
10873    public boolean hasTest() { 
10874      if (this.test == null)
10875        return false;
10876      for (TestScriptTestComponent item : this.test)
10877        if (!item.isEmpty())
10878          return true;
10879      return false;
10880    }
10881
10882    public TestScriptTestComponent addTest() { //3
10883      TestScriptTestComponent t = new TestScriptTestComponent();
10884      if (this.test == null)
10885        this.test = new ArrayList<TestScriptTestComponent>();
10886      this.test.add(t);
10887      return t;
10888    }
10889
10890    public TestScript addTest(TestScriptTestComponent t) { //3
10891      if (t == null)
10892        return this;
10893      if (this.test == null)
10894        this.test = new ArrayList<TestScriptTestComponent>();
10895      this.test.add(t);
10896      return this;
10897    }
10898
10899    /**
10900     * @return The first repetition of repeating field {@link #test}, creating it if it does not already exist {3}
10901     */
10902    public TestScriptTestComponent getTestFirstRep() { 
10903      if (getTest().isEmpty()) {
10904        addTest();
10905      }
10906      return getTest().get(0);
10907    }
10908
10909    /**
10910     * @return {@link #teardown} (A series of operations required to clean up after all the tests are executed (successfully or otherwise).)
10911     */
10912    public TestScriptTeardownComponent getTeardown() { 
10913      if (this.teardown == null)
10914        if (Configuration.errorOnAutoCreate())
10915          throw new Error("Attempt to auto-create TestScript.teardown");
10916        else if (Configuration.doAutoCreate())
10917          this.teardown = new TestScriptTeardownComponent(); // cc
10918      return this.teardown;
10919    }
10920
10921    public boolean hasTeardown() { 
10922      return this.teardown != null && !this.teardown.isEmpty();
10923    }
10924
10925    /**
10926     * @param value {@link #teardown} (A series of operations required to clean up after all the tests are executed (successfully or otherwise).)
10927     */
10928    public TestScript setTeardown(TestScriptTeardownComponent value) { 
10929      this.teardown = value;
10930      return this;
10931    }
10932
10933      protected void listChildren(List<Property> children) {
10934        super.listChildren(children);
10935        children.add(new Property("url", "uri", "An absolute URI that is used to identify this test script 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 test script is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the test script is stored on different servers.", 0, 1, url));
10936        children.add(new Property("identifier", "Identifier", "A formal identifier that is used to identify this test script when it is represented in other formats, or referenced in a specification, model, design or an instance.", 0, java.lang.Integer.MAX_VALUE, identifier));
10937        children.add(new Property("version", "string", "The identifier that is used to identify this version of the test script when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the test script 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));
10938        children.add(new Property("versionAlgorithm[x]", "string|Coding", "Indicates the mechanism used to compare versions to determine which is more current.", 0, 1, versionAlgorithm));
10939        children.add(new Property("name", "string", "A natural language name identifying the test script. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name));
10940        children.add(new Property("title", "string", "A short, descriptive, user-friendly title for the test script.", 0, 1, title));
10941        children.add(new Property("status", "code", "The status of this test script. Enables tracking the life-cycle of the content.", 0, 1, status));
10942        children.add(new Property("experimental", "boolean", "A Boolean value to indicate that this test script is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.", 0, 1, experimental));
10943        children.add(new Property("date", "dateTime", "The date  (and optionally time) when the test script was last significantly changed. 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 test script changes.", 0, 1, date));
10944        children.add(new Property("publisher", "string", "The name of the organization or individual responsible for the release and ongoing maintenance of the test script.", 0, 1, publisher));
10945        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));
10946        children.add(new Property("description", "markdown", "A free text natural language description of the test script from a consumer's perspective.", 0, 1, description));
10947        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 test script instances.", 0, java.lang.Integer.MAX_VALUE, useContext));
10948        children.add(new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the test script is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction));
10949        children.add(new Property("purpose", "markdown", "Explanation of why this test script is needed and why it has been designed as it has.", 0, 1, purpose));
10950        children.add(new Property("copyright", "markdown", "A copyright statement relating to the test script and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the test script.", 0, 1, copyright));
10951        children.add(new Property("copyrightLabel", "string", "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').", 0, 1, copyrightLabel));
10952        children.add(new Property("origin", "", "An abstract server used in operations within this test script in the origin element.", 0, java.lang.Integer.MAX_VALUE, origin));
10953        children.add(new Property("destination", "", "An abstract server used in operations within this test script in the destination element.", 0, java.lang.Integer.MAX_VALUE, destination));
10954        children.add(new Property("metadata", "", "The required capability must exist and are assumed to function correctly on the FHIR server being tested.", 0, 1, metadata));
10955        children.add(new Property("scope", "", "The scope indicates a conformance artifact that is tested by the test(s) within this test case and the expectation of the test outcome(s) as well as the intended test phase inclusion.", 0, java.lang.Integer.MAX_VALUE, scope));
10956        children.add(new Property("fixture", "", "Fixture in the test script - by reference (uri). All fixtures are required for the test script to execute.", 0, java.lang.Integer.MAX_VALUE, fixture));
10957        children.add(new Property("profile", "canonical(StructureDefinition)", "Reference to the profile to be used for validation.", 0, java.lang.Integer.MAX_VALUE, profile));
10958        children.add(new Property("variable", "", "Variable is set based either on element value in response body or on header field value in the response headers.", 0, java.lang.Integer.MAX_VALUE, variable));
10959        children.add(new Property("setup", "", "A series of required setup operations before tests are executed.", 0, 1, setup));
10960        children.add(new Property("test", "", "A test in this script.", 0, java.lang.Integer.MAX_VALUE, test));
10961        children.add(new Property("teardown", "", "A series of operations required to clean up after all the tests are executed (successfully or otherwise).", 0, 1, teardown));
10962      }
10963
10964      @Override
10965      public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
10966        switch (_hash) {
10967        case 116079: /*url*/  return new Property("url", "uri", "An absolute URI that is used to identify this test script 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 test script is (or will be) published. This URL can be the target of a canonical reference. It SHALL remain the same when the test script is stored on different servers.", 0, 1, url);
10968        case -1618432855: /*identifier*/  return new Property("identifier", "Identifier", "A formal identifier that is used to identify this test script when it is represented in other formats, or referenced in a specification, model, design or an instance.", 0, java.lang.Integer.MAX_VALUE, identifier);
10969        case 351608024: /*version*/  return new Property("version", "string", "The identifier that is used to identify this version of the test script when it is referenced in a specification, model, design or instance. This is an arbitrary value managed by the test script 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);
10970        case -115699031: /*versionAlgorithm[x]*/  return new Property("versionAlgorithm[x]", "string|Coding", "Indicates the mechanism used to compare versions to determine which is more current.", 0, 1, versionAlgorithm);
10971        case 1508158071: /*versionAlgorithm*/  return new Property("versionAlgorithm[x]", "string|Coding", "Indicates the mechanism used to compare versions to determine which is more current.", 0, 1, versionAlgorithm);
10972        case 1836908904: /*versionAlgorithmString*/  return new Property("versionAlgorithm[x]", "string", "Indicates the mechanism used to compare versions to determine which is more current.", 0, 1, versionAlgorithm);
10973        case 1373807809: /*versionAlgorithmCoding*/  return new Property("versionAlgorithm[x]", "Coding", "Indicates the mechanism used to compare versions to determine which is more current.", 0, 1, versionAlgorithm);
10974        case 3373707: /*name*/  return new Property("name", "string", "A natural language name identifying the test script. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, 1, name);
10975        case 110371416: /*title*/  return new Property("title", "string", "A short, descriptive, user-friendly title for the test script.", 0, 1, title);
10976        case -892481550: /*status*/  return new Property("status", "code", "The status of this test script. Enables tracking the life-cycle of the content.", 0, 1, status);
10977        case -404562712: /*experimental*/  return new Property("experimental", "boolean", "A Boolean value to indicate that this test script is authored for testing purposes (or education/evaluation/marketing) and is not intended to be used for genuine usage.", 0, 1, experimental);
10978        case 3076014: /*date*/  return new Property("date", "dateTime", "The date  (and optionally time) when the test script was last significantly changed. 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 test script changes.", 0, 1, date);
10979        case 1447404028: /*publisher*/  return new Property("publisher", "string", "The name of the organization or individual responsible for the release and ongoing maintenance of the test script.", 0, 1, publisher);
10980        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);
10981        case -1724546052: /*description*/  return new Property("description", "markdown", "A free text natural language description of the test script from a consumer's perspective.", 0, 1, description);
10982        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 test script instances.", 0, java.lang.Integer.MAX_VALUE, useContext);
10983        case -507075711: /*jurisdiction*/  return new Property("jurisdiction", "CodeableConcept", "A legal or geographic region in which the test script is intended to be used.", 0, java.lang.Integer.MAX_VALUE, jurisdiction);
10984        case -220463842: /*purpose*/  return new Property("purpose", "markdown", "Explanation of why this test script is needed and why it has been designed as it has.", 0, 1, purpose);
10985        case 1522889671: /*copyright*/  return new Property("copyright", "markdown", "A copyright statement relating to the test script and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the test script.", 0, 1, copyright);
10986        case 765157229: /*copyrightLabel*/  return new Property("copyrightLabel", "string", "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').", 0, 1, copyrightLabel);
10987        case -1008619738: /*origin*/  return new Property("origin", "", "An abstract server used in operations within this test script in the origin element.", 0, java.lang.Integer.MAX_VALUE, origin);
10988        case -1429847026: /*destination*/  return new Property("destination", "", "An abstract server used in operations within this test script in the destination element.", 0, java.lang.Integer.MAX_VALUE, destination);
10989        case -450004177: /*metadata*/  return new Property("metadata", "", "The required capability must exist and are assumed to function correctly on the FHIR server being tested.", 0, 1, metadata);
10990        case 109264468: /*scope*/  return new Property("scope", "", "The scope indicates a conformance artifact that is tested by the test(s) within this test case and the expectation of the test outcome(s) as well as the intended test phase inclusion.", 0, java.lang.Integer.MAX_VALUE, scope);
10991        case -843449847: /*fixture*/  return new Property("fixture", "", "Fixture in the test script - by reference (uri). All fixtures are required for the test script to execute.", 0, java.lang.Integer.MAX_VALUE, fixture);
10992        case -309425751: /*profile*/  return new Property("profile", "canonical(StructureDefinition)", "Reference to the profile to be used for validation.", 0, java.lang.Integer.MAX_VALUE, profile);
10993        case -1249586564: /*variable*/  return new Property("variable", "", "Variable is set based either on element value in response body or on header field value in the response headers.", 0, java.lang.Integer.MAX_VALUE, variable);
10994        case 109329021: /*setup*/  return new Property("setup", "", "A series of required setup operations before tests are executed.", 0, 1, setup);
10995        case 3556498: /*test*/  return new Property("test", "", "A test in this script.", 0, java.lang.Integer.MAX_VALUE, test);
10996        case -1663474172: /*teardown*/  return new Property("teardown", "", "A series of operations required to clean up after all the tests are executed (successfully or otherwise).", 0, 1, teardown);
10997        default: return super.getNamedProperty(_hash, _name, _checkValid);
10998        }
10999
11000      }
11001
11002      @Override
11003      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
11004        switch (hash) {
11005        case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType
11006        case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier
11007        case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType
11008        case 1508158071: /*versionAlgorithm*/ return this.versionAlgorithm == null ? new Base[0] : new Base[] {this.versionAlgorithm}; // DataType
11009        case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
11010        case 110371416: /*title*/ return this.title == null ? new Base[0] : new Base[] {this.title}; // StringType
11011        case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<PublicationStatus>
11012        case -404562712: /*experimental*/ return this.experimental == null ? new Base[0] : new Base[] {this.experimental}; // BooleanType
11013        case 3076014: /*date*/ return this.date == null ? new Base[0] : new Base[] {this.date}; // DateTimeType
11014        case 1447404028: /*publisher*/ return this.publisher == null ? new Base[0] : new Base[] {this.publisher}; // StringType
11015        case 951526432: /*contact*/ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail
11016        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // MarkdownType
11017        case -669707736: /*useContext*/ return this.useContext == null ? new Base[0] : this.useContext.toArray(new Base[this.useContext.size()]); // UsageContext
11018        case -507075711: /*jurisdiction*/ return this.jurisdiction == null ? new Base[0] : this.jurisdiction.toArray(new Base[this.jurisdiction.size()]); // CodeableConcept
11019        case -220463842: /*purpose*/ return this.purpose == null ? new Base[0] : new Base[] {this.purpose}; // MarkdownType
11020        case 1522889671: /*copyright*/ return this.copyright == null ? new Base[0] : new Base[] {this.copyright}; // MarkdownType
11021        case 765157229: /*copyrightLabel*/ return this.copyrightLabel == null ? new Base[0] : new Base[] {this.copyrightLabel}; // StringType
11022        case -1008619738: /*origin*/ return this.origin == null ? new Base[0] : this.origin.toArray(new Base[this.origin.size()]); // TestScriptOriginComponent
11023        case -1429847026: /*destination*/ return this.destination == null ? new Base[0] : this.destination.toArray(new Base[this.destination.size()]); // TestScriptDestinationComponent
11024        case -450004177: /*metadata*/ return this.metadata == null ? new Base[0] : new Base[] {this.metadata}; // TestScriptMetadataComponent
11025        case 109264468: /*scope*/ return this.scope == null ? new Base[0] : this.scope.toArray(new Base[this.scope.size()]); // TestScriptScopeComponent
11026        case -843449847: /*fixture*/ return this.fixture == null ? new Base[0] : this.fixture.toArray(new Base[this.fixture.size()]); // TestScriptFixtureComponent
11027        case -309425751: /*profile*/ return this.profile == null ? new Base[0] : this.profile.toArray(new Base[this.profile.size()]); // CanonicalType
11028        case -1249586564: /*variable*/ return this.variable == null ? new Base[0] : this.variable.toArray(new Base[this.variable.size()]); // TestScriptVariableComponent
11029        case 109329021: /*setup*/ return this.setup == null ? new Base[0] : new Base[] {this.setup}; // TestScriptSetupComponent
11030        case 3556498: /*test*/ return this.test == null ? new Base[0] : this.test.toArray(new Base[this.test.size()]); // TestScriptTestComponent
11031        case -1663474172: /*teardown*/ return this.teardown == null ? new Base[0] : new Base[] {this.teardown}; // TestScriptTeardownComponent
11032        default: return super.getProperty(hash, name, checkValid);
11033        }
11034
11035      }
11036
11037      @Override
11038      public Base setProperty(int hash, String name, Base value) throws FHIRException {
11039        switch (hash) {
11040        case 116079: // url
11041          this.url = TypeConvertor.castToUri(value); // UriType
11042          return value;
11043        case -1618432855: // identifier
11044          this.getIdentifier().add(TypeConvertor.castToIdentifier(value)); // Identifier
11045          return value;
11046        case 351608024: // version
11047          this.version = TypeConvertor.castToString(value); // StringType
11048          return value;
11049        case 1508158071: // versionAlgorithm
11050          this.versionAlgorithm = TypeConvertor.castToType(value); // DataType
11051          return value;
11052        case 3373707: // name
11053          this.name = TypeConvertor.castToString(value); // StringType
11054          return value;
11055        case 110371416: // title
11056          this.title = TypeConvertor.castToString(value); // StringType
11057          return value;
11058        case -892481550: // status
11059          value = new PublicationStatusEnumFactory().fromType(TypeConvertor.castToCode(value));
11060          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
11061          return value;
11062        case -404562712: // experimental
11063          this.experimental = TypeConvertor.castToBoolean(value); // BooleanType
11064          return value;
11065        case 3076014: // date
11066          this.date = TypeConvertor.castToDateTime(value); // DateTimeType
11067          return value;
11068        case 1447404028: // publisher
11069          this.publisher = TypeConvertor.castToString(value); // StringType
11070          return value;
11071        case 951526432: // contact
11072          this.getContact().add(TypeConvertor.castToContactDetail(value)); // ContactDetail
11073          return value;
11074        case -1724546052: // description
11075          this.description = TypeConvertor.castToMarkdown(value); // MarkdownType
11076          return value;
11077        case -669707736: // useContext
11078          this.getUseContext().add(TypeConvertor.castToUsageContext(value)); // UsageContext
11079          return value;
11080        case -507075711: // jurisdiction
11081          this.getJurisdiction().add(TypeConvertor.castToCodeableConcept(value)); // CodeableConcept
11082          return value;
11083        case -220463842: // purpose
11084          this.purpose = TypeConvertor.castToMarkdown(value); // MarkdownType
11085          return value;
11086        case 1522889671: // copyright
11087          this.copyright = TypeConvertor.castToMarkdown(value); // MarkdownType
11088          return value;
11089        case 765157229: // copyrightLabel
11090          this.copyrightLabel = TypeConvertor.castToString(value); // StringType
11091          return value;
11092        case -1008619738: // origin
11093          this.getOrigin().add((TestScriptOriginComponent) value); // TestScriptOriginComponent
11094          return value;
11095        case -1429847026: // destination
11096          this.getDestination().add((TestScriptDestinationComponent) value); // TestScriptDestinationComponent
11097          return value;
11098        case -450004177: // metadata
11099          this.metadata = (TestScriptMetadataComponent) value; // TestScriptMetadataComponent
11100          return value;
11101        case 109264468: // scope
11102          this.getScope().add((TestScriptScopeComponent) value); // TestScriptScopeComponent
11103          return value;
11104        case -843449847: // fixture
11105          this.getFixture().add((TestScriptFixtureComponent) value); // TestScriptFixtureComponent
11106          return value;
11107        case -309425751: // profile
11108          this.getProfile().add(TypeConvertor.castToCanonical(value)); // CanonicalType
11109          return value;
11110        case -1249586564: // variable
11111          this.getVariable().add((TestScriptVariableComponent) value); // TestScriptVariableComponent
11112          return value;
11113        case 109329021: // setup
11114          this.setup = (TestScriptSetupComponent) value; // TestScriptSetupComponent
11115          return value;
11116        case 3556498: // test
11117          this.getTest().add((TestScriptTestComponent) value); // TestScriptTestComponent
11118          return value;
11119        case -1663474172: // teardown
11120          this.teardown = (TestScriptTeardownComponent) value; // TestScriptTeardownComponent
11121          return value;
11122        default: return super.setProperty(hash, name, value);
11123        }
11124
11125      }
11126
11127      @Override
11128      public Base setProperty(String name, Base value) throws FHIRException {
11129        if (name.equals("url")) {
11130          this.url = TypeConvertor.castToUri(value); // UriType
11131        } else if (name.equals("identifier")) {
11132          this.getIdentifier().add(TypeConvertor.castToIdentifier(value));
11133        } else if (name.equals("version")) {
11134          this.version = TypeConvertor.castToString(value); // StringType
11135        } else if (name.equals("versionAlgorithm[x]")) {
11136          this.versionAlgorithm = TypeConvertor.castToType(value); // DataType
11137        } else if (name.equals("name")) {
11138          this.name = TypeConvertor.castToString(value); // StringType
11139        } else if (name.equals("title")) {
11140          this.title = TypeConvertor.castToString(value); // StringType
11141        } else if (name.equals("status")) {
11142          value = new PublicationStatusEnumFactory().fromType(TypeConvertor.castToCode(value));
11143          this.status = (Enumeration) value; // Enumeration<PublicationStatus>
11144        } else if (name.equals("experimental")) {
11145          this.experimental = TypeConvertor.castToBoolean(value); // BooleanType
11146        } else if (name.equals("date")) {
11147          this.date = TypeConvertor.castToDateTime(value); // DateTimeType
11148        } else if (name.equals("publisher")) {
11149          this.publisher = TypeConvertor.castToString(value); // StringType
11150        } else if (name.equals("contact")) {
11151          this.getContact().add(TypeConvertor.castToContactDetail(value));
11152        } else if (name.equals("description")) {
11153          this.description = TypeConvertor.castToMarkdown(value); // MarkdownType
11154        } else if (name.equals("useContext")) {
11155          this.getUseContext().add(TypeConvertor.castToUsageContext(value));
11156        } else if (name.equals("jurisdiction")) {
11157          this.getJurisdiction().add(TypeConvertor.castToCodeableConcept(value));
11158        } else if (name.equals("purpose")) {
11159          this.purpose = TypeConvertor.castToMarkdown(value); // MarkdownType
11160        } else if (name.equals("copyright")) {
11161          this.copyright = TypeConvertor.castToMarkdown(value); // MarkdownType
11162        } else if (name.equals("copyrightLabel")) {
11163          this.copyrightLabel = TypeConvertor.castToString(value); // StringType
11164        } else if (name.equals("origin")) {
11165          this.getOrigin().add((TestScriptOriginComponent) value);
11166        } else if (name.equals("destination")) {
11167          this.getDestination().add((TestScriptDestinationComponent) value);
11168        } else if (name.equals("metadata")) {
11169          this.metadata = (TestScriptMetadataComponent) value; // TestScriptMetadataComponent
11170        } else if (name.equals("scope")) {
11171          this.getScope().add((TestScriptScopeComponent) value);
11172        } else if (name.equals("fixture")) {
11173          this.getFixture().add((TestScriptFixtureComponent) value);
11174        } else if (name.equals("profile")) {
11175          this.getProfile().add(TypeConvertor.castToCanonical(value));
11176        } else if (name.equals("variable")) {
11177          this.getVariable().add((TestScriptVariableComponent) value);
11178        } else if (name.equals("setup")) {
11179          this.setup = (TestScriptSetupComponent) value; // TestScriptSetupComponent
11180        } else if (name.equals("test")) {
11181          this.getTest().add((TestScriptTestComponent) value);
11182        } else if (name.equals("teardown")) {
11183          this.teardown = (TestScriptTeardownComponent) value; // TestScriptTeardownComponent
11184        } else
11185          return super.setProperty(name, value);
11186        return value;
11187      }
11188
11189      @Override
11190      public Base makeProperty(int hash, String name) throws FHIRException {
11191        switch (hash) {
11192        case 116079:  return getUrlElement();
11193        case -1618432855:  return addIdentifier(); 
11194        case 351608024:  return getVersionElement();
11195        case -115699031:  return getVersionAlgorithm();
11196        case 1508158071:  return getVersionAlgorithm();
11197        case 3373707:  return getNameElement();
11198        case 110371416:  return getTitleElement();
11199        case -892481550:  return getStatusElement();
11200        case -404562712:  return getExperimentalElement();
11201        case 3076014:  return getDateElement();
11202        case 1447404028:  return getPublisherElement();
11203        case 951526432:  return addContact(); 
11204        case -1724546052:  return getDescriptionElement();
11205        case -669707736:  return addUseContext(); 
11206        case -507075711:  return addJurisdiction(); 
11207        case -220463842:  return getPurposeElement();
11208        case 1522889671:  return getCopyrightElement();
11209        case 765157229:  return getCopyrightLabelElement();
11210        case -1008619738:  return addOrigin(); 
11211        case -1429847026:  return addDestination(); 
11212        case -450004177:  return getMetadata();
11213        case 109264468:  return addScope(); 
11214        case -843449847:  return addFixture(); 
11215        case -309425751:  return addProfileElement();
11216        case -1249586564:  return addVariable(); 
11217        case 109329021:  return getSetup();
11218        case 3556498:  return addTest(); 
11219        case -1663474172:  return getTeardown();
11220        default: return super.makeProperty(hash, name);
11221        }
11222
11223      }
11224
11225      @Override
11226      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
11227        switch (hash) {
11228        case 116079: /*url*/ return new String[] {"uri"};
11229        case -1618432855: /*identifier*/ return new String[] {"Identifier"};
11230        case 351608024: /*version*/ return new String[] {"string"};
11231        case 1508158071: /*versionAlgorithm*/ return new String[] {"string", "Coding"};
11232        case 3373707: /*name*/ return new String[] {"string"};
11233        case 110371416: /*title*/ return new String[] {"string"};
11234        case -892481550: /*status*/ return new String[] {"code"};
11235        case -404562712: /*experimental*/ return new String[] {"boolean"};
11236        case 3076014: /*date*/ return new String[] {"dateTime"};
11237        case 1447404028: /*publisher*/ return new String[] {"string"};
11238        case 951526432: /*contact*/ return new String[] {"ContactDetail"};
11239        case -1724546052: /*description*/ return new String[] {"markdown"};
11240        case -669707736: /*useContext*/ return new String[] {"UsageContext"};
11241        case -507075711: /*jurisdiction*/ return new String[] {"CodeableConcept"};
11242        case -220463842: /*purpose*/ return new String[] {"markdown"};
11243        case 1522889671: /*copyright*/ return new String[] {"markdown"};
11244        case 765157229: /*copyrightLabel*/ return new String[] {"string"};
11245        case -1008619738: /*origin*/ return new String[] {};
11246        case -1429847026: /*destination*/ return new String[] {};
11247        case -450004177: /*metadata*/ return new String[] {};
11248        case 109264468: /*scope*/ return new String[] {};
11249        case -843449847: /*fixture*/ return new String[] {};
11250        case -309425751: /*profile*/ return new String[] {"canonical"};
11251        case -1249586564: /*variable*/ return new String[] {};
11252        case 109329021: /*setup*/ return new String[] {};
11253        case 3556498: /*test*/ return new String[] {};
11254        case -1663474172: /*teardown*/ return new String[] {};
11255        default: return super.getTypesForProperty(hash, name);
11256        }
11257
11258      }
11259
11260      @Override
11261      public Base addChild(String name) throws FHIRException {
11262        if (name.equals("url")) {
11263          throw new FHIRException("Cannot call addChild on a singleton property TestScript.url");
11264        }
11265        else if (name.equals("identifier")) {
11266          return addIdentifier();
11267        }
11268        else if (name.equals("version")) {
11269          throw new FHIRException("Cannot call addChild on a singleton property TestScript.version");
11270        }
11271        else if (name.equals("versionAlgorithmString")) {
11272          this.versionAlgorithm = new StringType();
11273          return this.versionAlgorithm;
11274        }
11275        else if (name.equals("versionAlgorithmCoding")) {
11276          this.versionAlgorithm = new Coding();
11277          return this.versionAlgorithm;
11278        }
11279        else if (name.equals("name")) {
11280          throw new FHIRException("Cannot call addChild on a singleton property TestScript.name");
11281        }
11282        else if (name.equals("title")) {
11283          throw new FHIRException("Cannot call addChild on a singleton property TestScript.title");
11284        }
11285        else if (name.equals("status")) {
11286          throw new FHIRException("Cannot call addChild on a singleton property TestScript.status");
11287        }
11288        else if (name.equals("experimental")) {
11289          throw new FHIRException("Cannot call addChild on a singleton property TestScript.experimental");
11290        }
11291        else if (name.equals("date")) {
11292          throw new FHIRException("Cannot call addChild on a singleton property TestScript.date");
11293        }
11294        else if (name.equals("publisher")) {
11295          throw new FHIRException("Cannot call addChild on a singleton property TestScript.publisher");
11296        }
11297        else if (name.equals("contact")) {
11298          return addContact();
11299        }
11300        else if (name.equals("description")) {
11301          throw new FHIRException("Cannot call addChild on a singleton property TestScript.description");
11302        }
11303        else if (name.equals("useContext")) {
11304          return addUseContext();
11305        }
11306        else if (name.equals("jurisdiction")) {
11307          return addJurisdiction();
11308        }
11309        else if (name.equals("purpose")) {
11310          throw new FHIRException("Cannot call addChild on a singleton property TestScript.purpose");
11311        }
11312        else if (name.equals("copyright")) {
11313          throw new FHIRException("Cannot call addChild on a singleton property TestScript.copyright");
11314        }
11315        else if (name.equals("copyrightLabel")) {
11316          throw new FHIRException("Cannot call addChild on a singleton property TestScript.copyrightLabel");
11317        }
11318        else if (name.equals("origin")) {
11319          return addOrigin();
11320        }
11321        else if (name.equals("destination")) {
11322          return addDestination();
11323        }
11324        else if (name.equals("metadata")) {
11325          this.metadata = new TestScriptMetadataComponent();
11326          return this.metadata;
11327        }
11328        else if (name.equals("scope")) {
11329          return addScope();
11330        }
11331        else if (name.equals("fixture")) {
11332          return addFixture();
11333        }
11334        else if (name.equals("profile")) {
11335          throw new FHIRException("Cannot call addChild on a singleton property TestScript.profile");
11336        }
11337        else if (name.equals("variable")) {
11338          return addVariable();
11339        }
11340        else if (name.equals("setup")) {
11341          this.setup = new TestScriptSetupComponent();
11342          return this.setup;
11343        }
11344        else if (name.equals("test")) {
11345          return addTest();
11346        }
11347        else if (name.equals("teardown")) {
11348          this.teardown = new TestScriptTeardownComponent();
11349          return this.teardown;
11350        }
11351        else
11352          return super.addChild(name);
11353      }
11354
11355  public String fhirType() {
11356    return "TestScript";
11357
11358  }
11359
11360      public TestScript copy() {
11361        TestScript dst = new TestScript();
11362        copyValues(dst);
11363        return dst;
11364      }
11365
11366      public void copyValues(TestScript dst) {
11367        super.copyValues(dst);
11368        dst.url = url == null ? null : url.copy();
11369        if (identifier != null) {
11370          dst.identifier = new ArrayList<Identifier>();
11371          for (Identifier i : identifier)
11372            dst.identifier.add(i.copy());
11373        };
11374        dst.version = version == null ? null : version.copy();
11375        dst.versionAlgorithm = versionAlgorithm == null ? null : versionAlgorithm.copy();
11376        dst.name = name == null ? null : name.copy();
11377        dst.title = title == null ? null : title.copy();
11378        dst.status = status == null ? null : status.copy();
11379        dst.experimental = experimental == null ? null : experimental.copy();
11380        dst.date = date == null ? null : date.copy();
11381        dst.publisher = publisher == null ? null : publisher.copy();
11382        if (contact != null) {
11383          dst.contact = new ArrayList<ContactDetail>();
11384          for (ContactDetail i : contact)
11385            dst.contact.add(i.copy());
11386        };
11387        dst.description = description == null ? null : description.copy();
11388        if (useContext != null) {
11389          dst.useContext = new ArrayList<UsageContext>();
11390          for (UsageContext i : useContext)
11391            dst.useContext.add(i.copy());
11392        };
11393        if (jurisdiction != null) {
11394          dst.jurisdiction = new ArrayList<CodeableConcept>();
11395          for (CodeableConcept i : jurisdiction)
11396            dst.jurisdiction.add(i.copy());
11397        };
11398        dst.purpose = purpose == null ? null : purpose.copy();
11399        dst.copyright = copyright == null ? null : copyright.copy();
11400        dst.copyrightLabel = copyrightLabel == null ? null : copyrightLabel.copy();
11401        if (origin != null) {
11402          dst.origin = new ArrayList<TestScriptOriginComponent>();
11403          for (TestScriptOriginComponent i : origin)
11404            dst.origin.add(i.copy());
11405        };
11406        if (destination != null) {
11407          dst.destination = new ArrayList<TestScriptDestinationComponent>();
11408          for (TestScriptDestinationComponent i : destination)
11409            dst.destination.add(i.copy());
11410        };
11411        dst.metadata = metadata == null ? null : metadata.copy();
11412        if (scope != null) {
11413          dst.scope = new ArrayList<TestScriptScopeComponent>();
11414          for (TestScriptScopeComponent i : scope)
11415            dst.scope.add(i.copy());
11416        };
11417        if (fixture != null) {
11418          dst.fixture = new ArrayList<TestScriptFixtureComponent>();
11419          for (TestScriptFixtureComponent i : fixture)
11420            dst.fixture.add(i.copy());
11421        };
11422        if (profile != null) {
11423          dst.profile = new ArrayList<CanonicalType>();
11424          for (CanonicalType i : profile)
11425            dst.profile.add(i.copy());
11426        };
11427        if (variable != null) {
11428          dst.variable = new ArrayList<TestScriptVariableComponent>();
11429          for (TestScriptVariableComponent i : variable)
11430            dst.variable.add(i.copy());
11431        };
11432        dst.setup = setup == null ? null : setup.copy();
11433        if (test != null) {
11434          dst.test = new ArrayList<TestScriptTestComponent>();
11435          for (TestScriptTestComponent i : test)
11436            dst.test.add(i.copy());
11437        };
11438        dst.teardown = teardown == null ? null : teardown.copy();
11439      }
11440
11441      protected TestScript typedCopy() {
11442        return copy();
11443      }
11444
11445      @Override
11446      public boolean equalsDeep(Base other_) {
11447        if (!super.equalsDeep(other_))
11448          return false;
11449        if (!(other_ instanceof TestScript))
11450          return false;
11451        TestScript o = (TestScript) other_;
11452        return compareDeep(url, o.url, true) && compareDeep(identifier, o.identifier, true) && compareDeep(version, o.version, true)
11453           && compareDeep(versionAlgorithm, o.versionAlgorithm, true) && compareDeep(name, o.name, true) && compareDeep(title, o.title, true)
11454           && compareDeep(status, o.status, true) && compareDeep(experimental, o.experimental, true) && compareDeep(date, o.date, true)
11455           && compareDeep(publisher, o.publisher, true) && compareDeep(contact, o.contact, true) && compareDeep(description, o.description, true)
11456           && compareDeep(useContext, o.useContext, true) && compareDeep(jurisdiction, o.jurisdiction, true)
11457           && compareDeep(purpose, o.purpose, true) && compareDeep(copyright, o.copyright, true) && compareDeep(copyrightLabel, o.copyrightLabel, true)
11458           && compareDeep(origin, o.origin, true) && compareDeep(destination, o.destination, true) && compareDeep(metadata, o.metadata, true)
11459           && compareDeep(scope, o.scope, true) && compareDeep(fixture, o.fixture, true) && compareDeep(profile, o.profile, true)
11460           && compareDeep(variable, o.variable, true) && compareDeep(setup, o.setup, true) && compareDeep(test, o.test, true)
11461           && compareDeep(teardown, o.teardown, true);
11462      }
11463
11464      @Override
11465      public boolean equalsShallow(Base other_) {
11466        if (!super.equalsShallow(other_))
11467          return false;
11468        if (!(other_ instanceof TestScript))
11469          return false;
11470        TestScript o = (TestScript) other_;
11471        return compareValues(url, o.url, true) && compareValues(version, o.version, true) && compareValues(name, o.name, true)
11472           && compareValues(title, o.title, true) && compareValues(status, o.status, true) && compareValues(experimental, o.experimental, true)
11473           && compareValues(date, o.date, true) && compareValues(publisher, o.publisher, true) && compareValues(description, o.description, true)
11474           && compareValues(purpose, o.purpose, true) && compareValues(copyright, o.copyright, true) && compareValues(copyrightLabel, o.copyrightLabel, true)
11475           && compareValues(profile, o.profile, true);
11476      }
11477
11478      public boolean isEmpty() {
11479        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(url, identifier, version
11480          , versionAlgorithm, name, title, status, experimental, date, publisher, contact
11481          , description, useContext, jurisdiction, purpose, copyright, copyrightLabel, origin
11482          , destination, metadata, scope, fixture, profile, variable, setup, test, teardown
11483          );
11484      }
11485
11486  @Override
11487  public ResourceType getResourceType() {
11488    return ResourceType.TestScript;
11489   }
11490
11491 /**
11492   * Search parameter: <b>context-quantity</b>
11493   * <p>
11494   * Description: <b>Multiple Resources: 
11495
11496* [ActivityDefinition](activitydefinition.html): A quantity- or range-valued use context assigned to the activity definition
11497* [ActorDefinition](actordefinition.html): A quantity- or range-valued use context assigned to the Actor Definition
11498* [CapabilityStatement](capabilitystatement.html): A quantity- or range-valued use context assigned to the capability statement
11499* [ChargeItemDefinition](chargeitemdefinition.html): A quantity- or range-valued use context assigned to the charge item definition
11500* [Citation](citation.html): A quantity- or range-valued use context assigned to the citation
11501* [CodeSystem](codesystem.html): A quantity- or range-valued use context assigned to the code system
11502* [CompartmentDefinition](compartmentdefinition.html): A quantity- or range-valued use context assigned to the compartment definition
11503* [ConceptMap](conceptmap.html): A quantity- or range-valued use context assigned to the concept map
11504* [ConditionDefinition](conditiondefinition.html): A quantity- or range-valued use context assigned to the condition definition
11505* [EventDefinition](eventdefinition.html): A quantity- or range-valued use context assigned to the event definition
11506* [Evidence](evidence.html): A quantity- or range-valued use context assigned to the evidence
11507* [EvidenceReport](evidencereport.html): A quantity- or range-valued use context assigned to the evidence report
11508* [EvidenceVariable](evidencevariable.html): A quantity- or range-valued use context assigned to the evidence variable
11509* [ExampleScenario](examplescenario.html): A quantity- or range-valued use context assigned to the example scenario
11510* [GraphDefinition](graphdefinition.html): A quantity- or range-valued use context assigned to the graph definition
11511* [ImplementationGuide](implementationguide.html): A quantity- or range-valued use context assigned to the implementation guide
11512* [Library](library.html): A quantity- or range-valued use context assigned to the library
11513* [Measure](measure.html): A quantity- or range-valued use context assigned to the measure
11514* [MessageDefinition](messagedefinition.html): A quantity- or range-valued use context assigned to the message definition
11515* [NamingSystem](namingsystem.html): A quantity- or range-valued use context assigned to the naming system
11516* [OperationDefinition](operationdefinition.html): A quantity- or range-valued use context assigned to the operation definition
11517* [PlanDefinition](plandefinition.html): A quantity- or range-valued use context assigned to the plan definition
11518* [Questionnaire](questionnaire.html): A quantity- or range-valued use context assigned to the questionnaire
11519* [Requirements](requirements.html): A quantity- or range-valued use context assigned to the requirements
11520* [SearchParameter](searchparameter.html): A quantity- or range-valued use context assigned to the search parameter
11521* [StructureDefinition](structuredefinition.html): A quantity- or range-valued use context assigned to the structure definition
11522* [StructureMap](structuremap.html): A quantity- or range-valued use context assigned to the structure map
11523* [TerminologyCapabilities](terminologycapabilities.html): A quantity- or range-valued use context assigned to the terminology capabilities
11524* [TestScript](testscript.html): A quantity- or range-valued use context assigned to the test script
11525* [ValueSet](valueset.html): A quantity- or range-valued use context assigned to the value set
11526</b><br>
11527   * Type: <b>quantity</b><br>
11528   * Path: <b>(ActivityDefinition.useContext.value.ofType(Quantity)) | (ActivityDefinition.useContext.value.ofType(Range)) | (ActorDefinition.useContext.value.ofType(Quantity)) | (ActorDefinition.useContext.value.ofType(Range)) | (CapabilityStatement.useContext.value.ofType(Quantity)) | (CapabilityStatement.useContext.value.ofType(Range)) | (ChargeItemDefinition.useContext.value.ofType(Quantity)) | (ChargeItemDefinition.useContext.value.ofType(Range)) | (Citation.useContext.value.ofType(Quantity)) | (Citation.useContext.value.ofType(Range)) | (CodeSystem.useContext.value.ofType(Quantity)) | (CodeSystem.useContext.value.ofType(Range)) | (CompartmentDefinition.useContext.value.ofType(Quantity)) | (CompartmentDefinition.useContext.value.ofType(Range)) | (ConceptMap.useContext.value.ofType(Quantity)) | (ConceptMap.useContext.value.ofType(Range)) | (ConditionDefinition.useContext.value.ofType(Quantity)) | (ConditionDefinition.useContext.value.ofType(Range)) | (EventDefinition.useContext.value.ofType(Quantity)) | (EventDefinition.useContext.value.ofType(Range)) | (Evidence.useContext.value.ofType(Quantity)) | (Evidence.useContext.value.ofType(Range)) | (EvidenceReport.useContext.value.ofType(Quantity)) | (EvidenceReport.useContext.value.ofType(Range)) | (EvidenceVariable.useContext.value.ofType(Quantity)) | (EvidenceVariable.useContext.value.ofType(Range)) | (ExampleScenario.useContext.value.ofType(Quantity)) | (ExampleScenario.useContext.value.ofType(Range)) | (GraphDefinition.useContext.value.ofType(Quantity)) | (GraphDefinition.useContext.value.ofType(Range)) | (ImplementationGuide.useContext.value.ofType(Quantity)) | (ImplementationGuide.useContext.value.ofType(Range)) | (Library.useContext.value.ofType(Quantity)) | (Library.useContext.value.ofType(Range)) | (Measure.useContext.value.ofType(Quantity)) | (Measure.useContext.value.ofType(Range)) | (MessageDefinition.useContext.value.ofType(Quantity)) | (MessageDefinition.useContext.value.ofType(Range)) | (NamingSystem.useContext.value.ofType(Quantity)) | (NamingSystem.useContext.value.ofType(Range)) | (OperationDefinition.useContext.value.ofType(Quantity)) | (OperationDefinition.useContext.value.ofType(Range)) | (PlanDefinition.useContext.value.ofType(Quantity)) | (PlanDefinition.useContext.value.ofType(Range)) | (Questionnaire.useContext.value.ofType(Quantity)) | (Questionnaire.useContext.value.ofType(Range)) | (Requirements.useContext.value.ofType(Quantity)) | (Requirements.useContext.value.ofType(Range)) | (SearchParameter.useContext.value.ofType(Quantity)) | (SearchParameter.useContext.value.ofType(Range)) | (StructureDefinition.useContext.value.ofType(Quantity)) | (StructureDefinition.useContext.value.ofType(Range)) | (StructureMap.useContext.value.ofType(Quantity)) | (StructureMap.useContext.value.ofType(Range)) | (TerminologyCapabilities.useContext.value.ofType(Quantity)) | (TerminologyCapabilities.useContext.value.ofType(Range)) | (TestScript.useContext.value.ofType(Quantity)) | (TestScript.useContext.value.ofType(Range)) | (ValueSet.useContext.value.ofType(Quantity)) | (ValueSet.useContext.value.ofType(Range))</b><br>
11529   * </p>
11530   */
11531  @SearchParamDefinition(name="context-quantity", path="(ActivityDefinition.useContext.value.ofType(Quantity)) | (ActivityDefinition.useContext.value.ofType(Range)) | (ActorDefinition.useContext.value.ofType(Quantity)) | (ActorDefinition.useContext.value.ofType(Range)) | (CapabilityStatement.useContext.value.ofType(Quantity)) | (CapabilityStatement.useContext.value.ofType(Range)) | (ChargeItemDefinition.useContext.value.ofType(Quantity)) | (ChargeItemDefinition.useContext.value.ofType(Range)) | (Citation.useContext.value.ofType(Quantity)) | (Citation.useContext.value.ofType(Range)) | (CodeSystem.useContext.value.ofType(Quantity)) | (CodeSystem.useContext.value.ofType(Range)) | (CompartmentDefinition.useContext.value.ofType(Quantity)) | (CompartmentDefinition.useContext.value.ofType(Range)) | (ConceptMap.useContext.value.ofType(Quantity)) | (ConceptMap.useContext.value.ofType(Range)) | (ConditionDefinition.useContext.value.ofType(Quantity)) | (ConditionDefinition.useContext.value.ofType(Range)) | (EventDefinition.useContext.value.ofType(Quantity)) | (EventDefinition.useContext.value.ofType(Range)) | (Evidence.useContext.value.ofType(Quantity)) | (Evidence.useContext.value.ofType(Range)) | (EvidenceReport.useContext.value.ofType(Quantity)) | (EvidenceReport.useContext.value.ofType(Range)) | (EvidenceVariable.useContext.value.ofType(Quantity)) | (EvidenceVariable.useContext.value.ofType(Range)) | (ExampleScenario.useContext.value.ofType(Quantity)) | (ExampleScenario.useContext.value.ofType(Range)) | (GraphDefinition.useContext.value.ofType(Quantity)) | (GraphDefinition.useContext.value.ofType(Range)) | (ImplementationGuide.useContext.value.ofType(Quantity)) | (ImplementationGuide.useContext.value.ofType(Range)) | (Library.useContext.value.ofType(Quantity)) | (Library.useContext.value.ofType(Range)) | (Measure.useContext.value.ofType(Quantity)) | (Measure.useContext.value.ofType(Range)) | (MessageDefinition.useContext.value.ofType(Quantity)) | (MessageDefinition.useContext.value.ofType(Range)) | (NamingSystem.useContext.value.ofType(Quantity)) | (NamingSystem.useContext.value.ofType(Range)) | (OperationDefinition.useContext.value.ofType(Quantity)) | (OperationDefinition.useContext.value.ofType(Range)) | (PlanDefinition.useContext.value.ofType(Quantity)) | (PlanDefinition.useContext.value.ofType(Range)) | (Questionnaire.useContext.value.ofType(Quantity)) | (Questionnaire.useContext.value.ofType(Range)) | (Requirements.useContext.value.ofType(Quantity)) | (Requirements.useContext.value.ofType(Range)) | (SearchParameter.useContext.value.ofType(Quantity)) | (SearchParameter.useContext.value.ofType(Range)) | (StructureDefinition.useContext.value.ofType(Quantity)) | (StructureDefinition.useContext.value.ofType(Range)) | (StructureMap.useContext.value.ofType(Quantity)) | (StructureMap.useContext.value.ofType(Range)) | (TerminologyCapabilities.useContext.value.ofType(Quantity)) | (TerminologyCapabilities.useContext.value.ofType(Range)) | (TestScript.useContext.value.ofType(Quantity)) | (TestScript.useContext.value.ofType(Range)) | (ValueSet.useContext.value.ofType(Quantity)) | (ValueSet.useContext.value.ofType(Range))", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): A quantity- or range-valued use context assigned to the activity definition\r\n* [ActorDefinition](actordefinition.html): A quantity- or range-valued use context assigned to the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): A quantity- or range-valued use context assigned to the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): A quantity- or range-valued use context assigned to the charge item definition\r\n* [Citation](citation.html): A quantity- or range-valued use context assigned to the citation\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* [ConditionDefinition](conditiondefinition.html): A quantity- or range-valued use context assigned to the condition definition\r\n* [EventDefinition](eventdefinition.html): A quantity- or range-valued use context assigned to the event definition\r\n* [Evidence](evidence.html): A quantity- or range-valued use context assigned to the evidence\r\n* [EvidenceReport](evidencereport.html): A quantity- or range-valued use context assigned to the evidence report\r\n* [EvidenceVariable](evidencevariable.html): A quantity- or range-valued use context assigned to the evidence variable\r\n* [ExampleScenario](examplescenario.html): A quantity- or range-valued use context assigned to the example scenario\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* [Library](library.html): A quantity- or range-valued use context assigned to the library\r\n* [Measure](measure.html): A quantity- or range-valued use context assigned to the measure\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* [PlanDefinition](plandefinition.html): A quantity- or range-valued use context assigned to the plan definition\r\n* [Questionnaire](questionnaire.html): A quantity- or range-valued use context assigned to the questionnaire\r\n* [Requirements](requirements.html): A quantity- or range-valued use context assigned to the requirements\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* [TestScript](testscript.html): A quantity- or range-valued use context assigned to the test script\r\n* [ValueSet](valueset.html): A quantity- or range-valued use context assigned to the value set\r\n", type="quantity" )
11532  public static final String SP_CONTEXT_QUANTITY = "context-quantity";
11533 /**
11534   * <b>Fluent Client</b> search parameter constant for <b>context-quantity</b>
11535   * <p>
11536   * Description: <b>Multiple Resources: 
11537
11538* [ActivityDefinition](activitydefinition.html): A quantity- or range-valued use context assigned to the activity definition
11539* [ActorDefinition](actordefinition.html): A quantity- or range-valued use context assigned to the Actor Definition
11540* [CapabilityStatement](capabilitystatement.html): A quantity- or range-valued use context assigned to the capability statement
11541* [ChargeItemDefinition](chargeitemdefinition.html): A quantity- or range-valued use context assigned to the charge item definition
11542* [Citation](citation.html): A quantity- or range-valued use context assigned to the citation
11543* [CodeSystem](codesystem.html): A quantity- or range-valued use context assigned to the code system
11544* [CompartmentDefinition](compartmentdefinition.html): A quantity- or range-valued use context assigned to the compartment definition
11545* [ConceptMap](conceptmap.html): A quantity- or range-valued use context assigned to the concept map
11546* [ConditionDefinition](conditiondefinition.html): A quantity- or range-valued use context assigned to the condition definition
11547* [EventDefinition](eventdefinition.html): A quantity- or range-valued use context assigned to the event definition
11548* [Evidence](evidence.html): A quantity- or range-valued use context assigned to the evidence
11549* [EvidenceReport](evidencereport.html): A quantity- or range-valued use context assigned to the evidence report
11550* [EvidenceVariable](evidencevariable.html): A quantity- or range-valued use context assigned to the evidence variable
11551* [ExampleScenario](examplescenario.html): A quantity- or range-valued use context assigned to the example scenario
11552* [GraphDefinition](graphdefinition.html): A quantity- or range-valued use context assigned to the graph definition
11553* [ImplementationGuide](implementationguide.html): A quantity- or range-valued use context assigned to the implementation guide
11554* [Library](library.html): A quantity- or range-valued use context assigned to the library
11555* [Measure](measure.html): A quantity- or range-valued use context assigned to the measure
11556* [MessageDefinition](messagedefinition.html): A quantity- or range-valued use context assigned to the message definition
11557* [NamingSystem](namingsystem.html): A quantity- or range-valued use context assigned to the naming system
11558* [OperationDefinition](operationdefinition.html): A quantity- or range-valued use context assigned to the operation definition
11559* [PlanDefinition](plandefinition.html): A quantity- or range-valued use context assigned to the plan definition
11560* [Questionnaire](questionnaire.html): A quantity- or range-valued use context assigned to the questionnaire
11561* [Requirements](requirements.html): A quantity- or range-valued use context assigned to the requirements
11562* [SearchParameter](searchparameter.html): A quantity- or range-valued use context assigned to the search parameter
11563* [StructureDefinition](structuredefinition.html): A quantity- or range-valued use context assigned to the structure definition
11564* [StructureMap](structuremap.html): A quantity- or range-valued use context assigned to the structure map
11565* [TerminologyCapabilities](terminologycapabilities.html): A quantity- or range-valued use context assigned to the terminology capabilities
11566* [TestScript](testscript.html): A quantity- or range-valued use context assigned to the test script
11567* [ValueSet](valueset.html): A quantity- or range-valued use context assigned to the value set
11568</b><br>
11569   * Type: <b>quantity</b><br>
11570   * Path: <b>(ActivityDefinition.useContext.value.ofType(Quantity)) | (ActivityDefinition.useContext.value.ofType(Range)) | (ActorDefinition.useContext.value.ofType(Quantity)) | (ActorDefinition.useContext.value.ofType(Range)) | (CapabilityStatement.useContext.value.ofType(Quantity)) | (CapabilityStatement.useContext.value.ofType(Range)) | (ChargeItemDefinition.useContext.value.ofType(Quantity)) | (ChargeItemDefinition.useContext.value.ofType(Range)) | (Citation.useContext.value.ofType(Quantity)) | (Citation.useContext.value.ofType(Range)) | (CodeSystem.useContext.value.ofType(Quantity)) | (CodeSystem.useContext.value.ofType(Range)) | (CompartmentDefinition.useContext.value.ofType(Quantity)) | (CompartmentDefinition.useContext.value.ofType(Range)) | (ConceptMap.useContext.value.ofType(Quantity)) | (ConceptMap.useContext.value.ofType(Range)) | (ConditionDefinition.useContext.value.ofType(Quantity)) | (ConditionDefinition.useContext.value.ofType(Range)) | (EventDefinition.useContext.value.ofType(Quantity)) | (EventDefinition.useContext.value.ofType(Range)) | (Evidence.useContext.value.ofType(Quantity)) | (Evidence.useContext.value.ofType(Range)) | (EvidenceReport.useContext.value.ofType(Quantity)) | (EvidenceReport.useContext.value.ofType(Range)) | (EvidenceVariable.useContext.value.ofType(Quantity)) | (EvidenceVariable.useContext.value.ofType(Range)) | (ExampleScenario.useContext.value.ofType(Quantity)) | (ExampleScenario.useContext.value.ofType(Range)) | (GraphDefinition.useContext.value.ofType(Quantity)) | (GraphDefinition.useContext.value.ofType(Range)) | (ImplementationGuide.useContext.value.ofType(Quantity)) | (ImplementationGuide.useContext.value.ofType(Range)) | (Library.useContext.value.ofType(Quantity)) | (Library.useContext.value.ofType(Range)) | (Measure.useContext.value.ofType(Quantity)) | (Measure.useContext.value.ofType(Range)) | (MessageDefinition.useContext.value.ofType(Quantity)) | (MessageDefinition.useContext.value.ofType(Range)) | (NamingSystem.useContext.value.ofType(Quantity)) | (NamingSystem.useContext.value.ofType(Range)) | (OperationDefinition.useContext.value.ofType(Quantity)) | (OperationDefinition.useContext.value.ofType(Range)) | (PlanDefinition.useContext.value.ofType(Quantity)) | (PlanDefinition.useContext.value.ofType(Range)) | (Questionnaire.useContext.value.ofType(Quantity)) | (Questionnaire.useContext.value.ofType(Range)) | (Requirements.useContext.value.ofType(Quantity)) | (Requirements.useContext.value.ofType(Range)) | (SearchParameter.useContext.value.ofType(Quantity)) | (SearchParameter.useContext.value.ofType(Range)) | (StructureDefinition.useContext.value.ofType(Quantity)) | (StructureDefinition.useContext.value.ofType(Range)) | (StructureMap.useContext.value.ofType(Quantity)) | (StructureMap.useContext.value.ofType(Range)) | (TerminologyCapabilities.useContext.value.ofType(Quantity)) | (TerminologyCapabilities.useContext.value.ofType(Range)) | (TestScript.useContext.value.ofType(Quantity)) | (TestScript.useContext.value.ofType(Range)) | (ValueSet.useContext.value.ofType(Quantity)) | (ValueSet.useContext.value.ofType(Range))</b><br>
11571   * </p>
11572   */
11573  public static final ca.uhn.fhir.rest.gclient.QuantityClientParam CONTEXT_QUANTITY = new ca.uhn.fhir.rest.gclient.QuantityClientParam(SP_CONTEXT_QUANTITY);
11574
11575 /**
11576   * Search parameter: <b>context-type-quantity</b>
11577   * <p>
11578   * Description: <b>Multiple Resources: 
11579
11580* [ActivityDefinition](activitydefinition.html): A use context type and quantity- or range-based value assigned to the activity definition
11581* [ActorDefinition](actordefinition.html): A use context type and quantity- or range-based value assigned to the Actor Definition
11582* [CapabilityStatement](capabilitystatement.html): A use context type and quantity- or range-based value assigned to the capability statement
11583* [ChargeItemDefinition](chargeitemdefinition.html): A use context type and quantity- or range-based value assigned to the charge item definition
11584* [Citation](citation.html): A use context type and quantity- or range-based value assigned to the citation
11585* [CodeSystem](codesystem.html): A use context type and quantity- or range-based value assigned to the code system
11586* [CompartmentDefinition](compartmentdefinition.html): A use context type and quantity- or range-based value assigned to the compartment definition
11587* [ConceptMap](conceptmap.html): A use context type and quantity- or range-based value assigned to the concept map
11588* [ConditionDefinition](conditiondefinition.html): A use context type and quantity- or range-based value assigned to the condition definition
11589* [EventDefinition](eventdefinition.html): A use context type and quantity- or range-based value assigned to the event definition
11590* [Evidence](evidence.html): A use context type and quantity- or range-based value assigned to the evidence
11591* [EvidenceReport](evidencereport.html): A use context type and quantity- or range-based value assigned to the evidence report
11592* [EvidenceVariable](evidencevariable.html): A use context type and quantity- or range-based value assigned to the evidence variable
11593* [ExampleScenario](examplescenario.html): A use context type and quantity- or range-based value assigned to the example scenario
11594* [GraphDefinition](graphdefinition.html): A use context type and quantity- or range-based value assigned to the graph definition
11595* [ImplementationGuide](implementationguide.html): A use context type and quantity- or range-based value assigned to the implementation guide
11596* [Library](library.html): A use context type and quantity- or range-based value assigned to the library
11597* [Measure](measure.html): A use context type and quantity- or range-based value assigned to the measure
11598* [MessageDefinition](messagedefinition.html): A use context type and quantity- or range-based value assigned to the message definition
11599* [NamingSystem](namingsystem.html): A use context type and quantity- or range-based value assigned to the naming system
11600* [OperationDefinition](operationdefinition.html): A use context type and quantity- or range-based value assigned to the operation definition
11601* [PlanDefinition](plandefinition.html): A use context type and quantity- or range-based value assigned to the plan definition
11602* [Questionnaire](questionnaire.html): A use context type and quantity- or range-based value assigned to the questionnaire
11603* [Requirements](requirements.html): A use context type and quantity- or range-based value assigned to the requirements
11604* [SearchParameter](searchparameter.html): A use context type and quantity- or range-based value assigned to the search parameter
11605* [StructureDefinition](structuredefinition.html): A use context type and quantity- or range-based value assigned to the structure definition
11606* [StructureMap](structuremap.html): A use context type and quantity- or range-based value assigned to the structure map
11607* [TerminologyCapabilities](terminologycapabilities.html): A use context type and quantity- or range-based value assigned to the terminology capabilities
11608* [TestScript](testscript.html): A use context type and quantity- or range-based value assigned to the test script
11609* [ValueSet](valueset.html): A use context type and quantity- or range-based value assigned to the value set
11610</b><br>
11611   * Type: <b>composite</b><br>
11612   * Path: <b>ActivityDefinition.useContext | ActorDefinition.useContext | CapabilityStatement.useContext | ChargeItemDefinition.useContext | Citation.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | ConditionDefinition.useContext | EventDefinition.useContext | Evidence.useContext | EvidenceReport.useContext | EvidenceVariable.useContext | ExampleScenario.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | Library.useContext | Measure.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | PlanDefinition.useContext | Questionnaire.useContext | Requirements.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | TestScript.useContext | ValueSet.useContext</b><br>
11613   * </p>
11614   */
11615  @SearchParamDefinition(name="context-type-quantity", path="ActivityDefinition.useContext | ActorDefinition.useContext | CapabilityStatement.useContext | ChargeItemDefinition.useContext | Citation.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | ConditionDefinition.useContext | EventDefinition.useContext | Evidence.useContext | EvidenceReport.useContext | EvidenceVariable.useContext | ExampleScenario.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | Library.useContext | Measure.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | PlanDefinition.useContext | Questionnaire.useContext | Requirements.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | TestScript.useContext | ValueSet.useContext", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): A use context type and quantity- or range-based value assigned to the activity definition\r\n* [ActorDefinition](actordefinition.html): A use context type and quantity- or range-based value assigned to the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): A use context type and quantity- or range-based value assigned to the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): A use context type and quantity- or range-based value assigned to the charge item definition\r\n* [Citation](citation.html): A use context type and quantity- or range-based value assigned to the citation\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* [ConditionDefinition](conditiondefinition.html): A use context type and quantity- or range-based value assigned to the condition definition\r\n* [EventDefinition](eventdefinition.html): A use context type and quantity- or range-based value assigned to the event definition\r\n* [Evidence](evidence.html): A use context type and quantity- or range-based value assigned to the evidence\r\n* [EvidenceReport](evidencereport.html): A use context type and quantity- or range-based value assigned to the evidence report\r\n* [EvidenceVariable](evidencevariable.html): A use context type and quantity- or range-based value assigned to the evidence variable\r\n* [ExampleScenario](examplescenario.html): A use context type and quantity- or range-based value assigned to the example scenario\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* [Library](library.html): A use context type and quantity- or range-based value assigned to the library\r\n* [Measure](measure.html): A use context type and quantity- or range-based value assigned to the measure\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* [PlanDefinition](plandefinition.html): A use context type and quantity- or range-based value assigned to the plan definition\r\n* [Questionnaire](questionnaire.html): A use context type and quantity- or range-based value assigned to the questionnaire\r\n* [Requirements](requirements.html): A use context type and quantity- or range-based value assigned to the requirements\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* [TestScript](testscript.html): A use context type and quantity- or range-based value assigned to the test script\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"} )
11616  public static final String SP_CONTEXT_TYPE_QUANTITY = "context-type-quantity";
11617 /**
11618   * <b>Fluent Client</b> search parameter constant for <b>context-type-quantity</b>
11619   * <p>
11620   * Description: <b>Multiple Resources: 
11621
11622* [ActivityDefinition](activitydefinition.html): A use context type and quantity- or range-based value assigned to the activity definition
11623* [ActorDefinition](actordefinition.html): A use context type and quantity- or range-based value assigned to the Actor Definition
11624* [CapabilityStatement](capabilitystatement.html): A use context type and quantity- or range-based value assigned to the capability statement
11625* [ChargeItemDefinition](chargeitemdefinition.html): A use context type and quantity- or range-based value assigned to the charge item definition
11626* [Citation](citation.html): A use context type and quantity- or range-based value assigned to the citation
11627* [CodeSystem](codesystem.html): A use context type and quantity- or range-based value assigned to the code system
11628* [CompartmentDefinition](compartmentdefinition.html): A use context type and quantity- or range-based value assigned to the compartment definition
11629* [ConceptMap](conceptmap.html): A use context type and quantity- or range-based value assigned to the concept map
11630* [ConditionDefinition](conditiondefinition.html): A use context type and quantity- or range-based value assigned to the condition definition
11631* [EventDefinition](eventdefinition.html): A use context type and quantity- or range-based value assigned to the event definition
11632* [Evidence](evidence.html): A use context type and quantity- or range-based value assigned to the evidence
11633* [EvidenceReport](evidencereport.html): A use context type and quantity- or range-based value assigned to the evidence report
11634* [EvidenceVariable](evidencevariable.html): A use context type and quantity- or range-based value assigned to the evidence variable
11635* [ExampleScenario](examplescenario.html): A use context type and quantity- or range-based value assigned to the example scenario
11636* [GraphDefinition](graphdefinition.html): A use context type and quantity- or range-based value assigned to the graph definition
11637* [ImplementationGuide](implementationguide.html): A use context type and quantity- or range-based value assigned to the implementation guide
11638* [Library](library.html): A use context type and quantity- or range-based value assigned to the library
11639* [Measure](measure.html): A use context type and quantity- or range-based value assigned to the measure
11640* [MessageDefinition](messagedefinition.html): A use context type and quantity- or range-based value assigned to the message definition
11641* [NamingSystem](namingsystem.html): A use context type and quantity- or range-based value assigned to the naming system
11642* [OperationDefinition](operationdefinition.html): A use context type and quantity- or range-based value assigned to the operation definition
11643* [PlanDefinition](plandefinition.html): A use context type and quantity- or range-based value assigned to the plan definition
11644* [Questionnaire](questionnaire.html): A use context type and quantity- or range-based value assigned to the questionnaire
11645* [Requirements](requirements.html): A use context type and quantity- or range-based value assigned to the requirements
11646* [SearchParameter](searchparameter.html): A use context type and quantity- or range-based value assigned to the search parameter
11647* [StructureDefinition](structuredefinition.html): A use context type and quantity- or range-based value assigned to the structure definition
11648* [StructureMap](structuremap.html): A use context type and quantity- or range-based value assigned to the structure map
11649* [TerminologyCapabilities](terminologycapabilities.html): A use context type and quantity- or range-based value assigned to the terminology capabilities
11650* [TestScript](testscript.html): A use context type and quantity- or range-based value assigned to the test script
11651* [ValueSet](valueset.html): A use context type and quantity- or range-based value assigned to the value set
11652</b><br>
11653   * Type: <b>composite</b><br>
11654   * Path: <b>ActivityDefinition.useContext | ActorDefinition.useContext | CapabilityStatement.useContext | ChargeItemDefinition.useContext | Citation.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | ConditionDefinition.useContext | EventDefinition.useContext | Evidence.useContext | EvidenceReport.useContext | EvidenceVariable.useContext | ExampleScenario.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | Library.useContext | Measure.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | PlanDefinition.useContext | Questionnaire.useContext | Requirements.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | TestScript.useContext | ValueSet.useContext</b><br>
11655   * </p>
11656   */
11657  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);
11658
11659 /**
11660   * Search parameter: <b>context-type-value</b>
11661   * <p>
11662   * Description: <b>Multiple Resources: 
11663
11664* [ActivityDefinition](activitydefinition.html): A use context type and value assigned to the activity definition
11665* [ActorDefinition](actordefinition.html): A use context type and value assigned to the Actor Definition
11666* [CapabilityStatement](capabilitystatement.html): A use context type and value assigned to the capability statement
11667* [ChargeItemDefinition](chargeitemdefinition.html): A use context type and value assigned to the charge item definition
11668* [Citation](citation.html): A use context type and value assigned to the citation
11669* [CodeSystem](codesystem.html): A use context type and value assigned to the code system
11670* [CompartmentDefinition](compartmentdefinition.html): A use context type and value assigned to the compartment definition
11671* [ConceptMap](conceptmap.html): A use context type and value assigned to the concept map
11672* [ConditionDefinition](conditiondefinition.html): A use context type and value assigned to the condition definition
11673* [EventDefinition](eventdefinition.html): A use context type and value assigned to the event definition
11674* [Evidence](evidence.html): A use context type and value assigned to the evidence
11675* [EvidenceReport](evidencereport.html): A use context type and value assigned to the evidence report
11676* [EvidenceVariable](evidencevariable.html): A use context type and value assigned to the evidence variable
11677* [ExampleScenario](examplescenario.html): A use context type and value assigned to the example scenario
11678* [GraphDefinition](graphdefinition.html): A use context type and value assigned to the graph definition
11679* [ImplementationGuide](implementationguide.html): A use context type and value assigned to the implementation guide
11680* [Library](library.html): A use context type and value assigned to the library
11681* [Measure](measure.html): A use context type and value assigned to the measure
11682* [MessageDefinition](messagedefinition.html): A use context type and value assigned to the message definition
11683* [NamingSystem](namingsystem.html): A use context type and value assigned to the naming system
11684* [OperationDefinition](operationdefinition.html): A use context type and value assigned to the operation definition
11685* [PlanDefinition](plandefinition.html): A use context type and value assigned to the plan definition
11686* [Questionnaire](questionnaire.html): A use context type and value assigned to the questionnaire
11687* [Requirements](requirements.html): A use context type and value assigned to the requirements
11688* [SearchParameter](searchparameter.html): A use context type and value assigned to the search parameter
11689* [StructureDefinition](structuredefinition.html): A use context type and value assigned to the structure definition
11690* [StructureMap](structuremap.html): A use context type and value assigned to the structure map
11691* [TerminologyCapabilities](terminologycapabilities.html): A use context type and value assigned to the terminology capabilities
11692* [TestScript](testscript.html): A use context type and value assigned to the test script
11693* [ValueSet](valueset.html): A use context type and value assigned to the value set
11694</b><br>
11695   * Type: <b>composite</b><br>
11696   * Path: <b>ActivityDefinition.useContext | ActorDefinition.useContext | CapabilityStatement.useContext | ChargeItemDefinition.useContext | Citation.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | ConditionDefinition.useContext | EventDefinition.useContext | Evidence.useContext | EvidenceReport.useContext | EvidenceVariable.useContext | ExampleScenario.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | Library.useContext | Measure.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | PlanDefinition.useContext | Questionnaire.useContext | Requirements.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | TestScript.useContext | ValueSet.useContext</b><br>
11697   * </p>
11698   */
11699  @SearchParamDefinition(name="context-type-value", path="ActivityDefinition.useContext | ActorDefinition.useContext | CapabilityStatement.useContext | ChargeItemDefinition.useContext | Citation.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | ConditionDefinition.useContext | EventDefinition.useContext | Evidence.useContext | EvidenceReport.useContext | EvidenceVariable.useContext | ExampleScenario.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | Library.useContext | Measure.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | PlanDefinition.useContext | Questionnaire.useContext | Requirements.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | TestScript.useContext | ValueSet.useContext", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): A use context type and value assigned to the activity definition\r\n* [ActorDefinition](actordefinition.html): A use context type and value assigned to the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): A use context type and value assigned to the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): A use context type and value assigned to the charge item definition\r\n* [Citation](citation.html): A use context type and value assigned to the citation\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* [ConditionDefinition](conditiondefinition.html): A use context type and value assigned to the condition definition\r\n* [EventDefinition](eventdefinition.html): A use context type and value assigned to the event definition\r\n* [Evidence](evidence.html): A use context type and value assigned to the evidence\r\n* [EvidenceReport](evidencereport.html): A use context type and value assigned to the evidence report\r\n* [EvidenceVariable](evidencevariable.html): A use context type and value assigned to the evidence variable\r\n* [ExampleScenario](examplescenario.html): A use context type and value assigned to the example scenario\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* [Library](library.html): A use context type and value assigned to the library\r\n* [Measure](measure.html): A use context type and value assigned to the measure\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* [PlanDefinition](plandefinition.html): A use context type and value assigned to the plan definition\r\n* [Questionnaire](questionnaire.html): A use context type and value assigned to the questionnaire\r\n* [Requirements](requirements.html): A use context type and value assigned to the requirements\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* [TestScript](testscript.html): A use context type and value assigned to the test script\r\n* [ValueSet](valueset.html): A use context type and value assigned to the value set\r\n", type="composite", compositeOf={"context-type", "context"} )
11700  public static final String SP_CONTEXT_TYPE_VALUE = "context-type-value";
11701 /**
11702   * <b>Fluent Client</b> search parameter constant for <b>context-type-value</b>
11703   * <p>
11704   * Description: <b>Multiple Resources: 
11705
11706* [ActivityDefinition](activitydefinition.html): A use context type and value assigned to the activity definition
11707* [ActorDefinition](actordefinition.html): A use context type and value assigned to the Actor Definition
11708* [CapabilityStatement](capabilitystatement.html): A use context type and value assigned to the capability statement
11709* [ChargeItemDefinition](chargeitemdefinition.html): A use context type and value assigned to the charge item definition
11710* [Citation](citation.html): A use context type and value assigned to the citation
11711* [CodeSystem](codesystem.html): A use context type and value assigned to the code system
11712* [CompartmentDefinition](compartmentdefinition.html): A use context type and value assigned to the compartment definition
11713* [ConceptMap](conceptmap.html): A use context type and value assigned to the concept map
11714* [ConditionDefinition](conditiondefinition.html): A use context type and value assigned to the condition definition
11715* [EventDefinition](eventdefinition.html): A use context type and value assigned to the event definition
11716* [Evidence](evidence.html): A use context type and value assigned to the evidence
11717* [EvidenceReport](evidencereport.html): A use context type and value assigned to the evidence report
11718* [EvidenceVariable](evidencevariable.html): A use context type and value assigned to the evidence variable
11719* [ExampleScenario](examplescenario.html): A use context type and value assigned to the example scenario
11720* [GraphDefinition](graphdefinition.html): A use context type and value assigned to the graph definition
11721* [ImplementationGuide](implementationguide.html): A use context type and value assigned to the implementation guide
11722* [Library](library.html): A use context type and value assigned to the library
11723* [Measure](measure.html): A use context type and value assigned to the measure
11724* [MessageDefinition](messagedefinition.html): A use context type and value assigned to the message definition
11725* [NamingSystem](namingsystem.html): A use context type and value assigned to the naming system
11726* [OperationDefinition](operationdefinition.html): A use context type and value assigned to the operation definition
11727* [PlanDefinition](plandefinition.html): A use context type and value assigned to the plan definition
11728* [Questionnaire](questionnaire.html): A use context type and value assigned to the questionnaire
11729* [Requirements](requirements.html): A use context type and value assigned to the requirements
11730* [SearchParameter](searchparameter.html): A use context type and value assigned to the search parameter
11731* [StructureDefinition](structuredefinition.html): A use context type and value assigned to the structure definition
11732* [StructureMap](structuremap.html): A use context type and value assigned to the structure map
11733* [TerminologyCapabilities](terminologycapabilities.html): A use context type and value assigned to the terminology capabilities
11734* [TestScript](testscript.html): A use context type and value assigned to the test script
11735* [ValueSet](valueset.html): A use context type and value assigned to the value set
11736</b><br>
11737   * Type: <b>composite</b><br>
11738   * Path: <b>ActivityDefinition.useContext | ActorDefinition.useContext | CapabilityStatement.useContext | ChargeItemDefinition.useContext | Citation.useContext | CodeSystem.useContext | CompartmentDefinition.useContext | ConceptMap.useContext | ConditionDefinition.useContext | EventDefinition.useContext | Evidence.useContext | EvidenceReport.useContext | EvidenceVariable.useContext | ExampleScenario.useContext | GraphDefinition.useContext | ImplementationGuide.useContext | Library.useContext | Measure.useContext | MessageDefinition.useContext | NamingSystem.useContext | OperationDefinition.useContext | PlanDefinition.useContext | Questionnaire.useContext | Requirements.useContext | SearchParameter.useContext | StructureDefinition.useContext | StructureMap.useContext | TerminologyCapabilities.useContext | TestScript.useContext | ValueSet.useContext</b><br>
11739   * </p>
11740   */
11741  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);
11742
11743 /**
11744   * Search parameter: <b>context-type</b>
11745   * <p>
11746   * Description: <b>Multiple Resources: 
11747
11748* [ActivityDefinition](activitydefinition.html): A type of use context assigned to the activity definition
11749* [ActorDefinition](actordefinition.html): A type of use context assigned to the Actor Definition
11750* [CapabilityStatement](capabilitystatement.html): A type of use context assigned to the capability statement
11751* [ChargeItemDefinition](chargeitemdefinition.html): A type of use context assigned to the charge item definition
11752* [Citation](citation.html): A type of use context assigned to the citation
11753* [CodeSystem](codesystem.html): A type of use context assigned to the code system
11754* [CompartmentDefinition](compartmentdefinition.html): A type of use context assigned to the compartment definition
11755* [ConceptMap](conceptmap.html): A type of use context assigned to the concept map
11756* [ConditionDefinition](conditiondefinition.html): A type of use context assigned to the condition definition
11757* [EventDefinition](eventdefinition.html): A type of use context assigned to the event definition
11758* [Evidence](evidence.html): A type of use context assigned to the evidence
11759* [EvidenceReport](evidencereport.html): A type of use context assigned to the evidence report
11760* [EvidenceVariable](evidencevariable.html): A type of use context assigned to the evidence variable
11761* [ExampleScenario](examplescenario.html): A type of use context assigned to the example scenario
11762* [GraphDefinition](graphdefinition.html): A type of use context assigned to the graph definition
11763* [ImplementationGuide](implementationguide.html): A type of use context assigned to the implementation guide
11764* [Library](library.html): A type of use context assigned to the library
11765* [Measure](measure.html): A type of use context assigned to the measure
11766* [MessageDefinition](messagedefinition.html): A type of use context assigned to the message definition
11767* [NamingSystem](namingsystem.html): A type of use context assigned to the naming system
11768* [OperationDefinition](operationdefinition.html): A type of use context assigned to the operation definition
11769* [PlanDefinition](plandefinition.html): A type of use context assigned to the plan definition
11770* [Questionnaire](questionnaire.html): A type of use context assigned to the questionnaire
11771* [Requirements](requirements.html): A type of use context assigned to the requirements
11772* [SearchParameter](searchparameter.html): A type of use context assigned to the search parameter
11773* [StructureDefinition](structuredefinition.html): A type of use context assigned to the structure definition
11774* [StructureMap](structuremap.html): A type of use context assigned to the structure map
11775* [TerminologyCapabilities](terminologycapabilities.html): A type of use context assigned to the terminology capabilities
11776* [TestScript](testscript.html): A type of use context assigned to the test script
11777* [ValueSet](valueset.html): A type of use context assigned to the value set
11778</b><br>
11779   * Type: <b>token</b><br>
11780   * Path: <b>ActivityDefinition.useContext.code | ActorDefinition.useContext.code | CapabilityStatement.useContext.code | ChargeItemDefinition.useContext.code | Citation.useContext.code | CodeSystem.useContext.code | CompartmentDefinition.useContext.code | ConceptMap.useContext.code | ConditionDefinition.useContext.code | EventDefinition.useContext.code | Evidence.useContext.code | EvidenceReport.useContext.code | EvidenceVariable.useContext.code | ExampleScenario.useContext.code | GraphDefinition.useContext.code | ImplementationGuide.useContext.code | Library.useContext.code | Measure.useContext.code | MessageDefinition.useContext.code | NamingSystem.useContext.code | OperationDefinition.useContext.code | PlanDefinition.useContext.code | Questionnaire.useContext.code | Requirements.useContext.code | SearchParameter.useContext.code | StructureDefinition.useContext.code | StructureMap.useContext.code | TerminologyCapabilities.useContext.code | TestScript.useContext.code | ValueSet.useContext.code</b><br>
11781   * </p>
11782   */
11783  @SearchParamDefinition(name="context-type", path="ActivityDefinition.useContext.code | ActorDefinition.useContext.code | CapabilityStatement.useContext.code | ChargeItemDefinition.useContext.code | Citation.useContext.code | CodeSystem.useContext.code | CompartmentDefinition.useContext.code | ConceptMap.useContext.code | ConditionDefinition.useContext.code | EventDefinition.useContext.code | Evidence.useContext.code | EvidenceReport.useContext.code | EvidenceVariable.useContext.code | ExampleScenario.useContext.code | GraphDefinition.useContext.code | ImplementationGuide.useContext.code | Library.useContext.code | Measure.useContext.code | MessageDefinition.useContext.code | NamingSystem.useContext.code | OperationDefinition.useContext.code | PlanDefinition.useContext.code | Questionnaire.useContext.code | Requirements.useContext.code | SearchParameter.useContext.code | StructureDefinition.useContext.code | StructureMap.useContext.code | TerminologyCapabilities.useContext.code | TestScript.useContext.code | ValueSet.useContext.code", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): A type of use context assigned to the activity definition\r\n* [ActorDefinition](actordefinition.html): A type of use context assigned to the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): A type of use context assigned to the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): A type of use context assigned to the charge item definition\r\n* [Citation](citation.html): A type of use context assigned to the citation\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* [ConditionDefinition](conditiondefinition.html): A type of use context assigned to the condition definition\r\n* [EventDefinition](eventdefinition.html): A type of use context assigned to the event definition\r\n* [Evidence](evidence.html): A type of use context assigned to the evidence\r\n* [EvidenceReport](evidencereport.html): A type of use context assigned to the evidence report\r\n* [EvidenceVariable](evidencevariable.html): A type of use context assigned to the evidence variable\r\n* [ExampleScenario](examplescenario.html): A type of use context assigned to the example scenario\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* [Library](library.html): A type of use context assigned to the library\r\n* [Measure](measure.html): A type of use context assigned to the measure\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* [PlanDefinition](plandefinition.html): A type of use context assigned to the plan definition\r\n* [Questionnaire](questionnaire.html): A type of use context assigned to the questionnaire\r\n* [Requirements](requirements.html): A type of use context assigned to the requirements\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* [TestScript](testscript.html): A type of use context assigned to the test script\r\n* [ValueSet](valueset.html): A type of use context assigned to the value set\r\n", type="token" )
11784  public static final String SP_CONTEXT_TYPE = "context-type";
11785 /**
11786   * <b>Fluent Client</b> search parameter constant for <b>context-type</b>
11787   * <p>
11788   * Description: <b>Multiple Resources: 
11789
11790* [ActivityDefinition](activitydefinition.html): A type of use context assigned to the activity definition
11791* [ActorDefinition](actordefinition.html): A type of use context assigned to the Actor Definition
11792* [CapabilityStatement](capabilitystatement.html): A type of use context assigned to the capability statement
11793* [ChargeItemDefinition](chargeitemdefinition.html): A type of use context assigned to the charge item definition
11794* [Citation](citation.html): A type of use context assigned to the citation
11795* [CodeSystem](codesystem.html): A type of use context assigned to the code system
11796* [CompartmentDefinition](compartmentdefinition.html): A type of use context assigned to the compartment definition
11797* [ConceptMap](conceptmap.html): A type of use context assigned to the concept map
11798* [ConditionDefinition](conditiondefinition.html): A type of use context assigned to the condition definition
11799* [EventDefinition](eventdefinition.html): A type of use context assigned to the event definition
11800* [Evidence](evidence.html): A type of use context assigned to the evidence
11801* [EvidenceReport](evidencereport.html): A type of use context assigned to the evidence report
11802* [EvidenceVariable](evidencevariable.html): A type of use context assigned to the evidence variable
11803* [ExampleScenario](examplescenario.html): A type of use context assigned to the example scenario
11804* [GraphDefinition](graphdefinition.html): A type of use context assigned to the graph definition
11805* [ImplementationGuide](implementationguide.html): A type of use context assigned to the implementation guide
11806* [Library](library.html): A type of use context assigned to the library
11807* [Measure](measure.html): A type of use context assigned to the measure
11808* [MessageDefinition](messagedefinition.html): A type of use context assigned to the message definition
11809* [NamingSystem](namingsystem.html): A type of use context assigned to the naming system
11810* [OperationDefinition](operationdefinition.html): A type of use context assigned to the operation definition
11811* [PlanDefinition](plandefinition.html): A type of use context assigned to the plan definition
11812* [Questionnaire](questionnaire.html): A type of use context assigned to the questionnaire
11813* [Requirements](requirements.html): A type of use context assigned to the requirements
11814* [SearchParameter](searchparameter.html): A type of use context assigned to the search parameter
11815* [StructureDefinition](structuredefinition.html): A type of use context assigned to the structure definition
11816* [StructureMap](structuremap.html): A type of use context assigned to the structure map
11817* [TerminologyCapabilities](terminologycapabilities.html): A type of use context assigned to the terminology capabilities
11818* [TestScript](testscript.html): A type of use context assigned to the test script
11819* [ValueSet](valueset.html): A type of use context assigned to the value set
11820</b><br>
11821   * Type: <b>token</b><br>
11822   * Path: <b>ActivityDefinition.useContext.code | ActorDefinition.useContext.code | CapabilityStatement.useContext.code | ChargeItemDefinition.useContext.code | Citation.useContext.code | CodeSystem.useContext.code | CompartmentDefinition.useContext.code | ConceptMap.useContext.code | ConditionDefinition.useContext.code | EventDefinition.useContext.code | Evidence.useContext.code | EvidenceReport.useContext.code | EvidenceVariable.useContext.code | ExampleScenario.useContext.code | GraphDefinition.useContext.code | ImplementationGuide.useContext.code | Library.useContext.code | Measure.useContext.code | MessageDefinition.useContext.code | NamingSystem.useContext.code | OperationDefinition.useContext.code | PlanDefinition.useContext.code | Questionnaire.useContext.code | Requirements.useContext.code | SearchParameter.useContext.code | StructureDefinition.useContext.code | StructureMap.useContext.code | TerminologyCapabilities.useContext.code | TestScript.useContext.code | ValueSet.useContext.code</b><br>
11823   * </p>
11824   */
11825  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT_TYPE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT_TYPE);
11826
11827 /**
11828   * Search parameter: <b>context</b>
11829   * <p>
11830   * Description: <b>Multiple Resources: 
11831
11832* [ActivityDefinition](activitydefinition.html): A use context assigned to the activity definition
11833* [ActorDefinition](actordefinition.html): A use context assigned to the Actor Definition
11834* [CapabilityStatement](capabilitystatement.html): A use context assigned to the capability statement
11835* [ChargeItemDefinition](chargeitemdefinition.html): A use context assigned to the charge item definition
11836* [Citation](citation.html): A use context assigned to the citation
11837* [CodeSystem](codesystem.html): A use context assigned to the code system
11838* [CompartmentDefinition](compartmentdefinition.html): A use context assigned to the compartment definition
11839* [ConceptMap](conceptmap.html): A use context assigned to the concept map
11840* [ConditionDefinition](conditiondefinition.html): A use context assigned to the condition definition
11841* [EventDefinition](eventdefinition.html): A use context assigned to the event definition
11842* [Evidence](evidence.html): A use context assigned to the evidence
11843* [EvidenceReport](evidencereport.html): A use context assigned to the evidence report
11844* [EvidenceVariable](evidencevariable.html): A use context assigned to the evidence variable
11845* [ExampleScenario](examplescenario.html): A use context assigned to the example scenario
11846* [GraphDefinition](graphdefinition.html): A use context assigned to the graph definition
11847* [ImplementationGuide](implementationguide.html): A use context assigned to the implementation guide
11848* [Library](library.html): A use context assigned to the library
11849* [Measure](measure.html): A use context assigned to the measure
11850* [MessageDefinition](messagedefinition.html): A use context assigned to the message definition
11851* [NamingSystem](namingsystem.html): A use context assigned to the naming system
11852* [OperationDefinition](operationdefinition.html): A use context assigned to the operation definition
11853* [PlanDefinition](plandefinition.html): A use context assigned to the plan definition
11854* [Questionnaire](questionnaire.html): A use context assigned to the questionnaire
11855* [Requirements](requirements.html): A use context assigned to the requirements
11856* [SearchParameter](searchparameter.html): A use context assigned to the search parameter
11857* [StructureDefinition](structuredefinition.html): A use context assigned to the structure definition
11858* [StructureMap](structuremap.html): A use context assigned to the structure map
11859* [TerminologyCapabilities](terminologycapabilities.html): A use context assigned to the terminology capabilities
11860* [TestScript](testscript.html): A use context assigned to the test script
11861* [ValueSet](valueset.html): A use context assigned to the value set
11862</b><br>
11863   * Type: <b>token</b><br>
11864   * Path: <b>(ActivityDefinition.useContext.value.ofType(CodeableConcept)) | (ActorDefinition.useContext.value.ofType(CodeableConcept)) | (CapabilityStatement.useContext.value.ofType(CodeableConcept)) | (ChargeItemDefinition.useContext.value.ofType(CodeableConcept)) | (Citation.useContext.value.ofType(CodeableConcept)) | (CodeSystem.useContext.value.ofType(CodeableConcept)) | (CompartmentDefinition.useContext.value.ofType(CodeableConcept)) | (ConceptMap.useContext.value.ofType(CodeableConcept)) | (ConditionDefinition.useContext.value.ofType(CodeableConcept)) | (EventDefinition.useContext.value.ofType(CodeableConcept)) | (Evidence.useContext.value.ofType(CodeableConcept)) | (EvidenceReport.useContext.value.ofType(CodeableConcept)) | (EvidenceVariable.useContext.value.ofType(CodeableConcept)) | (ExampleScenario.useContext.value.ofType(CodeableConcept)) | (GraphDefinition.useContext.value.ofType(CodeableConcept)) | (ImplementationGuide.useContext.value.ofType(CodeableConcept)) | (Library.useContext.value.ofType(CodeableConcept)) | (Measure.useContext.value.ofType(CodeableConcept)) | (MessageDefinition.useContext.value.ofType(CodeableConcept)) | (NamingSystem.useContext.value.ofType(CodeableConcept)) | (OperationDefinition.useContext.value.ofType(CodeableConcept)) | (PlanDefinition.useContext.value.ofType(CodeableConcept)) | (Questionnaire.useContext.value.ofType(CodeableConcept)) | (Requirements.useContext.value.ofType(CodeableConcept)) | (SearchParameter.useContext.value.ofType(CodeableConcept)) | (StructureDefinition.useContext.value.ofType(CodeableConcept)) | (StructureMap.useContext.value.ofType(CodeableConcept)) | (TerminologyCapabilities.useContext.value.ofType(CodeableConcept)) | (TestScript.useContext.value.ofType(CodeableConcept)) | (ValueSet.useContext.value.ofType(CodeableConcept))</b><br>
11865   * </p>
11866   */
11867  @SearchParamDefinition(name="context", path="(ActivityDefinition.useContext.value.ofType(CodeableConcept)) | (ActorDefinition.useContext.value.ofType(CodeableConcept)) | (CapabilityStatement.useContext.value.ofType(CodeableConcept)) | (ChargeItemDefinition.useContext.value.ofType(CodeableConcept)) | (Citation.useContext.value.ofType(CodeableConcept)) | (CodeSystem.useContext.value.ofType(CodeableConcept)) | (CompartmentDefinition.useContext.value.ofType(CodeableConcept)) | (ConceptMap.useContext.value.ofType(CodeableConcept)) | (ConditionDefinition.useContext.value.ofType(CodeableConcept)) | (EventDefinition.useContext.value.ofType(CodeableConcept)) | (Evidence.useContext.value.ofType(CodeableConcept)) | (EvidenceReport.useContext.value.ofType(CodeableConcept)) | (EvidenceVariable.useContext.value.ofType(CodeableConcept)) | (ExampleScenario.useContext.value.ofType(CodeableConcept)) | (GraphDefinition.useContext.value.ofType(CodeableConcept)) | (ImplementationGuide.useContext.value.ofType(CodeableConcept)) | (Library.useContext.value.ofType(CodeableConcept)) | (Measure.useContext.value.ofType(CodeableConcept)) | (MessageDefinition.useContext.value.ofType(CodeableConcept)) | (NamingSystem.useContext.value.ofType(CodeableConcept)) | (OperationDefinition.useContext.value.ofType(CodeableConcept)) | (PlanDefinition.useContext.value.ofType(CodeableConcept)) | (Questionnaire.useContext.value.ofType(CodeableConcept)) | (Requirements.useContext.value.ofType(CodeableConcept)) | (SearchParameter.useContext.value.ofType(CodeableConcept)) | (StructureDefinition.useContext.value.ofType(CodeableConcept)) | (StructureMap.useContext.value.ofType(CodeableConcept)) | (TerminologyCapabilities.useContext.value.ofType(CodeableConcept)) | (TestScript.useContext.value.ofType(CodeableConcept)) | (ValueSet.useContext.value.ofType(CodeableConcept))", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): A use context assigned to the activity definition\r\n* [ActorDefinition](actordefinition.html): A use context assigned to the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): A use context assigned to the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): A use context assigned to the charge item definition\r\n* [Citation](citation.html): A use context assigned to the citation\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* [ConditionDefinition](conditiondefinition.html): A use context assigned to the condition definition\r\n* [EventDefinition](eventdefinition.html): A use context assigned to the event definition\r\n* [Evidence](evidence.html): A use context assigned to the evidence\r\n* [EvidenceReport](evidencereport.html): A use context assigned to the evidence report\r\n* [EvidenceVariable](evidencevariable.html): A use context assigned to the evidence variable\r\n* [ExampleScenario](examplescenario.html): A use context assigned to the example scenario\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* [Library](library.html): A use context assigned to the library\r\n* [Measure](measure.html): A use context assigned to the measure\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* [PlanDefinition](plandefinition.html): A use context assigned to the plan definition\r\n* [Questionnaire](questionnaire.html): A use context assigned to the questionnaire\r\n* [Requirements](requirements.html): A use context assigned to the requirements\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* [TestScript](testscript.html): A use context assigned to the test script\r\n* [ValueSet](valueset.html): A use context assigned to the value set\r\n", type="token" )
11868  public static final String SP_CONTEXT = "context";
11869 /**
11870   * <b>Fluent Client</b> search parameter constant for <b>context</b>
11871   * <p>
11872   * Description: <b>Multiple Resources: 
11873
11874* [ActivityDefinition](activitydefinition.html): A use context assigned to the activity definition
11875* [ActorDefinition](actordefinition.html): A use context assigned to the Actor Definition
11876* [CapabilityStatement](capabilitystatement.html): A use context assigned to the capability statement
11877* [ChargeItemDefinition](chargeitemdefinition.html): A use context assigned to the charge item definition
11878* [Citation](citation.html): A use context assigned to the citation
11879* [CodeSystem](codesystem.html): A use context assigned to the code system
11880* [CompartmentDefinition](compartmentdefinition.html): A use context assigned to the compartment definition
11881* [ConceptMap](conceptmap.html): A use context assigned to the concept map
11882* [ConditionDefinition](conditiondefinition.html): A use context assigned to the condition definition
11883* [EventDefinition](eventdefinition.html): A use context assigned to the event definition
11884* [Evidence](evidence.html): A use context assigned to the evidence
11885* [EvidenceReport](evidencereport.html): A use context assigned to the evidence report
11886* [EvidenceVariable](evidencevariable.html): A use context assigned to the evidence variable
11887* [ExampleScenario](examplescenario.html): A use context assigned to the example scenario
11888* [GraphDefinition](graphdefinition.html): A use context assigned to the graph definition
11889* [ImplementationGuide](implementationguide.html): A use context assigned to the implementation guide
11890* [Library](library.html): A use context assigned to the library
11891* [Measure](measure.html): A use context assigned to the measure
11892* [MessageDefinition](messagedefinition.html): A use context assigned to the message definition
11893* [NamingSystem](namingsystem.html): A use context assigned to the naming system
11894* [OperationDefinition](operationdefinition.html): A use context assigned to the operation definition
11895* [PlanDefinition](plandefinition.html): A use context assigned to the plan definition
11896* [Questionnaire](questionnaire.html): A use context assigned to the questionnaire
11897* [Requirements](requirements.html): A use context assigned to the requirements
11898* [SearchParameter](searchparameter.html): A use context assigned to the search parameter
11899* [StructureDefinition](structuredefinition.html): A use context assigned to the structure definition
11900* [StructureMap](structuremap.html): A use context assigned to the structure map
11901* [TerminologyCapabilities](terminologycapabilities.html): A use context assigned to the terminology capabilities
11902* [TestScript](testscript.html): A use context assigned to the test script
11903* [ValueSet](valueset.html): A use context assigned to the value set
11904</b><br>
11905   * Type: <b>token</b><br>
11906   * Path: <b>(ActivityDefinition.useContext.value.ofType(CodeableConcept)) | (ActorDefinition.useContext.value.ofType(CodeableConcept)) | (CapabilityStatement.useContext.value.ofType(CodeableConcept)) | (ChargeItemDefinition.useContext.value.ofType(CodeableConcept)) | (Citation.useContext.value.ofType(CodeableConcept)) | (CodeSystem.useContext.value.ofType(CodeableConcept)) | (CompartmentDefinition.useContext.value.ofType(CodeableConcept)) | (ConceptMap.useContext.value.ofType(CodeableConcept)) | (ConditionDefinition.useContext.value.ofType(CodeableConcept)) | (EventDefinition.useContext.value.ofType(CodeableConcept)) | (Evidence.useContext.value.ofType(CodeableConcept)) | (EvidenceReport.useContext.value.ofType(CodeableConcept)) | (EvidenceVariable.useContext.value.ofType(CodeableConcept)) | (ExampleScenario.useContext.value.ofType(CodeableConcept)) | (GraphDefinition.useContext.value.ofType(CodeableConcept)) | (ImplementationGuide.useContext.value.ofType(CodeableConcept)) | (Library.useContext.value.ofType(CodeableConcept)) | (Measure.useContext.value.ofType(CodeableConcept)) | (MessageDefinition.useContext.value.ofType(CodeableConcept)) | (NamingSystem.useContext.value.ofType(CodeableConcept)) | (OperationDefinition.useContext.value.ofType(CodeableConcept)) | (PlanDefinition.useContext.value.ofType(CodeableConcept)) | (Questionnaire.useContext.value.ofType(CodeableConcept)) | (Requirements.useContext.value.ofType(CodeableConcept)) | (SearchParameter.useContext.value.ofType(CodeableConcept)) | (StructureDefinition.useContext.value.ofType(CodeableConcept)) | (StructureMap.useContext.value.ofType(CodeableConcept)) | (TerminologyCapabilities.useContext.value.ofType(CodeableConcept)) | (TestScript.useContext.value.ofType(CodeableConcept)) | (ValueSet.useContext.value.ofType(CodeableConcept))</b><br>
11907   * </p>
11908   */
11909  public static final ca.uhn.fhir.rest.gclient.TokenClientParam CONTEXT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_CONTEXT);
11910
11911 /**
11912   * Search parameter: <b>date</b>
11913   * <p>
11914   * Description: <b>Multiple Resources: 
11915
11916* [ActivityDefinition](activitydefinition.html): The activity definition publication date
11917* [ActorDefinition](actordefinition.html): The Actor Definition publication date
11918* [CapabilityStatement](capabilitystatement.html): The capability statement publication date
11919* [ChargeItemDefinition](chargeitemdefinition.html): The charge item definition publication date
11920* [Citation](citation.html): The citation publication date
11921* [CodeSystem](codesystem.html): The code system publication date
11922* [CompartmentDefinition](compartmentdefinition.html): The compartment definition publication date
11923* [ConceptMap](conceptmap.html): The concept map publication date
11924* [ConditionDefinition](conditiondefinition.html): The condition definition publication date
11925* [EventDefinition](eventdefinition.html): The event definition publication date
11926* [Evidence](evidence.html): The evidence publication date
11927* [EvidenceVariable](evidencevariable.html): The evidence variable publication date
11928* [ExampleScenario](examplescenario.html): The example scenario publication date
11929* [GraphDefinition](graphdefinition.html): The graph definition publication date
11930* [ImplementationGuide](implementationguide.html): The implementation guide publication date
11931* [Library](library.html): The library publication date
11932* [Measure](measure.html): The measure publication date
11933* [MessageDefinition](messagedefinition.html): The message definition publication date
11934* [NamingSystem](namingsystem.html): The naming system publication date
11935* [OperationDefinition](operationdefinition.html): The operation definition publication date
11936* [PlanDefinition](plandefinition.html): The plan definition publication date
11937* [Questionnaire](questionnaire.html): The questionnaire publication date
11938* [Requirements](requirements.html): The requirements publication date
11939* [SearchParameter](searchparameter.html): The search parameter publication date
11940* [StructureDefinition](structuredefinition.html): The structure definition publication date
11941* [StructureMap](structuremap.html): The structure map publication date
11942* [SubscriptionTopic](subscriptiontopic.html): Date status first applied
11943* [TerminologyCapabilities](terminologycapabilities.html): The terminology capabilities publication date
11944* [TestScript](testscript.html): The test script publication date
11945* [ValueSet](valueset.html): The value set publication date
11946</b><br>
11947   * Type: <b>date</b><br>
11948   * Path: <b>ActivityDefinition.date | ActorDefinition.date | CapabilityStatement.date | ChargeItemDefinition.date | Citation.date | CodeSystem.date | CompartmentDefinition.date | ConceptMap.date | ConditionDefinition.date | EventDefinition.date | Evidence.date | EvidenceVariable.date | ExampleScenario.date | GraphDefinition.date | ImplementationGuide.date | Library.date | Measure.date | MessageDefinition.date | NamingSystem.date | OperationDefinition.date | PlanDefinition.date | Questionnaire.date | Requirements.date | SearchParameter.date | StructureDefinition.date | StructureMap.date | SubscriptionTopic.date | TerminologyCapabilities.date | TestScript.date | ValueSet.date</b><br>
11949   * </p>
11950   */
11951  @SearchParamDefinition(name="date", path="ActivityDefinition.date | ActorDefinition.date | CapabilityStatement.date | ChargeItemDefinition.date | Citation.date | CodeSystem.date | CompartmentDefinition.date | ConceptMap.date | ConditionDefinition.date | EventDefinition.date | Evidence.date | EvidenceVariable.date | ExampleScenario.date | GraphDefinition.date | ImplementationGuide.date | Library.date | Measure.date | MessageDefinition.date | NamingSystem.date | OperationDefinition.date | PlanDefinition.date | Questionnaire.date | Requirements.date | SearchParameter.date | StructureDefinition.date | StructureMap.date | SubscriptionTopic.date | TerminologyCapabilities.date | TestScript.date | ValueSet.date", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): The activity definition publication date\r\n* [ActorDefinition](actordefinition.html): The Actor Definition publication date\r\n* [CapabilityStatement](capabilitystatement.html): The capability statement publication date\r\n* [ChargeItemDefinition](chargeitemdefinition.html): The charge item definition publication date\r\n* [Citation](citation.html): The citation 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* [ConditionDefinition](conditiondefinition.html): The condition definition publication date\r\n* [EventDefinition](eventdefinition.html): The event definition publication date\r\n* [Evidence](evidence.html): The evidence publication date\r\n* [EvidenceVariable](evidencevariable.html): The evidence variable publication date\r\n* [ExampleScenario](examplescenario.html): The example scenario publication date\r\n* [GraphDefinition](graphdefinition.html): The graph definition publication date\r\n* [ImplementationGuide](implementationguide.html): The implementation guide publication date\r\n* [Library](library.html): The library publication date\r\n* [Measure](measure.html): The measure 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* [PlanDefinition](plandefinition.html): The plan definition publication date\r\n* [Questionnaire](questionnaire.html): The questionnaire publication date\r\n* [Requirements](requirements.html): The requirements 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* [SubscriptionTopic](subscriptiontopic.html): Date status first applied\r\n* [TerminologyCapabilities](terminologycapabilities.html): The terminology capabilities publication date\r\n* [TestScript](testscript.html): The test script publication date\r\n* [ValueSet](valueset.html): The value set publication date\r\n", type="date" )
11952  public static final String SP_DATE = "date";
11953 /**
11954   * <b>Fluent Client</b> search parameter constant for <b>date</b>
11955   * <p>
11956   * Description: <b>Multiple Resources: 
11957
11958* [ActivityDefinition](activitydefinition.html): The activity definition publication date
11959* [ActorDefinition](actordefinition.html): The Actor Definition publication date
11960* [CapabilityStatement](capabilitystatement.html): The capability statement publication date
11961* [ChargeItemDefinition](chargeitemdefinition.html): The charge item definition publication date
11962* [Citation](citation.html): The citation publication date
11963* [CodeSystem](codesystem.html): The code system publication date
11964* [CompartmentDefinition](compartmentdefinition.html): The compartment definition publication date
11965* [ConceptMap](conceptmap.html): The concept map publication date
11966* [ConditionDefinition](conditiondefinition.html): The condition definition publication date
11967* [EventDefinition](eventdefinition.html): The event definition publication date
11968* [Evidence](evidence.html): The evidence publication date
11969* [EvidenceVariable](evidencevariable.html): The evidence variable publication date
11970* [ExampleScenario](examplescenario.html): The example scenario publication date
11971* [GraphDefinition](graphdefinition.html): The graph definition publication date
11972* [ImplementationGuide](implementationguide.html): The implementation guide publication date
11973* [Library](library.html): The library publication date
11974* [Measure](measure.html): The measure publication date
11975* [MessageDefinition](messagedefinition.html): The message definition publication date
11976* [NamingSystem](namingsystem.html): The naming system publication date
11977* [OperationDefinition](operationdefinition.html): The operation definition publication date
11978* [PlanDefinition](plandefinition.html): The plan definition publication date
11979* [Questionnaire](questionnaire.html): The questionnaire publication date
11980* [Requirements](requirements.html): The requirements publication date
11981* [SearchParameter](searchparameter.html): The search parameter publication date
11982* [StructureDefinition](structuredefinition.html): The structure definition publication date
11983* [StructureMap](structuremap.html): The structure map publication date
11984* [SubscriptionTopic](subscriptiontopic.html): Date status first applied
11985* [TerminologyCapabilities](terminologycapabilities.html): The terminology capabilities publication date
11986* [TestScript](testscript.html): The test script publication date
11987* [ValueSet](valueset.html): The value set publication date
11988</b><br>
11989   * Type: <b>date</b><br>
11990   * Path: <b>ActivityDefinition.date | ActorDefinition.date | CapabilityStatement.date | ChargeItemDefinition.date | Citation.date | CodeSystem.date | CompartmentDefinition.date | ConceptMap.date | ConditionDefinition.date | EventDefinition.date | Evidence.date | EvidenceVariable.date | ExampleScenario.date | GraphDefinition.date | ImplementationGuide.date | Library.date | Measure.date | MessageDefinition.date | NamingSystem.date | OperationDefinition.date | PlanDefinition.date | Questionnaire.date | Requirements.date | SearchParameter.date | StructureDefinition.date | StructureMap.date | SubscriptionTopic.date | TerminologyCapabilities.date | TestScript.date | ValueSet.date</b><br>
11991   * </p>
11992   */
11993  public static final ca.uhn.fhir.rest.gclient.DateClientParam DATE = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_DATE);
11994
11995 /**
11996   * Search parameter: <b>description</b>
11997   * <p>
11998   * Description: <b>Multiple Resources: 
11999
12000* [ActivityDefinition](activitydefinition.html): The description of the activity definition
12001* [ActorDefinition](actordefinition.html): The description of the Actor Definition
12002* [CapabilityStatement](capabilitystatement.html): The description of the capability statement
12003* [ChargeItemDefinition](chargeitemdefinition.html): The description of the charge item definition
12004* [Citation](citation.html): The description of the citation
12005* [CodeSystem](codesystem.html): The description of the code system
12006* [CompartmentDefinition](compartmentdefinition.html): The description of the compartment definition
12007* [ConceptMap](conceptmap.html): The description of the concept map
12008* [ConditionDefinition](conditiondefinition.html): The description of the condition definition
12009* [EventDefinition](eventdefinition.html): The description of the event definition
12010* [Evidence](evidence.html): The description of the evidence
12011* [EvidenceVariable](evidencevariable.html): The description of the evidence variable
12012* [GraphDefinition](graphdefinition.html): The description of the graph definition
12013* [ImplementationGuide](implementationguide.html): The description of the implementation guide
12014* [Library](library.html): The description of the library
12015* [Measure](measure.html): The description of the measure
12016* [MessageDefinition](messagedefinition.html): The description of the message definition
12017* [NamingSystem](namingsystem.html): The description of the naming system
12018* [OperationDefinition](operationdefinition.html): The description of the operation definition
12019* [PlanDefinition](plandefinition.html): The description of the plan definition
12020* [Questionnaire](questionnaire.html): The description of the questionnaire
12021* [Requirements](requirements.html): The description of the requirements
12022* [SearchParameter](searchparameter.html): The description of the search parameter
12023* [StructureDefinition](structuredefinition.html): The description of the structure definition
12024* [StructureMap](structuremap.html): The description of the structure map
12025* [TerminologyCapabilities](terminologycapabilities.html): The description of the terminology capabilities
12026* [TestScript](testscript.html): The description of the test script
12027* [ValueSet](valueset.html): The description of the value set
12028</b><br>
12029   * Type: <b>string</b><br>
12030   * Path: <b>ActivityDefinition.description | ActorDefinition.description | CapabilityStatement.description | ChargeItemDefinition.description | Citation.description | CodeSystem.description | CompartmentDefinition.description | ConceptMap.description | ConditionDefinition.description | EventDefinition.description | Evidence.description | EvidenceVariable.description | GraphDefinition.description | ImplementationGuide.description | Library.description | Measure.description | MessageDefinition.description | NamingSystem.description | OperationDefinition.description | PlanDefinition.description | Questionnaire.description | Requirements.description | SearchParameter.description | StructureDefinition.description | StructureMap.description | TerminologyCapabilities.description | TestScript.description | ValueSet.description</b><br>
12031   * </p>
12032   */
12033  @SearchParamDefinition(name="description", path="ActivityDefinition.description | ActorDefinition.description | CapabilityStatement.description | ChargeItemDefinition.description | Citation.description | CodeSystem.description | CompartmentDefinition.description | ConceptMap.description | ConditionDefinition.description | EventDefinition.description | Evidence.description | EvidenceVariable.description | GraphDefinition.description | ImplementationGuide.description | Library.description | Measure.description | MessageDefinition.description | NamingSystem.description | OperationDefinition.description | PlanDefinition.description | Questionnaire.description | Requirements.description | SearchParameter.description | StructureDefinition.description | StructureMap.description | TerminologyCapabilities.description | TestScript.description | ValueSet.description", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): The description of the activity definition\r\n* [ActorDefinition](actordefinition.html): The description of the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): The description of the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): The description of the charge item definition\r\n* [Citation](citation.html): The description of the citation\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* [ConditionDefinition](conditiondefinition.html): The description of the condition definition\r\n* [EventDefinition](eventdefinition.html): The description of the event definition\r\n* [Evidence](evidence.html): The description of the evidence\r\n* [EvidenceVariable](evidencevariable.html): The description of the evidence variable\r\n* [GraphDefinition](graphdefinition.html): The description of the graph definition\r\n* [ImplementationGuide](implementationguide.html): The description of the implementation guide\r\n* [Library](library.html): The description of the library\r\n* [Measure](measure.html): The description of the measure\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* [PlanDefinition](plandefinition.html): The description of the plan definition\r\n* [Questionnaire](questionnaire.html): The description of the questionnaire\r\n* [Requirements](requirements.html): The description of the requirements\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* [TestScript](testscript.html): The description of the test script\r\n* [ValueSet](valueset.html): The description of the value set\r\n", type="string" )
12034  public static final String SP_DESCRIPTION = "description";
12035 /**
12036   * <b>Fluent Client</b> search parameter constant for <b>description</b>
12037   * <p>
12038   * Description: <b>Multiple Resources: 
12039
12040* [ActivityDefinition](activitydefinition.html): The description of the activity definition
12041* [ActorDefinition](actordefinition.html): The description of the Actor Definition
12042* [CapabilityStatement](capabilitystatement.html): The description of the capability statement
12043* [ChargeItemDefinition](chargeitemdefinition.html): The description of the charge item definition
12044* [Citation](citation.html): The description of the citation
12045* [CodeSystem](codesystem.html): The description of the code system
12046* [CompartmentDefinition](compartmentdefinition.html): The description of the compartment definition
12047* [ConceptMap](conceptmap.html): The description of the concept map
12048* [ConditionDefinition](conditiondefinition.html): The description of the condition definition
12049* [EventDefinition](eventdefinition.html): The description of the event definition
12050* [Evidence](evidence.html): The description of the evidence
12051* [EvidenceVariable](evidencevariable.html): The description of the evidence variable
12052* [GraphDefinition](graphdefinition.html): The description of the graph definition
12053* [ImplementationGuide](implementationguide.html): The description of the implementation guide
12054* [Library](library.html): The description of the library
12055* [Measure](measure.html): The description of the measure
12056* [MessageDefinition](messagedefinition.html): The description of the message definition
12057* [NamingSystem](namingsystem.html): The description of the naming system
12058* [OperationDefinition](operationdefinition.html): The description of the operation definition
12059* [PlanDefinition](plandefinition.html): The description of the plan definition
12060* [Questionnaire](questionnaire.html): The description of the questionnaire
12061* [Requirements](requirements.html): The description of the requirements
12062* [SearchParameter](searchparameter.html): The description of the search parameter
12063* [StructureDefinition](structuredefinition.html): The description of the structure definition
12064* [StructureMap](structuremap.html): The description of the structure map
12065* [TerminologyCapabilities](terminologycapabilities.html): The description of the terminology capabilities
12066* [TestScript](testscript.html): The description of the test script
12067* [ValueSet](valueset.html): The description of the value set
12068</b><br>
12069   * Type: <b>string</b><br>
12070   * Path: <b>ActivityDefinition.description | ActorDefinition.description | CapabilityStatement.description | ChargeItemDefinition.description | Citation.description | CodeSystem.description | CompartmentDefinition.description | ConceptMap.description | ConditionDefinition.description | EventDefinition.description | Evidence.description | EvidenceVariable.description | GraphDefinition.description | ImplementationGuide.description | Library.description | Measure.description | MessageDefinition.description | NamingSystem.description | OperationDefinition.description | PlanDefinition.description | Questionnaire.description | Requirements.description | SearchParameter.description | StructureDefinition.description | StructureMap.description | TerminologyCapabilities.description | TestScript.description | ValueSet.description</b><br>
12071   * </p>
12072   */
12073  public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_DESCRIPTION);
12074
12075 /**
12076   * Search parameter: <b>identifier</b>
12077   * <p>
12078   * Description: <b>Multiple Resources: 
12079
12080* [ActivityDefinition](activitydefinition.html): External identifier for the activity definition
12081* [ActorDefinition](actordefinition.html): External identifier for the Actor Definition
12082* [CapabilityStatement](capabilitystatement.html): External identifier for the capability statement
12083* [ChargeItemDefinition](chargeitemdefinition.html): External identifier for the charge item definition
12084* [Citation](citation.html): External identifier for the citation
12085* [CodeSystem](codesystem.html): External identifier for the code system
12086* [ConceptMap](conceptmap.html): External identifier for the concept map
12087* [ConditionDefinition](conditiondefinition.html): External identifier for the condition definition
12088* [EventDefinition](eventdefinition.html): External identifier for the event definition
12089* [Evidence](evidence.html): External identifier for the evidence
12090* [EvidenceReport](evidencereport.html): External identifier for the evidence report
12091* [EvidenceVariable](evidencevariable.html): External identifier for the evidence variable
12092* [ExampleScenario](examplescenario.html): External identifier for the example scenario
12093* [GraphDefinition](graphdefinition.html): External identifier for the graph definition
12094* [ImplementationGuide](implementationguide.html): External identifier for the implementation guide
12095* [Library](library.html): External identifier for the library
12096* [Measure](measure.html): External identifier for the measure
12097* [MedicationKnowledge](medicationknowledge.html): Business identifier for this medication
12098* [MessageDefinition](messagedefinition.html): External identifier for the message definition
12099* [NamingSystem](namingsystem.html): External identifier for the naming system
12100* [ObservationDefinition](observationdefinition.html): The unique identifier associated with the specimen definition
12101* [OperationDefinition](operationdefinition.html): External identifier for the search parameter
12102* [PlanDefinition](plandefinition.html): External identifier for the plan definition
12103* [Questionnaire](questionnaire.html): External identifier for the questionnaire
12104* [Requirements](requirements.html): External identifier for the requirements
12105* [SearchParameter](searchparameter.html): External identifier for the search parameter
12106* [SpecimenDefinition](specimendefinition.html): The unique identifier associated with the SpecimenDefinition
12107* [StructureDefinition](structuredefinition.html): External identifier for the structure definition
12108* [StructureMap](structuremap.html): External identifier for the structure map
12109* [SubscriptionTopic](subscriptiontopic.html): Business Identifier for SubscriptionTopic
12110* [TerminologyCapabilities](terminologycapabilities.html): External identifier for the terminology capabilities
12111* [TestPlan](testplan.html): An identifier for the test plan
12112* [TestScript](testscript.html): External identifier for the test script
12113* [ValueSet](valueset.html): External identifier for the value set
12114</b><br>
12115   * Type: <b>token</b><br>
12116   * Path: <b>ActivityDefinition.identifier | ActorDefinition.identifier | CapabilityStatement.identifier | ChargeItemDefinition.identifier | Citation.identifier | CodeSystem.identifier | ConceptMap.identifier | ConditionDefinition.identifier | EventDefinition.identifier | Evidence.identifier | EvidenceReport.identifier | EvidenceVariable.identifier | ExampleScenario.identifier | GraphDefinition.identifier | ImplementationGuide.identifier | Library.identifier | Measure.identifier | MedicationKnowledge.identifier | MessageDefinition.identifier | NamingSystem.identifier | ObservationDefinition.identifier | OperationDefinition.identifier | PlanDefinition.identifier | Questionnaire.identifier | Requirements.identifier | SearchParameter.identifier | SpecimenDefinition.identifier | StructureDefinition.identifier | StructureMap.identifier | SubscriptionTopic.identifier | TerminologyCapabilities.identifier | TestPlan.identifier | TestScript.identifier | ValueSet.identifier</b><br>
12117   * </p>
12118   */
12119  @SearchParamDefinition(name="identifier", path="ActivityDefinition.identifier | ActorDefinition.identifier | CapabilityStatement.identifier | ChargeItemDefinition.identifier | Citation.identifier | CodeSystem.identifier | ConceptMap.identifier | ConditionDefinition.identifier | EventDefinition.identifier | Evidence.identifier | EvidenceReport.identifier | EvidenceVariable.identifier | ExampleScenario.identifier | GraphDefinition.identifier | ImplementationGuide.identifier | Library.identifier | Measure.identifier | MedicationKnowledge.identifier | MessageDefinition.identifier | NamingSystem.identifier | ObservationDefinition.identifier | OperationDefinition.identifier | PlanDefinition.identifier | Questionnaire.identifier | Requirements.identifier | SearchParameter.identifier | SpecimenDefinition.identifier | StructureDefinition.identifier | StructureMap.identifier | SubscriptionTopic.identifier | TerminologyCapabilities.identifier | TestPlan.identifier | TestScript.identifier | ValueSet.identifier", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): External identifier for the activity definition\r\n* [ActorDefinition](actordefinition.html): External identifier for the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): External identifier for the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): External identifier for the charge item definition\r\n* [Citation](citation.html): External identifier for the citation\r\n* [CodeSystem](codesystem.html): External identifier for the code system\r\n* [ConceptMap](conceptmap.html): External identifier for the concept map\r\n* [ConditionDefinition](conditiondefinition.html): External identifier for the condition definition\r\n* [EventDefinition](eventdefinition.html): External identifier for the event definition\r\n* [Evidence](evidence.html): External identifier for the evidence\r\n* [EvidenceReport](evidencereport.html): External identifier for the evidence report\r\n* [EvidenceVariable](evidencevariable.html): External identifier for the evidence variable\r\n* [ExampleScenario](examplescenario.html): External identifier for the example scenario\r\n* [GraphDefinition](graphdefinition.html): External identifier for the graph definition\r\n* [ImplementationGuide](implementationguide.html): External identifier for the implementation guide\r\n* [Library](library.html): External identifier for the library\r\n* [Measure](measure.html): External identifier for the measure\r\n* [MedicationKnowledge](medicationknowledge.html): Business identifier for this medication\r\n* [MessageDefinition](messagedefinition.html): External identifier for the message definition\r\n* [NamingSystem](namingsystem.html): External identifier for the naming system\r\n* [ObservationDefinition](observationdefinition.html): The unique identifier associated with the specimen definition\r\n* [OperationDefinition](operationdefinition.html): External identifier for the search parameter\r\n* [PlanDefinition](plandefinition.html): External identifier for the plan definition\r\n* [Questionnaire](questionnaire.html): External identifier for the questionnaire\r\n* [Requirements](requirements.html): External identifier for the requirements\r\n* [SearchParameter](searchparameter.html): External identifier for the search parameter\r\n* [SpecimenDefinition](specimendefinition.html): The unique identifier associated with the SpecimenDefinition\r\n* [StructureDefinition](structuredefinition.html): External identifier for the structure definition\r\n* [StructureMap](structuremap.html): External identifier for the structure map\r\n* [SubscriptionTopic](subscriptiontopic.html): Business Identifier for SubscriptionTopic\r\n* [TerminologyCapabilities](terminologycapabilities.html): External identifier for the terminology capabilities\r\n* [TestPlan](testplan.html): An identifier for the test plan\r\n* [TestScript](testscript.html): External identifier for the test script\r\n* [ValueSet](valueset.html): External identifier for the value set\r\n", type="token" )
12120  public static final String SP_IDENTIFIER = "identifier";
12121 /**
12122   * <b>Fluent Client</b> search parameter constant for <b>identifier</b>
12123   * <p>
12124   * Description: <b>Multiple Resources: 
12125
12126* [ActivityDefinition](activitydefinition.html): External identifier for the activity definition
12127* [ActorDefinition](actordefinition.html): External identifier for the Actor Definition
12128* [CapabilityStatement](capabilitystatement.html): External identifier for the capability statement
12129* [ChargeItemDefinition](chargeitemdefinition.html): External identifier for the charge item definition
12130* [Citation](citation.html): External identifier for the citation
12131* [CodeSystem](codesystem.html): External identifier for the code system
12132* [ConceptMap](conceptmap.html): External identifier for the concept map
12133* [ConditionDefinition](conditiondefinition.html): External identifier for the condition definition
12134* [EventDefinition](eventdefinition.html): External identifier for the event definition
12135* [Evidence](evidence.html): External identifier for the evidence
12136* [EvidenceReport](evidencereport.html): External identifier for the evidence report
12137* [EvidenceVariable](evidencevariable.html): External identifier for the evidence variable
12138* [ExampleScenario](examplescenario.html): External identifier for the example scenario
12139* [GraphDefinition](graphdefinition.html): External identifier for the graph definition
12140* [ImplementationGuide](implementationguide.html): External identifier for the implementation guide
12141* [Library](library.html): External identifier for the library
12142* [Measure](measure.html): External identifier for the measure
12143* [MedicationKnowledge](medicationknowledge.html): Business identifier for this medication
12144* [MessageDefinition](messagedefinition.html): External identifier for the message definition
12145* [NamingSystem](namingsystem.html): External identifier for the naming system
12146* [ObservationDefinition](observationdefinition.html): The unique identifier associated with the specimen definition
12147* [OperationDefinition](operationdefinition.html): External identifier for the search parameter
12148* [PlanDefinition](plandefinition.html): External identifier for the plan definition
12149* [Questionnaire](questionnaire.html): External identifier for the questionnaire
12150* [Requirements](requirements.html): External identifier for the requirements
12151* [SearchParameter](searchparameter.html): External identifier for the search parameter
12152* [SpecimenDefinition](specimendefinition.html): The unique identifier associated with the SpecimenDefinition
12153* [StructureDefinition](structuredefinition.html): External identifier for the structure definition
12154* [StructureMap](structuremap.html): External identifier for the structure map
12155* [SubscriptionTopic](subscriptiontopic.html): Business Identifier for SubscriptionTopic
12156* [TerminologyCapabilities](terminologycapabilities.html): External identifier for the terminology capabilities
12157* [TestPlan](testplan.html): An identifier for the test plan
12158* [TestScript](testscript.html): External identifier for the test script
12159* [ValueSet](valueset.html): External identifier for the value set
12160</b><br>
12161   * Type: <b>token</b><br>
12162   * Path: <b>ActivityDefinition.identifier | ActorDefinition.identifier | CapabilityStatement.identifier | ChargeItemDefinition.identifier | Citation.identifier | CodeSystem.identifier | ConceptMap.identifier | ConditionDefinition.identifier | EventDefinition.identifier | Evidence.identifier | EvidenceReport.identifier | EvidenceVariable.identifier | ExampleScenario.identifier | GraphDefinition.identifier | ImplementationGuide.identifier | Library.identifier | Measure.identifier | MedicationKnowledge.identifier | MessageDefinition.identifier | NamingSystem.identifier | ObservationDefinition.identifier | OperationDefinition.identifier | PlanDefinition.identifier | Questionnaire.identifier | Requirements.identifier | SearchParameter.identifier | SpecimenDefinition.identifier | StructureDefinition.identifier | StructureMap.identifier | SubscriptionTopic.identifier | TerminologyCapabilities.identifier | TestPlan.identifier | TestScript.identifier | ValueSet.identifier</b><br>
12163   * </p>
12164   */
12165  public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER);
12166
12167 /**
12168   * Search parameter: <b>jurisdiction</b>
12169   * <p>
12170   * Description: <b>Multiple Resources: 
12171
12172* [ActivityDefinition](activitydefinition.html): Intended jurisdiction for the activity definition
12173* [ActorDefinition](actordefinition.html): Intended jurisdiction for the Actor Definition
12174* [CapabilityStatement](capabilitystatement.html): Intended jurisdiction for the capability statement
12175* [ChargeItemDefinition](chargeitemdefinition.html): Intended jurisdiction for the charge item definition
12176* [Citation](citation.html): Intended jurisdiction for the citation
12177* [CodeSystem](codesystem.html): Intended jurisdiction for the code system
12178* [ConceptMap](conceptmap.html): Intended jurisdiction for the concept map
12179* [ConditionDefinition](conditiondefinition.html): Intended jurisdiction for the condition definition
12180* [EventDefinition](eventdefinition.html): Intended jurisdiction for the event definition
12181* [ExampleScenario](examplescenario.html): Intended jurisdiction for the example scenario
12182* [GraphDefinition](graphdefinition.html): Intended jurisdiction for the graph definition
12183* [ImplementationGuide](implementationguide.html): Intended jurisdiction for the implementation guide
12184* [Library](library.html): Intended jurisdiction for the library
12185* [Measure](measure.html): Intended jurisdiction for the measure
12186* [MessageDefinition](messagedefinition.html): Intended jurisdiction for the message definition
12187* [NamingSystem](namingsystem.html): Intended jurisdiction for the naming system
12188* [OperationDefinition](operationdefinition.html): Intended jurisdiction for the operation definition
12189* [PlanDefinition](plandefinition.html): Intended jurisdiction for the plan definition
12190* [Questionnaire](questionnaire.html): Intended jurisdiction for the questionnaire
12191* [Requirements](requirements.html): Intended jurisdiction for the requirements
12192* [SearchParameter](searchparameter.html): Intended jurisdiction for the search parameter
12193* [StructureDefinition](structuredefinition.html): Intended jurisdiction for the structure definition
12194* [StructureMap](structuremap.html): Intended jurisdiction for the structure map
12195* [TerminologyCapabilities](terminologycapabilities.html): Intended jurisdiction for the terminology capabilities
12196* [TestScript](testscript.html): Intended jurisdiction for the test script
12197* [ValueSet](valueset.html): Intended jurisdiction for the value set
12198</b><br>
12199   * Type: <b>token</b><br>
12200   * Path: <b>ActivityDefinition.jurisdiction | ActorDefinition.jurisdiction | CapabilityStatement.jurisdiction | ChargeItemDefinition.jurisdiction | Citation.jurisdiction | CodeSystem.jurisdiction | ConceptMap.jurisdiction | ConditionDefinition.jurisdiction | EventDefinition.jurisdiction | ExampleScenario.jurisdiction | GraphDefinition.jurisdiction | ImplementationGuide.jurisdiction | Library.jurisdiction | Measure.jurisdiction | MessageDefinition.jurisdiction | NamingSystem.jurisdiction | OperationDefinition.jurisdiction | PlanDefinition.jurisdiction | Questionnaire.jurisdiction | Requirements.jurisdiction | SearchParameter.jurisdiction | StructureDefinition.jurisdiction | StructureMap.jurisdiction | TerminologyCapabilities.jurisdiction | TestScript.jurisdiction | ValueSet.jurisdiction</b><br>
12201   * </p>
12202   */
12203  @SearchParamDefinition(name="jurisdiction", path="ActivityDefinition.jurisdiction | ActorDefinition.jurisdiction | CapabilityStatement.jurisdiction | ChargeItemDefinition.jurisdiction | Citation.jurisdiction | CodeSystem.jurisdiction | ConceptMap.jurisdiction | ConditionDefinition.jurisdiction | EventDefinition.jurisdiction | ExampleScenario.jurisdiction | GraphDefinition.jurisdiction | ImplementationGuide.jurisdiction | Library.jurisdiction | Measure.jurisdiction | MessageDefinition.jurisdiction | NamingSystem.jurisdiction | OperationDefinition.jurisdiction | PlanDefinition.jurisdiction | Questionnaire.jurisdiction | Requirements.jurisdiction | SearchParameter.jurisdiction | StructureDefinition.jurisdiction | StructureMap.jurisdiction | TerminologyCapabilities.jurisdiction | TestScript.jurisdiction | ValueSet.jurisdiction", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): Intended jurisdiction for the activity definition\r\n* [ActorDefinition](actordefinition.html): Intended jurisdiction for the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): Intended jurisdiction for the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): Intended jurisdiction for the charge item definition\r\n* [Citation](citation.html): Intended jurisdiction for the citation\r\n* [CodeSystem](codesystem.html): Intended jurisdiction for the code system\r\n* [ConceptMap](conceptmap.html): Intended jurisdiction for the concept map\r\n* [ConditionDefinition](conditiondefinition.html): Intended jurisdiction for the condition definition\r\n* [EventDefinition](eventdefinition.html): Intended jurisdiction for the event definition\r\n* [ExampleScenario](examplescenario.html): Intended jurisdiction for the example scenario\r\n* [GraphDefinition](graphdefinition.html): Intended jurisdiction for the graph definition\r\n* [ImplementationGuide](implementationguide.html): Intended jurisdiction for the implementation guide\r\n* [Library](library.html): Intended jurisdiction for the library\r\n* [Measure](measure.html): Intended jurisdiction for the measure\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* [PlanDefinition](plandefinition.html): Intended jurisdiction for the plan definition\r\n* [Questionnaire](questionnaire.html): Intended jurisdiction for the questionnaire\r\n* [Requirements](requirements.html): Intended jurisdiction for the requirements\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* [TestScript](testscript.html): Intended jurisdiction for the test script\r\n* [ValueSet](valueset.html): Intended jurisdiction for the value set\r\n", type="token" )
12204  public static final String SP_JURISDICTION = "jurisdiction";
12205 /**
12206   * <b>Fluent Client</b> search parameter constant for <b>jurisdiction</b>
12207   * <p>
12208   * Description: <b>Multiple Resources: 
12209
12210* [ActivityDefinition](activitydefinition.html): Intended jurisdiction for the activity definition
12211* [ActorDefinition](actordefinition.html): Intended jurisdiction for the Actor Definition
12212* [CapabilityStatement](capabilitystatement.html): Intended jurisdiction for the capability statement
12213* [ChargeItemDefinition](chargeitemdefinition.html): Intended jurisdiction for the charge item definition
12214* [Citation](citation.html): Intended jurisdiction for the citation
12215* [CodeSystem](codesystem.html): Intended jurisdiction for the code system
12216* [ConceptMap](conceptmap.html): Intended jurisdiction for the concept map
12217* [ConditionDefinition](conditiondefinition.html): Intended jurisdiction for the condition definition
12218* [EventDefinition](eventdefinition.html): Intended jurisdiction for the event definition
12219* [ExampleScenario](examplescenario.html): Intended jurisdiction for the example scenario
12220* [GraphDefinition](graphdefinition.html): Intended jurisdiction for the graph definition
12221* [ImplementationGuide](implementationguide.html): Intended jurisdiction for the implementation guide
12222* [Library](library.html): Intended jurisdiction for the library
12223* [Measure](measure.html): Intended jurisdiction for the measure
12224* [MessageDefinition](messagedefinition.html): Intended jurisdiction for the message definition
12225* [NamingSystem](namingsystem.html): Intended jurisdiction for the naming system
12226* [OperationDefinition](operationdefinition.html): Intended jurisdiction for the operation definition
12227* [PlanDefinition](plandefinition.html): Intended jurisdiction for the plan definition
12228* [Questionnaire](questionnaire.html): Intended jurisdiction for the questionnaire
12229* [Requirements](requirements.html): Intended jurisdiction for the requirements
12230* [SearchParameter](searchparameter.html): Intended jurisdiction for the search parameter
12231* [StructureDefinition](structuredefinition.html): Intended jurisdiction for the structure definition
12232* [StructureMap](structuremap.html): Intended jurisdiction for the structure map
12233* [TerminologyCapabilities](terminologycapabilities.html): Intended jurisdiction for the terminology capabilities
12234* [TestScript](testscript.html): Intended jurisdiction for the test script
12235* [ValueSet](valueset.html): Intended jurisdiction for the value set
12236</b><br>
12237   * Type: <b>token</b><br>
12238   * Path: <b>ActivityDefinition.jurisdiction | ActorDefinition.jurisdiction | CapabilityStatement.jurisdiction | ChargeItemDefinition.jurisdiction | Citation.jurisdiction | CodeSystem.jurisdiction | ConceptMap.jurisdiction | ConditionDefinition.jurisdiction | EventDefinition.jurisdiction | ExampleScenario.jurisdiction | GraphDefinition.jurisdiction | ImplementationGuide.jurisdiction | Library.jurisdiction | Measure.jurisdiction | MessageDefinition.jurisdiction | NamingSystem.jurisdiction | OperationDefinition.jurisdiction | PlanDefinition.jurisdiction | Questionnaire.jurisdiction | Requirements.jurisdiction | SearchParameter.jurisdiction | StructureDefinition.jurisdiction | StructureMap.jurisdiction | TerminologyCapabilities.jurisdiction | TestScript.jurisdiction | ValueSet.jurisdiction</b><br>
12239   * </p>
12240   */
12241  public static final ca.uhn.fhir.rest.gclient.TokenClientParam JURISDICTION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_JURISDICTION);
12242
12243 /**
12244   * Search parameter: <b>name</b>
12245   * <p>
12246   * Description: <b>Multiple Resources: 
12247
12248* [ActivityDefinition](activitydefinition.html): Computationally friendly name of the activity definition
12249* [CapabilityStatement](capabilitystatement.html): Computationally friendly name of the capability statement
12250* [Citation](citation.html): Computationally friendly name of the citation
12251* [CodeSystem](codesystem.html): Computationally friendly name of the code system
12252* [CompartmentDefinition](compartmentdefinition.html): Computationally friendly name of the compartment definition
12253* [ConceptMap](conceptmap.html): Computationally friendly name of the concept map
12254* [ConditionDefinition](conditiondefinition.html): Computationally friendly name of the condition definition
12255* [EventDefinition](eventdefinition.html): Computationally friendly name of the event definition
12256* [EvidenceVariable](evidencevariable.html): Computationally friendly name of the evidence variable
12257* [ExampleScenario](examplescenario.html): Computationally friendly name of the example scenario
12258* [GraphDefinition](graphdefinition.html): Computationally friendly name of the graph definition
12259* [ImplementationGuide](implementationguide.html): Computationally friendly name of the implementation guide
12260* [Library](library.html): Computationally friendly name of the library
12261* [Measure](measure.html): Computationally friendly name of the measure
12262* [MessageDefinition](messagedefinition.html): Computationally friendly name of the message definition
12263* [NamingSystem](namingsystem.html): Computationally friendly name of the naming system
12264* [OperationDefinition](operationdefinition.html): Computationally friendly name of the operation definition
12265* [PlanDefinition](plandefinition.html): Computationally friendly name of the plan definition
12266* [Questionnaire](questionnaire.html): Computationally friendly name of the questionnaire
12267* [Requirements](requirements.html): Computationally friendly name of the requirements
12268* [SearchParameter](searchparameter.html): Computationally friendly name of the search parameter
12269* [StructureDefinition](structuredefinition.html): Computationally friendly name of the structure definition
12270* [StructureMap](structuremap.html): Computationally friendly name of the structure map
12271* [TerminologyCapabilities](terminologycapabilities.html): Computationally friendly name of the terminology capabilities
12272* [TestScript](testscript.html): Computationally friendly name of the test script
12273* [ValueSet](valueset.html): Computationally friendly name of the value set
12274</b><br>
12275   * Type: <b>string</b><br>
12276   * Path: <b>ActivityDefinition.name | CapabilityStatement.name | Citation.name | CodeSystem.name | CompartmentDefinition.name | ConceptMap.name | ConditionDefinition.name | EventDefinition.name | EvidenceVariable.name | ExampleScenario.name | GraphDefinition.name | ImplementationGuide.name | Library.name | Measure.name | MessageDefinition.name | NamingSystem.name | OperationDefinition.name | PlanDefinition.name | Questionnaire.name | Requirements.name | SearchParameter.name | StructureDefinition.name | StructureMap.name | TerminologyCapabilities.name | TestScript.name | ValueSet.name</b><br>
12277   * </p>
12278   */
12279  @SearchParamDefinition(name="name", path="ActivityDefinition.name | CapabilityStatement.name | Citation.name | CodeSystem.name | CompartmentDefinition.name | ConceptMap.name | ConditionDefinition.name | EventDefinition.name | EvidenceVariable.name | ExampleScenario.name | GraphDefinition.name | ImplementationGuide.name | Library.name | Measure.name | MessageDefinition.name | NamingSystem.name | OperationDefinition.name | PlanDefinition.name | Questionnaire.name | Requirements.name | SearchParameter.name | StructureDefinition.name | StructureMap.name | TerminologyCapabilities.name | TestScript.name | ValueSet.name", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): Computationally friendly name of the activity definition\r\n* [CapabilityStatement](capabilitystatement.html): Computationally friendly name of the capability statement\r\n* [Citation](citation.html): Computationally friendly name of the citation\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* [ConditionDefinition](conditiondefinition.html): Computationally friendly name of the condition definition\r\n* [EventDefinition](eventdefinition.html): Computationally friendly name of the event definition\r\n* [EvidenceVariable](evidencevariable.html): Computationally friendly name of the evidence variable\r\n* [ExampleScenario](examplescenario.html): Computationally friendly name of the example scenario\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* [Library](library.html): Computationally friendly name of the library\r\n* [Measure](measure.html): Computationally friendly name of the measure\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* [PlanDefinition](plandefinition.html): Computationally friendly name of the plan definition\r\n* [Questionnaire](questionnaire.html): Computationally friendly name of the questionnaire\r\n* [Requirements](requirements.html): Computationally friendly name of the requirements\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* [TestScript](testscript.html): Computationally friendly name of the test script\r\n* [ValueSet](valueset.html): Computationally friendly name of the value set\r\n", type="string" )
12280  public static final String SP_NAME = "name";
12281 /**
12282   * <b>Fluent Client</b> search parameter constant for <b>name</b>
12283   * <p>
12284   * Description: <b>Multiple Resources: 
12285
12286* [ActivityDefinition](activitydefinition.html): Computationally friendly name of the activity definition
12287* [CapabilityStatement](capabilitystatement.html): Computationally friendly name of the capability statement
12288* [Citation](citation.html): Computationally friendly name of the citation
12289* [CodeSystem](codesystem.html): Computationally friendly name of the code system
12290* [CompartmentDefinition](compartmentdefinition.html): Computationally friendly name of the compartment definition
12291* [ConceptMap](conceptmap.html): Computationally friendly name of the concept map
12292* [ConditionDefinition](conditiondefinition.html): Computationally friendly name of the condition definition
12293* [EventDefinition](eventdefinition.html): Computationally friendly name of the event definition
12294* [EvidenceVariable](evidencevariable.html): Computationally friendly name of the evidence variable
12295* [ExampleScenario](examplescenario.html): Computationally friendly name of the example scenario
12296* [GraphDefinition](graphdefinition.html): Computationally friendly name of the graph definition
12297* [ImplementationGuide](implementationguide.html): Computationally friendly name of the implementation guide
12298* [Library](library.html): Computationally friendly name of the library
12299* [Measure](measure.html): Computationally friendly name of the measure
12300* [MessageDefinition](messagedefinition.html): Computationally friendly name of the message definition
12301* [NamingSystem](namingsystem.html): Computationally friendly name of the naming system
12302* [OperationDefinition](operationdefinition.html): Computationally friendly name of the operation definition
12303* [PlanDefinition](plandefinition.html): Computationally friendly name of the plan definition
12304* [Questionnaire](questionnaire.html): Computationally friendly name of the questionnaire
12305* [Requirements](requirements.html): Computationally friendly name of the requirements
12306* [SearchParameter](searchparameter.html): Computationally friendly name of the search parameter
12307* [StructureDefinition](structuredefinition.html): Computationally friendly name of the structure definition
12308* [StructureMap](structuremap.html): Computationally friendly name of the structure map
12309* [TerminologyCapabilities](terminologycapabilities.html): Computationally friendly name of the terminology capabilities
12310* [TestScript](testscript.html): Computationally friendly name of the test script
12311* [ValueSet](valueset.html): Computationally friendly name of the value set
12312</b><br>
12313   * Type: <b>string</b><br>
12314   * Path: <b>ActivityDefinition.name | CapabilityStatement.name | Citation.name | CodeSystem.name | CompartmentDefinition.name | ConceptMap.name | ConditionDefinition.name | EventDefinition.name | EvidenceVariable.name | ExampleScenario.name | GraphDefinition.name | ImplementationGuide.name | Library.name | Measure.name | MessageDefinition.name | NamingSystem.name | OperationDefinition.name | PlanDefinition.name | Questionnaire.name | Requirements.name | SearchParameter.name | StructureDefinition.name | StructureMap.name | TerminologyCapabilities.name | TestScript.name | ValueSet.name</b><br>
12315   * </p>
12316   */
12317  public static final ca.uhn.fhir.rest.gclient.StringClientParam NAME = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_NAME);
12318
12319 /**
12320   * Search parameter: <b>publisher</b>
12321   * <p>
12322   * Description: <b>Multiple Resources: 
12323
12324* [ActivityDefinition](activitydefinition.html): Name of the publisher of the activity definition
12325* [ActorDefinition](actordefinition.html): Name of the publisher of the Actor Definition
12326* [CapabilityStatement](capabilitystatement.html): Name of the publisher of the capability statement
12327* [ChargeItemDefinition](chargeitemdefinition.html): Name of the publisher of the charge item definition
12328* [Citation](citation.html): Name of the publisher of the citation
12329* [CodeSystem](codesystem.html): Name of the publisher of the code system
12330* [CompartmentDefinition](compartmentdefinition.html): Name of the publisher of the compartment definition
12331* [ConceptMap](conceptmap.html): Name of the publisher of the concept map
12332* [ConditionDefinition](conditiondefinition.html): Name of the publisher of the condition definition
12333* [EventDefinition](eventdefinition.html): Name of the publisher of the event definition
12334* [Evidence](evidence.html): Name of the publisher of the evidence
12335* [EvidenceReport](evidencereport.html): Name of the publisher of the evidence report
12336* [EvidenceVariable](evidencevariable.html): Name of the publisher of the evidence variable
12337* [ExampleScenario](examplescenario.html): Name of the publisher of the example scenario
12338* [GraphDefinition](graphdefinition.html): Name of the publisher of the graph definition
12339* [ImplementationGuide](implementationguide.html): Name of the publisher of the implementation guide
12340* [Library](library.html): Name of the publisher of the library
12341* [Measure](measure.html): Name of the publisher of the measure
12342* [MessageDefinition](messagedefinition.html): Name of the publisher of the message definition
12343* [NamingSystem](namingsystem.html): Name of the publisher of the naming system
12344* [OperationDefinition](operationdefinition.html): Name of the publisher of the operation definition
12345* [PlanDefinition](plandefinition.html): Name of the publisher of the plan definition
12346* [Questionnaire](questionnaire.html): Name of the publisher of the questionnaire
12347* [Requirements](requirements.html): Name of the publisher of the requirements
12348* [SearchParameter](searchparameter.html): Name of the publisher of the search parameter
12349* [StructureDefinition](structuredefinition.html): Name of the publisher of the structure definition
12350* [StructureMap](structuremap.html): Name of the publisher of the structure map
12351* [TerminologyCapabilities](terminologycapabilities.html): Name of the publisher of the terminology capabilities
12352* [TestScript](testscript.html): Name of the publisher of the test script
12353* [ValueSet](valueset.html): Name of the publisher of the value set
12354</b><br>
12355   * Type: <b>string</b><br>
12356   * Path: <b>ActivityDefinition.publisher | ActorDefinition.publisher | CapabilityStatement.publisher | ChargeItemDefinition.publisher | Citation.publisher | CodeSystem.publisher | CompartmentDefinition.publisher | ConceptMap.publisher | ConditionDefinition.publisher | EventDefinition.publisher | Evidence.publisher | EvidenceReport.publisher | EvidenceVariable.publisher | ExampleScenario.publisher | GraphDefinition.publisher | ImplementationGuide.publisher | Library.publisher | Measure.publisher | MessageDefinition.publisher | NamingSystem.publisher | OperationDefinition.publisher | PlanDefinition.publisher | Questionnaire.publisher | Requirements.publisher | SearchParameter.publisher | StructureDefinition.publisher | StructureMap.publisher | TerminologyCapabilities.publisher | TestScript.publisher | ValueSet.publisher</b><br>
12357   * </p>
12358   */
12359  @SearchParamDefinition(name="publisher", path="ActivityDefinition.publisher | ActorDefinition.publisher | CapabilityStatement.publisher | ChargeItemDefinition.publisher | Citation.publisher | CodeSystem.publisher | CompartmentDefinition.publisher | ConceptMap.publisher | ConditionDefinition.publisher | EventDefinition.publisher | Evidence.publisher | EvidenceReport.publisher | EvidenceVariable.publisher | ExampleScenario.publisher | GraphDefinition.publisher | ImplementationGuide.publisher | Library.publisher | Measure.publisher | MessageDefinition.publisher | NamingSystem.publisher | OperationDefinition.publisher | PlanDefinition.publisher | Questionnaire.publisher | Requirements.publisher | SearchParameter.publisher | StructureDefinition.publisher | StructureMap.publisher | TerminologyCapabilities.publisher | TestScript.publisher | ValueSet.publisher", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): Name of the publisher of the activity definition\r\n* [ActorDefinition](actordefinition.html): Name of the publisher of the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): Name of the publisher of the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): Name of the publisher of the charge item definition\r\n* [Citation](citation.html): Name of the publisher of the citation\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* [ConditionDefinition](conditiondefinition.html): Name of the publisher of the condition definition\r\n* [EventDefinition](eventdefinition.html): Name of the publisher of the event definition\r\n* [Evidence](evidence.html): Name of the publisher of the evidence\r\n* [EvidenceReport](evidencereport.html): Name of the publisher of the evidence report\r\n* [EvidenceVariable](evidencevariable.html): Name of the publisher of the evidence variable\r\n* [ExampleScenario](examplescenario.html): Name of the publisher of the example scenario\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* [Library](library.html): Name of the publisher of the library\r\n* [Measure](measure.html): Name of the publisher of the measure\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* [PlanDefinition](plandefinition.html): Name of the publisher of the plan definition\r\n* [Questionnaire](questionnaire.html): Name of the publisher of the questionnaire\r\n* [Requirements](requirements.html): Name of the publisher of the requirements\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* [TestScript](testscript.html): Name of the publisher of the test script\r\n* [ValueSet](valueset.html): Name of the publisher of the value set\r\n", type="string" )
12360  public static final String SP_PUBLISHER = "publisher";
12361 /**
12362   * <b>Fluent Client</b> search parameter constant for <b>publisher</b>
12363   * <p>
12364   * Description: <b>Multiple Resources: 
12365
12366* [ActivityDefinition](activitydefinition.html): Name of the publisher of the activity definition
12367* [ActorDefinition](actordefinition.html): Name of the publisher of the Actor Definition
12368* [CapabilityStatement](capabilitystatement.html): Name of the publisher of the capability statement
12369* [ChargeItemDefinition](chargeitemdefinition.html): Name of the publisher of the charge item definition
12370* [Citation](citation.html): Name of the publisher of the citation
12371* [CodeSystem](codesystem.html): Name of the publisher of the code system
12372* [CompartmentDefinition](compartmentdefinition.html): Name of the publisher of the compartment definition
12373* [ConceptMap](conceptmap.html): Name of the publisher of the concept map
12374* [ConditionDefinition](conditiondefinition.html): Name of the publisher of the condition definition
12375* [EventDefinition](eventdefinition.html): Name of the publisher of the event definition
12376* [Evidence](evidence.html): Name of the publisher of the evidence
12377* [EvidenceReport](evidencereport.html): Name of the publisher of the evidence report
12378* [EvidenceVariable](evidencevariable.html): Name of the publisher of the evidence variable
12379* [ExampleScenario](examplescenario.html): Name of the publisher of the example scenario
12380* [GraphDefinition](graphdefinition.html): Name of the publisher of the graph definition
12381* [ImplementationGuide](implementationguide.html): Name of the publisher of the implementation guide
12382* [Library](library.html): Name of the publisher of the library
12383* [Measure](measure.html): Name of the publisher of the measure
12384* [MessageDefinition](messagedefinition.html): Name of the publisher of the message definition
12385* [NamingSystem](namingsystem.html): Name of the publisher of the naming system
12386* [OperationDefinition](operationdefinition.html): Name of the publisher of the operation definition
12387* [PlanDefinition](plandefinition.html): Name of the publisher of the plan definition
12388* [Questionnaire](questionnaire.html): Name of the publisher of the questionnaire
12389* [Requirements](requirements.html): Name of the publisher of the requirements
12390* [SearchParameter](searchparameter.html): Name of the publisher of the search parameter
12391* [StructureDefinition](structuredefinition.html): Name of the publisher of the structure definition
12392* [StructureMap](structuremap.html): Name of the publisher of the structure map
12393* [TerminologyCapabilities](terminologycapabilities.html): Name of the publisher of the terminology capabilities
12394* [TestScript](testscript.html): Name of the publisher of the test script
12395* [ValueSet](valueset.html): Name of the publisher of the value set
12396</b><br>
12397   * Type: <b>string</b><br>
12398   * Path: <b>ActivityDefinition.publisher | ActorDefinition.publisher | CapabilityStatement.publisher | ChargeItemDefinition.publisher | Citation.publisher | CodeSystem.publisher | CompartmentDefinition.publisher | ConceptMap.publisher | ConditionDefinition.publisher | EventDefinition.publisher | Evidence.publisher | EvidenceReport.publisher | EvidenceVariable.publisher | ExampleScenario.publisher | GraphDefinition.publisher | ImplementationGuide.publisher | Library.publisher | Measure.publisher | MessageDefinition.publisher | NamingSystem.publisher | OperationDefinition.publisher | PlanDefinition.publisher | Questionnaire.publisher | Requirements.publisher | SearchParameter.publisher | StructureDefinition.publisher | StructureMap.publisher | TerminologyCapabilities.publisher | TestScript.publisher | ValueSet.publisher</b><br>
12399   * </p>
12400   */
12401  public static final ca.uhn.fhir.rest.gclient.StringClientParam PUBLISHER = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_PUBLISHER);
12402
12403 /**
12404   * Search parameter: <b>status</b>
12405   * <p>
12406   * Description: <b>Multiple Resources: 
12407
12408* [ActivityDefinition](activitydefinition.html): The current status of the activity definition
12409* [ActorDefinition](actordefinition.html): The current status of the Actor Definition
12410* [CapabilityStatement](capabilitystatement.html): The current status of the capability statement
12411* [ChargeItemDefinition](chargeitemdefinition.html): The current status of the charge item definition
12412* [Citation](citation.html): The current status of the citation
12413* [CodeSystem](codesystem.html): The current status of the code system
12414* [CompartmentDefinition](compartmentdefinition.html): The current status of the compartment definition
12415* [ConceptMap](conceptmap.html): The current status of the concept map
12416* [ConditionDefinition](conditiondefinition.html): The current status of the condition definition
12417* [EventDefinition](eventdefinition.html): The current status of the event definition
12418* [Evidence](evidence.html): The current status of the evidence
12419* [EvidenceReport](evidencereport.html): The current status of the evidence report
12420* [EvidenceVariable](evidencevariable.html): The current status of the evidence variable
12421* [ExampleScenario](examplescenario.html): The current status of the example scenario
12422* [GraphDefinition](graphdefinition.html): The current status of the graph definition
12423* [ImplementationGuide](implementationguide.html): The current status of the implementation guide
12424* [Library](library.html): The current status of the library
12425* [Measure](measure.html): The current status of the measure
12426* [MedicationKnowledge](medicationknowledge.html): active | inactive | entered-in-error
12427* [MessageDefinition](messagedefinition.html): The current status of the message definition
12428* [NamingSystem](namingsystem.html): The current status of the naming system
12429* [ObservationDefinition](observationdefinition.html): Publication status of the ObservationDefinition: draft, active, retired, unknown
12430* [OperationDefinition](operationdefinition.html): The current status of the operation definition
12431* [PlanDefinition](plandefinition.html): The current status of the plan definition
12432* [Questionnaire](questionnaire.html): The current status of the questionnaire
12433* [Requirements](requirements.html): The current status of the requirements
12434* [SearchParameter](searchparameter.html): The current status of the search parameter
12435* [SpecimenDefinition](specimendefinition.html): Publication status of the SpecimenDefinition: draft, active, retired, unknown
12436* [StructureDefinition](structuredefinition.html): The current status of the structure definition
12437* [StructureMap](structuremap.html): The current status of the structure map
12438* [SubscriptionTopic](subscriptiontopic.html): draft | active | retired | unknown
12439* [TerminologyCapabilities](terminologycapabilities.html): The current status of the terminology capabilities
12440* [TestPlan](testplan.html): The current status of the test plan
12441* [TestScript](testscript.html): The current status of the test script
12442* [ValueSet](valueset.html): The current status of the value set
12443</b><br>
12444   * Type: <b>token</b><br>
12445   * Path: <b>ActivityDefinition.status | ActorDefinition.status | CapabilityStatement.status | ChargeItemDefinition.status | Citation.status | CodeSystem.status | CompartmentDefinition.status | ConceptMap.status | ConditionDefinition.status | EventDefinition.status | Evidence.status | EvidenceReport.status | EvidenceVariable.status | ExampleScenario.status | GraphDefinition.status | ImplementationGuide.status | Library.status | Measure.status | MedicationKnowledge.status | MessageDefinition.status | NamingSystem.status | ObservationDefinition.status | OperationDefinition.status | PlanDefinition.status | Questionnaire.status | Requirements.status | SearchParameter.status | SpecimenDefinition.status | StructureDefinition.status | StructureMap.status | SubscriptionTopic.status | TerminologyCapabilities.status | TestPlan.status | TestScript.status | ValueSet.status</b><br>
12446   * </p>
12447   */
12448  @SearchParamDefinition(name="status", path="ActivityDefinition.status | ActorDefinition.status | CapabilityStatement.status | ChargeItemDefinition.status | Citation.status | CodeSystem.status | CompartmentDefinition.status | ConceptMap.status | ConditionDefinition.status | EventDefinition.status | Evidence.status | EvidenceReport.status | EvidenceVariable.status | ExampleScenario.status | GraphDefinition.status | ImplementationGuide.status | Library.status | Measure.status | MedicationKnowledge.status | MessageDefinition.status | NamingSystem.status | ObservationDefinition.status | OperationDefinition.status | PlanDefinition.status | Questionnaire.status | Requirements.status | SearchParameter.status | SpecimenDefinition.status | StructureDefinition.status | StructureMap.status | SubscriptionTopic.status | TerminologyCapabilities.status | TestPlan.status | TestScript.status | ValueSet.status", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): The current status of the activity definition\r\n* [ActorDefinition](actordefinition.html): The current status of the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): The current status of the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): The current status of the charge item definition\r\n* [Citation](citation.html): The current status of the citation\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* [ConditionDefinition](conditiondefinition.html): The current status of the condition definition\r\n* [EventDefinition](eventdefinition.html): The current status of the event definition\r\n* [Evidence](evidence.html): The current status of the evidence\r\n* [EvidenceReport](evidencereport.html): The current status of the evidence report\r\n* [EvidenceVariable](evidencevariable.html): The current status of the evidence variable\r\n* [ExampleScenario](examplescenario.html): The current status of the example scenario\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* [Library](library.html): The current status of the library\r\n* [Measure](measure.html): The current status of the measure\r\n* [MedicationKnowledge](medicationknowledge.html): active | inactive | entered-in-error\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* [ObservationDefinition](observationdefinition.html): Publication status of the ObservationDefinition: draft, active, retired, unknown\r\n* [OperationDefinition](operationdefinition.html): The current status of the operation definition\r\n* [PlanDefinition](plandefinition.html): The current status of the plan definition\r\n* [Questionnaire](questionnaire.html): The current status of the questionnaire\r\n* [Requirements](requirements.html): The current status of the requirements\r\n* [SearchParameter](searchparameter.html): The current status of the search parameter\r\n* [SpecimenDefinition](specimendefinition.html): Publication status of the SpecimenDefinition: draft, active, retired, unknown\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* [SubscriptionTopic](subscriptiontopic.html): draft | active | retired | unknown\r\n* [TerminologyCapabilities](terminologycapabilities.html): The current status of the terminology capabilities\r\n* [TestPlan](testplan.html): The current status of the test plan\r\n* [TestScript](testscript.html): The current status of the test script\r\n* [ValueSet](valueset.html): The current status of the value set\r\n", type="token" )
12449  public static final String SP_STATUS = "status";
12450 /**
12451   * <b>Fluent Client</b> search parameter constant for <b>status</b>
12452   * <p>
12453   * Description: <b>Multiple Resources: 
12454
12455* [ActivityDefinition](activitydefinition.html): The current status of the activity definition
12456* [ActorDefinition](actordefinition.html): The current status of the Actor Definition
12457* [CapabilityStatement](capabilitystatement.html): The current status of the capability statement
12458* [ChargeItemDefinition](chargeitemdefinition.html): The current status of the charge item definition
12459* [Citation](citation.html): The current status of the citation
12460* [CodeSystem](codesystem.html): The current status of the code system
12461* [CompartmentDefinition](compartmentdefinition.html): The current status of the compartment definition
12462* [ConceptMap](conceptmap.html): The current status of the concept map
12463* [ConditionDefinition](conditiondefinition.html): The current status of the condition definition
12464* [EventDefinition](eventdefinition.html): The current status of the event definition
12465* [Evidence](evidence.html): The current status of the evidence
12466* [EvidenceReport](evidencereport.html): The current status of the evidence report
12467* [EvidenceVariable](evidencevariable.html): The current status of the evidence variable
12468* [ExampleScenario](examplescenario.html): The current status of the example scenario
12469* [GraphDefinition](graphdefinition.html): The current status of the graph definition
12470* [ImplementationGuide](implementationguide.html): The current status of the implementation guide
12471* [Library](library.html): The current status of the library
12472* [Measure](measure.html): The current status of the measure
12473* [MedicationKnowledge](medicationknowledge.html): active | inactive | entered-in-error
12474* [MessageDefinition](messagedefinition.html): The current status of the message definition
12475* [NamingSystem](namingsystem.html): The current status of the naming system
12476* [ObservationDefinition](observationdefinition.html): Publication status of the ObservationDefinition: draft, active, retired, unknown
12477* [OperationDefinition](operationdefinition.html): The current status of the operation definition
12478* [PlanDefinition](plandefinition.html): The current status of the plan definition
12479* [Questionnaire](questionnaire.html): The current status of the questionnaire
12480* [Requirements](requirements.html): The current status of the requirements
12481* [SearchParameter](searchparameter.html): The current status of the search parameter
12482* [SpecimenDefinition](specimendefinition.html): Publication status of the SpecimenDefinition: draft, active, retired, unknown
12483* [StructureDefinition](structuredefinition.html): The current status of the structure definition
12484* [StructureMap](structuremap.html): The current status of the structure map
12485* [SubscriptionTopic](subscriptiontopic.html): draft | active | retired | unknown
12486* [TerminologyCapabilities](terminologycapabilities.html): The current status of the terminology capabilities
12487* [TestPlan](testplan.html): The current status of the test plan
12488* [TestScript](testscript.html): The current status of the test script
12489* [ValueSet](valueset.html): The current status of the value set
12490</b><br>
12491   * Type: <b>token</b><br>
12492   * Path: <b>ActivityDefinition.status | ActorDefinition.status | CapabilityStatement.status | ChargeItemDefinition.status | Citation.status | CodeSystem.status | CompartmentDefinition.status | ConceptMap.status | ConditionDefinition.status | EventDefinition.status | Evidence.status | EvidenceReport.status | EvidenceVariable.status | ExampleScenario.status | GraphDefinition.status | ImplementationGuide.status | Library.status | Measure.status | MedicationKnowledge.status | MessageDefinition.status | NamingSystem.status | ObservationDefinition.status | OperationDefinition.status | PlanDefinition.status | Questionnaire.status | Requirements.status | SearchParameter.status | SpecimenDefinition.status | StructureDefinition.status | StructureMap.status | SubscriptionTopic.status | TerminologyCapabilities.status | TestPlan.status | TestScript.status | ValueSet.status</b><br>
12493   * </p>
12494   */
12495  public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS);
12496
12497 /**
12498   * Search parameter: <b>title</b>
12499   * <p>
12500   * Description: <b>Multiple Resources: 
12501
12502* [ActivityDefinition](activitydefinition.html): The human-friendly name of the activity definition
12503* [ActorDefinition](actordefinition.html): The human-friendly name of the Actor Definition
12504* [CapabilityStatement](capabilitystatement.html): The human-friendly name of the capability statement
12505* [ChargeItemDefinition](chargeitemdefinition.html): The human-friendly name of the charge item definition
12506* [Citation](citation.html): The human-friendly name of the citation
12507* [CodeSystem](codesystem.html): The human-friendly name of the code system
12508* [ConceptMap](conceptmap.html): The human-friendly name of the concept map
12509* [ConditionDefinition](conditiondefinition.html): The human-friendly name of the condition definition
12510* [EventDefinition](eventdefinition.html): The human-friendly name of the event definition
12511* [Evidence](evidence.html): The human-friendly name of the evidence
12512* [EvidenceVariable](evidencevariable.html): The human-friendly name of the evidence variable
12513* [ImplementationGuide](implementationguide.html): The human-friendly name of the implementation guide
12514* [Library](library.html): The human-friendly name of the library
12515* [Measure](measure.html): The human-friendly name of the measure
12516* [MessageDefinition](messagedefinition.html): The human-friendly name of the message definition
12517* [ObservationDefinition](observationdefinition.html): Human-friendly name of the ObservationDefinition
12518* [OperationDefinition](operationdefinition.html): The human-friendly name of the operation definition
12519* [PlanDefinition](plandefinition.html): The human-friendly name of the plan definition
12520* [Questionnaire](questionnaire.html): The human-friendly name of the questionnaire
12521* [Requirements](requirements.html): The human-friendly name of the requirements
12522* [SpecimenDefinition](specimendefinition.html): Human-friendly name of the SpecimenDefinition
12523* [StructureDefinition](structuredefinition.html): The human-friendly name of the structure definition
12524* [StructureMap](structuremap.html): The human-friendly name of the structure map
12525* [SubscriptionTopic](subscriptiontopic.html): Name for this SubscriptionTopic (Human friendly)
12526* [TerminologyCapabilities](terminologycapabilities.html): The human-friendly name of the terminology capabilities
12527* [TestScript](testscript.html): The human-friendly name of the test script
12528* [ValueSet](valueset.html): The human-friendly name of the value set
12529</b><br>
12530   * Type: <b>string</b><br>
12531   * Path: <b>ActivityDefinition.title | ActorDefinition.title | CapabilityStatement.title | ChargeItemDefinition.title | Citation.title | CodeSystem.title | ConceptMap.title | ConditionDefinition.title | EventDefinition.title | Evidence.title | EvidenceVariable.title | ImplementationGuide.title | Library.title | Measure.title | MessageDefinition.title | ObservationDefinition.title | OperationDefinition.title | PlanDefinition.title | Questionnaire.title | Requirements.title | SpecimenDefinition.title | StructureDefinition.title | StructureMap.title | SubscriptionTopic.title | TerminologyCapabilities.title | TestScript.title | ValueSet.title</b><br>
12532   * </p>
12533   */
12534  @SearchParamDefinition(name="title", path="ActivityDefinition.title | ActorDefinition.title | CapabilityStatement.title | ChargeItemDefinition.title | Citation.title | CodeSystem.title | ConceptMap.title | ConditionDefinition.title | EventDefinition.title | Evidence.title | EvidenceVariable.title | ImplementationGuide.title | Library.title | Measure.title | MessageDefinition.title | ObservationDefinition.title | OperationDefinition.title | PlanDefinition.title | Questionnaire.title | Requirements.title | SpecimenDefinition.title | StructureDefinition.title | StructureMap.title | SubscriptionTopic.title | TerminologyCapabilities.title | TestScript.title | ValueSet.title", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): The human-friendly name of the activity definition\r\n* [ActorDefinition](actordefinition.html): The human-friendly name of the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): The human-friendly name of the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): The human-friendly name of the charge item definition\r\n* [Citation](citation.html): The human-friendly name of the citation\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* [ConditionDefinition](conditiondefinition.html): The human-friendly name of the condition definition\r\n* [EventDefinition](eventdefinition.html): The human-friendly name of the event definition\r\n* [Evidence](evidence.html): The human-friendly name of the evidence\r\n* [EvidenceVariable](evidencevariable.html): The human-friendly name of the evidence variable\r\n* [ImplementationGuide](implementationguide.html): The human-friendly name of the implementation guide\r\n* [Library](library.html): The human-friendly name of the library\r\n* [Measure](measure.html): The human-friendly name of the measure\r\n* [MessageDefinition](messagedefinition.html): The human-friendly name of the message definition\r\n* [ObservationDefinition](observationdefinition.html): Human-friendly name of the ObservationDefinition\r\n* [OperationDefinition](operationdefinition.html): The human-friendly name of the operation definition\r\n* [PlanDefinition](plandefinition.html): The human-friendly name of the plan definition\r\n* [Questionnaire](questionnaire.html): The human-friendly name of the questionnaire\r\n* [Requirements](requirements.html): The human-friendly name of the requirements\r\n* [SpecimenDefinition](specimendefinition.html): Human-friendly name of the SpecimenDefinition\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* [SubscriptionTopic](subscriptiontopic.html): Name for this SubscriptionTopic (Human friendly)\r\n* [TerminologyCapabilities](terminologycapabilities.html): The human-friendly name of the terminology capabilities\r\n* [TestScript](testscript.html): The human-friendly name of the test script\r\n* [ValueSet](valueset.html): The human-friendly name of the value set\r\n", type="string" )
12535  public static final String SP_TITLE = "title";
12536 /**
12537   * <b>Fluent Client</b> search parameter constant for <b>title</b>
12538   * <p>
12539   * Description: <b>Multiple Resources: 
12540
12541* [ActivityDefinition](activitydefinition.html): The human-friendly name of the activity definition
12542* [ActorDefinition](actordefinition.html): The human-friendly name of the Actor Definition
12543* [CapabilityStatement](capabilitystatement.html): The human-friendly name of the capability statement
12544* [ChargeItemDefinition](chargeitemdefinition.html): The human-friendly name of the charge item definition
12545* [Citation](citation.html): The human-friendly name of the citation
12546* [CodeSystem](codesystem.html): The human-friendly name of the code system
12547* [ConceptMap](conceptmap.html): The human-friendly name of the concept map
12548* [ConditionDefinition](conditiondefinition.html): The human-friendly name of the condition definition
12549* [EventDefinition](eventdefinition.html): The human-friendly name of the event definition
12550* [Evidence](evidence.html): The human-friendly name of the evidence
12551* [EvidenceVariable](evidencevariable.html): The human-friendly name of the evidence variable
12552* [ImplementationGuide](implementationguide.html): The human-friendly name of the implementation guide
12553* [Library](library.html): The human-friendly name of the library
12554* [Measure](measure.html): The human-friendly name of the measure
12555* [MessageDefinition](messagedefinition.html): The human-friendly name of the message definition
12556* [ObservationDefinition](observationdefinition.html): Human-friendly name of the ObservationDefinition
12557* [OperationDefinition](operationdefinition.html): The human-friendly name of the operation definition
12558* [PlanDefinition](plandefinition.html): The human-friendly name of the plan definition
12559* [Questionnaire](questionnaire.html): The human-friendly name of the questionnaire
12560* [Requirements](requirements.html): The human-friendly name of the requirements
12561* [SpecimenDefinition](specimendefinition.html): Human-friendly name of the SpecimenDefinition
12562* [StructureDefinition](structuredefinition.html): The human-friendly name of the structure definition
12563* [StructureMap](structuremap.html): The human-friendly name of the structure map
12564* [SubscriptionTopic](subscriptiontopic.html): Name for this SubscriptionTopic (Human friendly)
12565* [TerminologyCapabilities](terminologycapabilities.html): The human-friendly name of the terminology capabilities
12566* [TestScript](testscript.html): The human-friendly name of the test script
12567* [ValueSet](valueset.html): The human-friendly name of the value set
12568</b><br>
12569   * Type: <b>string</b><br>
12570   * Path: <b>ActivityDefinition.title | ActorDefinition.title | CapabilityStatement.title | ChargeItemDefinition.title | Citation.title | CodeSystem.title | ConceptMap.title | ConditionDefinition.title | EventDefinition.title | Evidence.title | EvidenceVariable.title | ImplementationGuide.title | Library.title | Measure.title | MessageDefinition.title | ObservationDefinition.title | OperationDefinition.title | PlanDefinition.title | Questionnaire.title | Requirements.title | SpecimenDefinition.title | StructureDefinition.title | StructureMap.title | SubscriptionTopic.title | TerminologyCapabilities.title | TestScript.title | ValueSet.title</b><br>
12571   * </p>
12572   */
12573  public static final ca.uhn.fhir.rest.gclient.StringClientParam TITLE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_TITLE);
12574
12575 /**
12576   * Search parameter: <b>url</b>
12577   * <p>
12578   * Description: <b>Multiple Resources: 
12579
12580* [ActivityDefinition](activitydefinition.html): The uri that identifies the activity definition
12581* [ActorDefinition](actordefinition.html): The uri that identifies the Actor Definition
12582* [CapabilityStatement](capabilitystatement.html): The uri that identifies the capability statement
12583* [ChargeItemDefinition](chargeitemdefinition.html): The uri that identifies the charge item definition
12584* [Citation](citation.html): The uri that identifies the citation
12585* [CodeSystem](codesystem.html): The uri that identifies the code system
12586* [CompartmentDefinition](compartmentdefinition.html): The uri that identifies the compartment definition
12587* [ConceptMap](conceptmap.html): The URI that identifies the concept map
12588* [ConditionDefinition](conditiondefinition.html): The uri that identifies the condition definition
12589* [EventDefinition](eventdefinition.html): The uri that identifies the event definition
12590* [Evidence](evidence.html): The uri that identifies the evidence
12591* [EvidenceReport](evidencereport.html): The uri that identifies the evidence report
12592* [EvidenceVariable](evidencevariable.html): The uri that identifies the evidence variable
12593* [ExampleScenario](examplescenario.html): The uri that identifies the example scenario
12594* [GraphDefinition](graphdefinition.html): The uri that identifies the graph definition
12595* [ImplementationGuide](implementationguide.html): The uri that identifies the implementation guide
12596* [Library](library.html): The uri that identifies the library
12597* [Measure](measure.html): The uri that identifies the measure
12598* [MessageDefinition](messagedefinition.html): The uri that identifies the message definition
12599* [NamingSystem](namingsystem.html): The uri that identifies the naming system
12600* [ObservationDefinition](observationdefinition.html): The uri that identifies the observation definition
12601* [OperationDefinition](operationdefinition.html): The uri that identifies the operation definition
12602* [PlanDefinition](plandefinition.html): The uri that identifies the plan definition
12603* [Questionnaire](questionnaire.html): The uri that identifies the questionnaire
12604* [Requirements](requirements.html): The uri that identifies the requirements
12605* [SearchParameter](searchparameter.html): The uri that identifies the search parameter
12606* [SpecimenDefinition](specimendefinition.html): The uri that identifies the specimen definition
12607* [StructureDefinition](structuredefinition.html): The uri that identifies the structure definition
12608* [StructureMap](structuremap.html): The uri that identifies the structure map
12609* [SubscriptionTopic](subscriptiontopic.html): Logical canonical URL to reference this SubscriptionTopic (globally unique)
12610* [TerminologyCapabilities](terminologycapabilities.html): The uri that identifies the terminology capabilities
12611* [TestPlan](testplan.html): The uri that identifies the test plan
12612* [TestScript](testscript.html): The uri that identifies the test script
12613* [ValueSet](valueset.html): The uri that identifies the value set
12614</b><br>
12615   * Type: <b>uri</b><br>
12616   * Path: <b>ActivityDefinition.url | ActorDefinition.url | CapabilityStatement.url | ChargeItemDefinition.url | Citation.url | CodeSystem.url | CompartmentDefinition.url | ConceptMap.url | ConditionDefinition.url | EventDefinition.url | Evidence.url | EvidenceReport.url | EvidenceVariable.url | ExampleScenario.url | GraphDefinition.url | ImplementationGuide.url | Library.url | Measure.url | MessageDefinition.url | NamingSystem.url | ObservationDefinition.url | OperationDefinition.url | PlanDefinition.url | Questionnaire.url | Requirements.url | SearchParameter.url | SpecimenDefinition.url | StructureDefinition.url | StructureMap.url | SubscriptionTopic.url | TerminologyCapabilities.url | TestPlan.url | TestScript.url | ValueSet.url</b><br>
12617   * </p>
12618   */
12619  @SearchParamDefinition(name="url", path="ActivityDefinition.url | ActorDefinition.url | CapabilityStatement.url | ChargeItemDefinition.url | Citation.url | CodeSystem.url | CompartmentDefinition.url | ConceptMap.url | ConditionDefinition.url | EventDefinition.url | Evidence.url | EvidenceReport.url | EvidenceVariable.url | ExampleScenario.url | GraphDefinition.url | ImplementationGuide.url | Library.url | Measure.url | MessageDefinition.url | NamingSystem.url | ObservationDefinition.url | OperationDefinition.url | PlanDefinition.url | Questionnaire.url | Requirements.url | SearchParameter.url | SpecimenDefinition.url | StructureDefinition.url | StructureMap.url | SubscriptionTopic.url | TerminologyCapabilities.url | TestPlan.url | TestScript.url | ValueSet.url", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): The uri that identifies the activity definition\r\n* [ActorDefinition](actordefinition.html): The uri that identifies the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): The uri that identifies the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): The uri that identifies the charge item definition\r\n* [Citation](citation.html): The uri that identifies the citation\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* [ConditionDefinition](conditiondefinition.html): The uri that identifies the condition definition\r\n* [EventDefinition](eventdefinition.html): The uri that identifies the event definition\r\n* [Evidence](evidence.html): The uri that identifies the evidence\r\n* [EvidenceReport](evidencereport.html): The uri that identifies the evidence report\r\n* [EvidenceVariable](evidencevariable.html): The uri that identifies the evidence variable\r\n* [ExampleScenario](examplescenario.html): The uri that identifies the example scenario\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* [Library](library.html): The uri that identifies the library\r\n* [Measure](measure.html): The uri that identifies the measure\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* [ObservationDefinition](observationdefinition.html): The uri that identifies the observation definition\r\n* [OperationDefinition](operationdefinition.html): The uri that identifies the operation definition\r\n* [PlanDefinition](plandefinition.html): The uri that identifies the plan definition\r\n* [Questionnaire](questionnaire.html): The uri that identifies the questionnaire\r\n* [Requirements](requirements.html): The uri that identifies the requirements\r\n* [SearchParameter](searchparameter.html): The uri that identifies the search parameter\r\n* [SpecimenDefinition](specimendefinition.html): The uri that identifies the specimen definition\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* [SubscriptionTopic](subscriptiontopic.html): Logical canonical URL to reference this SubscriptionTopic (globally unique)\r\n* [TerminologyCapabilities](terminologycapabilities.html): The uri that identifies the terminology capabilities\r\n* [TestPlan](testplan.html): The uri that identifies the test plan\r\n* [TestScript](testscript.html): The uri that identifies the test script\r\n* [ValueSet](valueset.html): The uri that identifies the value set\r\n", type="uri" )
12620  public static final String SP_URL = "url";
12621 /**
12622   * <b>Fluent Client</b> search parameter constant for <b>url</b>
12623   * <p>
12624   * Description: <b>Multiple Resources: 
12625
12626* [ActivityDefinition](activitydefinition.html): The uri that identifies the activity definition
12627* [ActorDefinition](actordefinition.html): The uri that identifies the Actor Definition
12628* [CapabilityStatement](capabilitystatement.html): The uri that identifies the capability statement
12629* [ChargeItemDefinition](chargeitemdefinition.html): The uri that identifies the charge item definition
12630* [Citation](citation.html): The uri that identifies the citation
12631* [CodeSystem](codesystem.html): The uri that identifies the code system
12632* [CompartmentDefinition](compartmentdefinition.html): The uri that identifies the compartment definition
12633* [ConceptMap](conceptmap.html): The URI that identifies the concept map
12634* [ConditionDefinition](conditiondefinition.html): The uri that identifies the condition definition
12635* [EventDefinition](eventdefinition.html): The uri that identifies the event definition
12636* [Evidence](evidence.html): The uri that identifies the evidence
12637* [EvidenceReport](evidencereport.html): The uri that identifies the evidence report
12638* [EvidenceVariable](evidencevariable.html): The uri that identifies the evidence variable
12639* [ExampleScenario](examplescenario.html): The uri that identifies the example scenario
12640* [GraphDefinition](graphdefinition.html): The uri that identifies the graph definition
12641* [ImplementationGuide](implementationguide.html): The uri that identifies the implementation guide
12642* [Library](library.html): The uri that identifies the library
12643* [Measure](measure.html): The uri that identifies the measure
12644* [MessageDefinition](messagedefinition.html): The uri that identifies the message definition
12645* [NamingSystem](namingsystem.html): The uri that identifies the naming system
12646* [ObservationDefinition](observationdefinition.html): The uri that identifies the observation definition
12647* [OperationDefinition](operationdefinition.html): The uri that identifies the operation definition
12648* [PlanDefinition](plandefinition.html): The uri that identifies the plan definition
12649* [Questionnaire](questionnaire.html): The uri that identifies the questionnaire
12650* [Requirements](requirements.html): The uri that identifies the requirements
12651* [SearchParameter](searchparameter.html): The uri that identifies the search parameter
12652* [SpecimenDefinition](specimendefinition.html): The uri that identifies the specimen definition
12653* [StructureDefinition](structuredefinition.html): The uri that identifies the structure definition
12654* [StructureMap](structuremap.html): The uri that identifies the structure map
12655* [SubscriptionTopic](subscriptiontopic.html): Logical canonical URL to reference this SubscriptionTopic (globally unique)
12656* [TerminologyCapabilities](terminologycapabilities.html): The uri that identifies the terminology capabilities
12657* [TestPlan](testplan.html): The uri that identifies the test plan
12658* [TestScript](testscript.html): The uri that identifies the test script
12659* [ValueSet](valueset.html): The uri that identifies the value set
12660</b><br>
12661   * Type: <b>uri</b><br>
12662   * Path: <b>ActivityDefinition.url | ActorDefinition.url | CapabilityStatement.url | ChargeItemDefinition.url | Citation.url | CodeSystem.url | CompartmentDefinition.url | ConceptMap.url | ConditionDefinition.url | EventDefinition.url | Evidence.url | EvidenceReport.url | EvidenceVariable.url | ExampleScenario.url | GraphDefinition.url | ImplementationGuide.url | Library.url | Measure.url | MessageDefinition.url | NamingSystem.url | ObservationDefinition.url | OperationDefinition.url | PlanDefinition.url | Questionnaire.url | Requirements.url | SearchParameter.url | SpecimenDefinition.url | StructureDefinition.url | StructureMap.url | SubscriptionTopic.url | TerminologyCapabilities.url | TestPlan.url | TestScript.url | ValueSet.url</b><br>
12663   * </p>
12664   */
12665  public static final ca.uhn.fhir.rest.gclient.UriClientParam URL = new ca.uhn.fhir.rest.gclient.UriClientParam(SP_URL);
12666
12667 /**
12668   * Search parameter: <b>version</b>
12669   * <p>
12670   * Description: <b>Multiple Resources: 
12671
12672* [ActivityDefinition](activitydefinition.html): The business version of the activity definition
12673* [ActorDefinition](actordefinition.html): The business version of the Actor Definition
12674* [CapabilityStatement](capabilitystatement.html): The business version of the capability statement
12675* [ChargeItemDefinition](chargeitemdefinition.html): The business version of the charge item definition
12676* [Citation](citation.html): The business version of the citation
12677* [CodeSystem](codesystem.html): The business version of the code system
12678* [CompartmentDefinition](compartmentdefinition.html): The business version of the compartment definition
12679* [ConceptMap](conceptmap.html): The business version of the concept map
12680* [ConditionDefinition](conditiondefinition.html): The business version of the condition definition
12681* [EventDefinition](eventdefinition.html): The business version of the event definition
12682* [Evidence](evidence.html): The business version of the evidence
12683* [EvidenceVariable](evidencevariable.html): The business version of the evidence variable
12684* [ExampleScenario](examplescenario.html): The business version of the example scenario
12685* [GraphDefinition](graphdefinition.html): The business version of the graph definition
12686* [ImplementationGuide](implementationguide.html): The business version of the implementation guide
12687* [Library](library.html): The business version of the library
12688* [Measure](measure.html): The business version of the measure
12689* [MessageDefinition](messagedefinition.html): The business version of the message definition
12690* [NamingSystem](namingsystem.html): The business version of the naming system
12691* [OperationDefinition](operationdefinition.html): The business version of the operation definition
12692* [PlanDefinition](plandefinition.html): The business version of the plan definition
12693* [Questionnaire](questionnaire.html): The business version of the questionnaire
12694* [Requirements](requirements.html): The business version of the requirements
12695* [SearchParameter](searchparameter.html): The business version of the search parameter
12696* [StructureDefinition](structuredefinition.html): The business version of the structure definition
12697* [StructureMap](structuremap.html): The business version of the structure map
12698* [SubscriptionTopic](subscriptiontopic.html): Business version of the SubscriptionTopic
12699* [TerminologyCapabilities](terminologycapabilities.html): The business version of the terminology capabilities
12700* [TestScript](testscript.html): The business version of the test script
12701* [ValueSet](valueset.html): The business version of the value set
12702</b><br>
12703   * Type: <b>token</b><br>
12704   * Path: <b>ActivityDefinition.version | ActorDefinition.version | CapabilityStatement.version | ChargeItemDefinition.version | Citation.version | CodeSystem.version | CompartmentDefinition.version | ConceptMap.version | ConditionDefinition.version | EventDefinition.version | Evidence.version | EvidenceVariable.version | ExampleScenario.version | GraphDefinition.version | ImplementationGuide.version | Library.version | Measure.version | MessageDefinition.version | NamingSystem.version | OperationDefinition.version | PlanDefinition.version | Questionnaire.version | Requirements.version | SearchParameter.version | StructureDefinition.version | StructureMap.version | SubscriptionTopic.version | TerminologyCapabilities.version | TestScript.version | ValueSet.version</b><br>
12705   * </p>
12706   */
12707  @SearchParamDefinition(name="version", path="ActivityDefinition.version | ActorDefinition.version | CapabilityStatement.version | ChargeItemDefinition.version | Citation.version | CodeSystem.version | CompartmentDefinition.version | ConceptMap.version | ConditionDefinition.version | EventDefinition.version | Evidence.version | EvidenceVariable.version | ExampleScenario.version | GraphDefinition.version | ImplementationGuide.version | Library.version | Measure.version | MessageDefinition.version | NamingSystem.version | OperationDefinition.version | PlanDefinition.version | Questionnaire.version | Requirements.version | SearchParameter.version | StructureDefinition.version | StructureMap.version | SubscriptionTopic.version | TerminologyCapabilities.version | TestScript.version | ValueSet.version", description="Multiple Resources: \r\n\r\n* [ActivityDefinition](activitydefinition.html): The business version of the activity definition\r\n* [ActorDefinition](actordefinition.html): The business version of the Actor Definition\r\n* [CapabilityStatement](capabilitystatement.html): The business version of the capability statement\r\n* [ChargeItemDefinition](chargeitemdefinition.html): The business version of the charge item definition\r\n* [Citation](citation.html): The business version of the citation\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* [ConditionDefinition](conditiondefinition.html): The business version of the condition definition\r\n* [EventDefinition](eventdefinition.html): The business version of the event definition\r\n* [Evidence](evidence.html): The business version of the evidence\r\n* [EvidenceVariable](evidencevariable.html): The business version of the evidence variable\r\n* [ExampleScenario](examplescenario.html): The business version of the example scenario\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* [Library](library.html): The business version of the library\r\n* [Measure](measure.html): The business version of the measure\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* [PlanDefinition](plandefinition.html): The business version of the plan definition\r\n* [Questionnaire](questionnaire.html): The business version of the questionnaire\r\n* [Requirements](requirements.html): The business version of the requirements\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* [SubscriptionTopic](subscriptiontopic.html): Business version of the SubscriptionTopic\r\n* [TerminologyCapabilities](terminologycapabilities.html): The business version of the terminology capabilities\r\n* [TestScript](testscript.html): The business version of the test script\r\n* [ValueSet](valueset.html): The business version of the value set\r\n", type="token" )
12708  public static final String SP_VERSION = "version";
12709 /**
12710   * <b>Fluent Client</b> search parameter constant for <b>version</b>
12711   * <p>
12712   * Description: <b>Multiple Resources: 
12713
12714* [ActivityDefinition](activitydefinition.html): The business version of the activity definition
12715* [ActorDefinition](actordefinition.html): The business version of the Actor Definition
12716* [CapabilityStatement](capabilitystatement.html): The business version of the capability statement
12717* [ChargeItemDefinition](chargeitemdefinition.html): The business version of the charge item definition
12718* [Citation](citation.html): The business version of the citation
12719* [CodeSystem](codesystem.html): The business version of the code system
12720* [CompartmentDefinition](compartmentdefinition.html): The business version of the compartment definition
12721* [ConceptMap](conceptmap.html): The business version of the concept map
12722* [ConditionDefinition](conditiondefinition.html): The business version of the condition definition
12723* [EventDefinition](eventdefinition.html): The business version of the event definition
12724* [Evidence](evidence.html): The business version of the evidence
12725* [EvidenceVariable](evidencevariable.html): The business version of the evidence variable
12726* [ExampleScenario](examplescenario.html): The business version of the example scenario
12727* [GraphDefinition](graphdefinition.html): The business version of the graph definition
12728* [ImplementationGuide](implementationguide.html): The business version of the implementation guide
12729* [Library](library.html): The business version of the library
12730* [Measure](measure.html): The business version of the measure
12731* [MessageDefinition](messagedefinition.html): The business version of the message definition
12732* [NamingSystem](namingsystem.html): The business version of the naming system
12733* [OperationDefinition](operationdefinition.html): The business version of the operation definition
12734* [PlanDefinition](plandefinition.html): The business version of the plan definition
12735* [Questionnaire](questionnaire.html): The business version of the questionnaire
12736* [Requirements](requirements.html): The business version of the requirements
12737* [SearchParameter](searchparameter.html): The business version of the search parameter
12738* [StructureDefinition](structuredefinition.html): The business version of the structure definition
12739* [StructureMap](structuremap.html): The business version of the structure map
12740* [SubscriptionTopic](subscriptiontopic.html): Business version of the SubscriptionTopic
12741* [TerminologyCapabilities](terminologycapabilities.html): The business version of the terminology capabilities
12742* [TestScript](testscript.html): The business version of the test script
12743* [ValueSet](valueset.html): The business version of the value set
12744</b><br>
12745   * Type: <b>token</b><br>
12746   * Path: <b>ActivityDefinition.version | ActorDefinition.version | CapabilityStatement.version | ChargeItemDefinition.version | Citation.version | CodeSystem.version | CompartmentDefinition.version | ConceptMap.version | ConditionDefinition.version | EventDefinition.version | Evidence.version | EvidenceVariable.version | ExampleScenario.version | GraphDefinition.version | ImplementationGuide.version | Library.version | Measure.version | MessageDefinition.version | NamingSystem.version | OperationDefinition.version | PlanDefinition.version | Questionnaire.version | Requirements.version | SearchParameter.version | StructureDefinition.version | StructureMap.version | SubscriptionTopic.version | TerminologyCapabilities.version | TestScript.version | ValueSet.version</b><br>
12747   * </p>
12748   */
12749  public static final ca.uhn.fhir.rest.gclient.TokenClientParam VERSION = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_VERSION);
12750
12751 /**
12752   * Search parameter: <b>scope-artifact</b>
12753   * <p>
12754   * Description: <b>The artifact under test</b><br>
12755   * Type: <b>reference</b><br>
12756   * Path: <b>TestScript.scope.artifact</b><br>
12757   * </p>
12758   */
12759  @SearchParamDefinition(name="scope-artifact", path="TestScript.scope.artifact", description="The artifact under test", type="reference", target={Account.class, ActivityDefinition.class, ActorDefinition.class, AdministrableProductDefinition.class, AdverseEvent.class, AllergyIntolerance.class, Appointment.class, AppointmentResponse.class, ArtifactAssessment.class, AuditEvent.class, Basic.class, Binary.class, BiologicallyDerivedProduct.class, BiologicallyDerivedProductDispense.class, BodyStructure.class, Bundle.class, CapabilityStatement.class, CarePlan.class, CareTeam.class, ChargeItem.class, ChargeItemDefinition.class, Citation.class, Claim.class, ClaimResponse.class, ClinicalImpression.class, ClinicalUseDefinition.class, CodeSystem.class, Communication.class, CommunicationRequest.class, CompartmentDefinition.class, Composition.class, ConceptMap.class, Condition.class, ConditionDefinition.class, Consent.class, Contract.class, Coverage.class, CoverageEligibilityRequest.class, CoverageEligibilityResponse.class, DetectedIssue.class, Device.class, DeviceAssociation.class, DeviceDefinition.class, DeviceDispense.class, DeviceMetric.class, DeviceRequest.class, DeviceUsage.class, DiagnosticReport.class, DocumentReference.class, Encounter.class, EncounterHistory.class, Endpoint.class, EnrollmentRequest.class, EnrollmentResponse.class, EpisodeOfCare.class, EventDefinition.class, Evidence.class, EvidenceReport.class, EvidenceVariable.class, ExampleScenario.class, ExplanationOfBenefit.class, FamilyMemberHistory.class, Flag.class, FormularyItem.class, GenomicStudy.class, Goal.class, GraphDefinition.class, Group.class, GuidanceResponse.class, HealthcareService.class, ImagingSelection.class, ImagingStudy.class, Immunization.class, ImmunizationEvaluation.class, ImmunizationRecommendation.class, ImplementationGuide.class, Ingredient.class, InsurancePlan.class, InventoryItem.class, InventoryReport.class, Invoice.class, Library.class, Linkage.class, ListResource.class, Location.class, ManufacturedItemDefinition.class, Measure.class, MeasureReport.class, Medication.class, MedicationAdministration.class, MedicationDispense.class, MedicationKnowledge.class, MedicationRequest.class, MedicationStatement.class, MedicinalProductDefinition.class, MessageDefinition.class, MessageHeader.class, MolecularSequence.class, NamingSystem.class, NutritionIntake.class, NutritionOrder.class, NutritionProduct.class, Observation.class, ObservationDefinition.class, OperationDefinition.class, OperationOutcome.class, Organization.class, OrganizationAffiliation.class, PackagedProductDefinition.class, Parameters.class, Patient.class, PaymentNotice.class, PaymentReconciliation.class, Permission.class, Person.class, PlanDefinition.class, Practitioner.class, PractitionerRole.class, Procedure.class, Provenance.class, Questionnaire.class, QuestionnaireResponse.class, RegulatedAuthorization.class, RelatedPerson.class, RequestOrchestration.class, Requirements.class, ResearchStudy.class, ResearchSubject.class, RiskAssessment.class, Schedule.class, SearchParameter.class, ServiceRequest.class, Slot.class, Specimen.class, SpecimenDefinition.class, StructureDefinition.class, StructureMap.class, Subscription.class, SubscriptionStatus.class, SubscriptionTopic.class, Substance.class, SubstanceDefinition.class, SubstanceNucleicAcid.class, SubstancePolymer.class, SubstanceProtein.class, SubstanceReferenceInformation.class, SubstanceSourceMaterial.class, SupplyDelivery.class, SupplyRequest.class, Task.class, TerminologyCapabilities.class, TestPlan.class, TestReport.class, TestScript.class, Transport.class, ValueSet.class, VerificationResult.class, VisionPrescription.class } )
12760  public static final String SP_SCOPE_ARTIFACT = "scope-artifact";
12761 /**
12762   * <b>Fluent Client</b> search parameter constant for <b>scope-artifact</b>
12763   * <p>
12764   * Description: <b>The artifact under test</b><br>
12765   * Type: <b>reference</b><br>
12766   * Path: <b>TestScript.scope.artifact</b><br>
12767   * </p>
12768   */
12769  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam SCOPE_ARTIFACT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_SCOPE_ARTIFACT);
12770
12771/**
12772   * Constant for fluent queries to be used to add include statements. Specifies
12773   * the path value of "<b>TestScript:scope-artifact</b>".
12774   */
12775  public static final ca.uhn.fhir.model.api.Include INCLUDE_SCOPE_ARTIFACT = new ca.uhn.fhir.model.api.Include("TestScript:scope-artifact").toLocked();
12776
12777 /**
12778   * Search parameter: <b>testscript-capability</b>
12779   * <p>
12780   * Description: <b>TestScript required and validated capability</b><br>
12781   * Type: <b>string</b><br>
12782   * Path: <b>TestScript.metadata.capability.description</b><br>
12783   * </p>
12784   */
12785  @SearchParamDefinition(name="testscript-capability", path="TestScript.metadata.capability.description", description="TestScript required and validated capability", type="string" )
12786  public static final String SP_TESTSCRIPT_CAPABILITY = "testscript-capability";
12787 /**
12788   * <b>Fluent Client</b> search parameter constant for <b>testscript-capability</b>
12789   * <p>
12790   * Description: <b>TestScript required and validated capability</b><br>
12791   * Type: <b>string</b><br>
12792   * Path: <b>TestScript.metadata.capability.description</b><br>
12793   * </p>
12794   */
12795  public static final ca.uhn.fhir.rest.gclient.StringClientParam TESTSCRIPT_CAPABILITY = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_TESTSCRIPT_CAPABILITY);
12796
12797
12798}
12799