001package org.hl7.fhir.r4.model;
002
003/*
004  Copyright (c) 2011+, HL7, Inc.
005  All rights reserved.
006  
007  Redistribution and use in source and binary forms, with or without modification, 
008  are permitted provided that the following conditions are met:
009  
010   * Redistributions of source code must retain the above copyright notice, this 
011     list of conditions and the following disclaimer.
012   * Redistributions in binary form must reproduce the above copyright notice, 
013     this list of conditions and the following disclaimer in the documentation 
014     and/or other materials provided with the distribution.
015   * Neither the name of HL7 nor the names of its contributors may be used to 
016     endorse or promote products derived from this software without specific 
017     prior written permission.
018  
019  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
020  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
021  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
022  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
023  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
024  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
025  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
026  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
027  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
028  POSSIBILITY OF SUCH DAMAGE.
029  
030*/
031
032// Generated on Tue, May 12, 2020 07:26+1000 for FHIR v4.0.1
033import java.util.ArrayList;
034import java.util.Date;
035import java.util.List;
036
037import org.hl7.fhir.exceptions.FHIRException;
038import org.hl7.fhir.instance.model.api.IBaseBackboneElement;
039import org.hl7.fhir.r4.model.Enumerations.PublicationStatus;
040import org.hl7.fhir.r4.model.Enumerations.PublicationStatusEnumFactory;
041import org.hl7.fhir.utilities.Utilities;
042
043import ca.uhn.fhir.model.api.annotation.Block;
044import ca.uhn.fhir.model.api.annotation.Child;
045import ca.uhn.fhir.model.api.annotation.ChildOrder;
046import ca.uhn.fhir.model.api.annotation.Description;
047import ca.uhn.fhir.model.api.annotation.ResourceDef;
048import ca.uhn.fhir.model.api.annotation.SearchParamDefinition;
049
050/**
051 * A structured set of tests against a FHIR server or client implementation to
052 * determine compliance against the FHIR specification.
053 */
054@ResourceDef(name = "TestScript", profile = "http://hl7.org/fhir/StructureDefinition/TestScript")
055@ChildOrder(names = { "url", "identifier", "version", "name", "title", "status", "experimental", "date", "publisher",
056    "contact", "description", "useContext", "jurisdiction", "purpose", "copyright", "origin", "destination", "metadata",
057    "fixture", "profile", "variable", "setup", "test", "teardown" })
058public class TestScript extends MetadataResource {
059
060  public enum TestScriptRequestMethodCode {
061    /**
062     * HTTP DELETE operation.
063     */
064    DELETE,
065    /**
066     * HTTP GET operation.
067     */
068    GET,
069    /**
070     * HTTP OPTIONS operation.
071     */
072    OPTIONS,
073    /**
074     * HTTP PATCH operation.
075     */
076    PATCH,
077    /**
078     * HTTP POST operation.
079     */
080    POST,
081    /**
082     * HTTP PUT operation.
083     */
084    PUT,
085    /**
086     * HTTP HEAD operation.
087     */
088    HEAD,
089    /**
090     * added to help the parsers with the generic types
091     */
092    NULL;
093
094    public static TestScriptRequestMethodCode fromCode(String codeString) throws FHIRException {
095      if (codeString == null || "".equals(codeString))
096        return null;
097      if ("delete".equals(codeString))
098        return DELETE;
099      if ("get".equals(codeString))
100        return GET;
101      if ("options".equals(codeString))
102        return OPTIONS;
103      if ("patch".equals(codeString))
104        return PATCH;
105      if ("post".equals(codeString))
106        return POST;
107      if ("put".equals(codeString))
108        return PUT;
109      if ("head".equals(codeString))
110        return HEAD;
111      if (Configuration.isAcceptInvalidEnums())
112        return null;
113      else
114        throw new FHIRException("Unknown TestScriptRequestMethodCode code '" + codeString + "'");
115    }
116
117    public String toCode() {
118      switch (this) {
119      case DELETE:
120        return "delete";
121      case GET:
122        return "get";
123      case OPTIONS:
124        return "options";
125      case PATCH:
126        return "patch";
127      case POST:
128        return "post";
129      case PUT:
130        return "put";
131      case HEAD:
132        return "head";
133      case NULL:
134        return null;
135      default:
136        return "?";
137      }
138    }
139
140    public String getSystem() {
141      switch (this) {
142      case DELETE:
143        return "http://hl7.org/fhir/http-operations";
144      case GET:
145        return "http://hl7.org/fhir/http-operations";
146      case OPTIONS:
147        return "http://hl7.org/fhir/http-operations";
148      case PATCH:
149        return "http://hl7.org/fhir/http-operations";
150      case POST:
151        return "http://hl7.org/fhir/http-operations";
152      case PUT:
153        return "http://hl7.org/fhir/http-operations";
154      case HEAD:
155        return "http://hl7.org/fhir/http-operations";
156      case NULL:
157        return null;
158      default:
159        return "?";
160      }
161    }
162
163    public String getDefinition() {
164      switch (this) {
165      case DELETE:
166        return "HTTP DELETE operation.";
167      case GET:
168        return "HTTP GET operation.";
169      case OPTIONS:
170        return "HTTP OPTIONS operation.";
171      case PATCH:
172        return "HTTP PATCH operation.";
173      case POST:
174        return "HTTP POST operation.";
175      case PUT:
176        return "HTTP PUT operation.";
177      case HEAD:
178        return "HTTP HEAD operation.";
179      case NULL:
180        return null;
181      default:
182        return "?";
183      }
184    }
185
186    public String getDisplay() {
187      switch (this) {
188      case DELETE:
189        return "DELETE";
190      case GET:
191        return "GET";
192      case OPTIONS:
193        return "OPTIONS";
194      case PATCH:
195        return "PATCH";
196      case POST:
197        return "POST";
198      case PUT:
199        return "PUT";
200      case HEAD:
201        return "HEAD";
202      case NULL:
203        return null;
204      default:
205        return "?";
206      }
207    }
208  }
209
210  public static class TestScriptRequestMethodCodeEnumFactory implements EnumFactory<TestScriptRequestMethodCode> {
211    public TestScriptRequestMethodCode fromCode(String codeString) throws IllegalArgumentException {
212      if (codeString == null || "".equals(codeString))
213        if (codeString == null || "".equals(codeString))
214          return null;
215      if ("delete".equals(codeString))
216        return TestScriptRequestMethodCode.DELETE;
217      if ("get".equals(codeString))
218        return TestScriptRequestMethodCode.GET;
219      if ("options".equals(codeString))
220        return TestScriptRequestMethodCode.OPTIONS;
221      if ("patch".equals(codeString))
222        return TestScriptRequestMethodCode.PATCH;
223      if ("post".equals(codeString))
224        return TestScriptRequestMethodCode.POST;
225      if ("put".equals(codeString))
226        return TestScriptRequestMethodCode.PUT;
227      if ("head".equals(codeString))
228        return TestScriptRequestMethodCode.HEAD;
229      throw new IllegalArgumentException("Unknown TestScriptRequestMethodCode code '" + codeString + "'");
230    }
231
232    public Enumeration<TestScriptRequestMethodCode> fromType(PrimitiveType<?> code) throws FHIRException {
233      if (code == null)
234        return null;
235      if (code.isEmpty())
236        return new Enumeration<TestScriptRequestMethodCode>(this, TestScriptRequestMethodCode.NULL, code);
237      String codeString = code.asStringValue();
238      if (codeString == null || "".equals(codeString))
239        return new Enumeration<TestScriptRequestMethodCode>(this, TestScriptRequestMethodCode.NULL, code);
240      if ("delete".equals(codeString))
241        return new Enumeration<TestScriptRequestMethodCode>(this, TestScriptRequestMethodCode.DELETE, code);
242      if ("get".equals(codeString))
243        return new Enumeration<TestScriptRequestMethodCode>(this, TestScriptRequestMethodCode.GET, code);
244      if ("options".equals(codeString))
245        return new Enumeration<TestScriptRequestMethodCode>(this, TestScriptRequestMethodCode.OPTIONS, code);
246      if ("patch".equals(codeString))
247        return new Enumeration<TestScriptRequestMethodCode>(this, TestScriptRequestMethodCode.PATCH, code);
248      if ("post".equals(codeString))
249        return new Enumeration<TestScriptRequestMethodCode>(this, TestScriptRequestMethodCode.POST, code);
250      if ("put".equals(codeString))
251        return new Enumeration<TestScriptRequestMethodCode>(this, TestScriptRequestMethodCode.PUT, code);
252      if ("head".equals(codeString))
253        return new Enumeration<TestScriptRequestMethodCode>(this, TestScriptRequestMethodCode.HEAD, code);
254      throw new FHIRException("Unknown TestScriptRequestMethodCode code '" + codeString + "'");
255    }
256
257    public String toCode(TestScriptRequestMethodCode code) {
258      if (code == TestScriptRequestMethodCode.DELETE)
259        return "delete";
260      if (code == TestScriptRequestMethodCode.GET)
261        return "get";
262      if (code == TestScriptRequestMethodCode.OPTIONS)
263        return "options";
264      if (code == TestScriptRequestMethodCode.PATCH)
265        return "patch";
266      if (code == TestScriptRequestMethodCode.POST)
267        return "post";
268      if (code == TestScriptRequestMethodCode.PUT)
269        return "put";
270      if (code == TestScriptRequestMethodCode.HEAD)
271        return "head";
272      return "?";
273    }
274
275    public String toSystem(TestScriptRequestMethodCode code) {
276      return code.getSystem();
277    }
278  }
279
280  public enum AssertionDirectionType {
281    /**
282     * The assertion is evaluated on the response. This is the default value.
283     */
284    RESPONSE,
285    /**
286     * The assertion is evaluated on the request.
287     */
288    REQUEST,
289    /**
290     * added to help the parsers with the generic types
291     */
292    NULL;
293
294    public static AssertionDirectionType fromCode(String codeString) throws FHIRException {
295      if (codeString == null || "".equals(codeString))
296        return null;
297      if ("response".equals(codeString))
298        return RESPONSE;
299      if ("request".equals(codeString))
300        return REQUEST;
301      if (Configuration.isAcceptInvalidEnums())
302        return null;
303      else
304        throw new FHIRException("Unknown AssertionDirectionType code '" + codeString + "'");
305    }
306
307    public String toCode() {
308      switch (this) {
309      case RESPONSE:
310        return "response";
311      case REQUEST:
312        return "request";
313      case NULL:
314        return null;
315      default:
316        return "?";
317      }
318    }
319
320    public String getSystem() {
321      switch (this) {
322      case RESPONSE:
323        return "http://hl7.org/fhir/assert-direction-codes";
324      case REQUEST:
325        return "http://hl7.org/fhir/assert-direction-codes";
326      case NULL:
327        return null;
328      default:
329        return "?";
330      }
331    }
332
333    public String getDefinition() {
334      switch (this) {
335      case RESPONSE:
336        return "The assertion is evaluated on the response. This is the default value.";
337      case REQUEST:
338        return "The assertion is evaluated on the request.";
339      case NULL:
340        return null;
341      default:
342        return "?";
343      }
344    }
345
346    public String getDisplay() {
347      switch (this) {
348      case RESPONSE:
349        return "response";
350      case REQUEST:
351        return "request";
352      case NULL:
353        return null;
354      default:
355        return "?";
356      }
357    }
358  }
359
360  public static class AssertionDirectionTypeEnumFactory implements EnumFactory<AssertionDirectionType> {
361    public AssertionDirectionType fromCode(String codeString) throws IllegalArgumentException {
362      if (codeString == null || "".equals(codeString))
363        if (codeString == null || "".equals(codeString))
364          return null;
365      if ("response".equals(codeString))
366        return AssertionDirectionType.RESPONSE;
367      if ("request".equals(codeString))
368        return AssertionDirectionType.REQUEST;
369      throw new IllegalArgumentException("Unknown AssertionDirectionType code '" + codeString + "'");
370    }
371
372    public Enumeration<AssertionDirectionType> fromType(PrimitiveType<?> code) throws FHIRException {
373      if (code == null)
374        return null;
375      if (code.isEmpty())
376        return new Enumeration<AssertionDirectionType>(this, AssertionDirectionType.NULL, code);
377      String codeString = code.asStringValue();
378      if (codeString == null || "".equals(codeString))
379        return new Enumeration<AssertionDirectionType>(this, AssertionDirectionType.NULL, code);
380      if ("response".equals(codeString))
381        return new Enumeration<AssertionDirectionType>(this, AssertionDirectionType.RESPONSE, code);
382      if ("request".equals(codeString))
383        return new Enumeration<AssertionDirectionType>(this, AssertionDirectionType.REQUEST, code);
384      throw new FHIRException("Unknown AssertionDirectionType code '" + codeString + "'");
385    }
386
387    public String toCode(AssertionDirectionType code) {
388      if (code == AssertionDirectionType.RESPONSE)
389        return "response";
390      if (code == AssertionDirectionType.REQUEST)
391        return "request";
392      return "?";
393    }
394
395    public String toSystem(AssertionDirectionType code) {
396      return code.getSystem();
397    }
398  }
399
400  public enum AssertionOperatorType {
401    /**
402     * Default value. Equals comparison.
403     */
404    EQUALS,
405    /**
406     * Not equals comparison.
407     */
408    NOTEQUALS,
409    /**
410     * Compare value within a known set of values.
411     */
412    IN,
413    /**
414     * Compare value not within a known set of values.
415     */
416    NOTIN,
417    /**
418     * Compare value to be greater than a known value.
419     */
420    GREATERTHAN,
421    /**
422     * Compare value to be less than a known value.
423     */
424    LESSTHAN,
425    /**
426     * Compare value is empty.
427     */
428    EMPTY,
429    /**
430     * Compare value is not empty.
431     */
432    NOTEMPTY,
433    /**
434     * Compare value string contains a known value.
435     */
436    CONTAINS,
437    /**
438     * Compare value string does not contain a known value.
439     */
440    NOTCONTAINS,
441    /**
442     * Evaluate the FHIRPath expression as a boolean condition.
443     */
444    EVAL,
445    /**
446     * added to help the parsers with the generic types
447     */
448    NULL;
449
450    public static AssertionOperatorType fromCode(String codeString) throws FHIRException {
451      if (codeString == null || "".equals(codeString))
452        return null;
453      if ("equals".equals(codeString))
454        return EQUALS;
455      if ("notEquals".equals(codeString))
456        return NOTEQUALS;
457      if ("in".equals(codeString))
458        return IN;
459      if ("notIn".equals(codeString))
460        return NOTIN;
461      if ("greaterThan".equals(codeString))
462        return GREATERTHAN;
463      if ("lessThan".equals(codeString))
464        return LESSTHAN;
465      if ("empty".equals(codeString))
466        return EMPTY;
467      if ("notEmpty".equals(codeString))
468        return NOTEMPTY;
469      if ("contains".equals(codeString))
470        return CONTAINS;
471      if ("notContains".equals(codeString))
472        return NOTCONTAINS;
473      if ("eval".equals(codeString))
474        return EVAL;
475      if (Configuration.isAcceptInvalidEnums())
476        return null;
477      else
478        throw new FHIRException("Unknown AssertionOperatorType code '" + codeString + "'");
479    }
480
481    public String toCode() {
482      switch (this) {
483      case EQUALS:
484        return "equals";
485      case NOTEQUALS:
486        return "notEquals";
487      case IN:
488        return "in";
489      case NOTIN:
490        return "notIn";
491      case GREATERTHAN:
492        return "greaterThan";
493      case LESSTHAN:
494        return "lessThan";
495      case EMPTY:
496        return "empty";
497      case NOTEMPTY:
498        return "notEmpty";
499      case CONTAINS:
500        return "contains";
501      case NOTCONTAINS:
502        return "notContains";
503      case EVAL:
504        return "eval";
505      case NULL:
506        return null;
507      default:
508        return "?";
509      }
510    }
511
512    public String getSystem() {
513      switch (this) {
514      case EQUALS:
515        return "http://hl7.org/fhir/assert-operator-codes";
516      case NOTEQUALS:
517        return "http://hl7.org/fhir/assert-operator-codes";
518      case IN:
519        return "http://hl7.org/fhir/assert-operator-codes";
520      case NOTIN:
521        return "http://hl7.org/fhir/assert-operator-codes";
522      case GREATERTHAN:
523        return "http://hl7.org/fhir/assert-operator-codes";
524      case LESSTHAN:
525        return "http://hl7.org/fhir/assert-operator-codes";
526      case EMPTY:
527        return "http://hl7.org/fhir/assert-operator-codes";
528      case NOTEMPTY:
529        return "http://hl7.org/fhir/assert-operator-codes";
530      case CONTAINS:
531        return "http://hl7.org/fhir/assert-operator-codes";
532      case NOTCONTAINS:
533        return "http://hl7.org/fhir/assert-operator-codes";
534      case EVAL:
535        return "http://hl7.org/fhir/assert-operator-codes";
536      case NULL:
537        return null;
538      default:
539        return "?";
540      }
541    }
542
543    public String getDefinition() {
544      switch (this) {
545      case EQUALS:
546        return "Default value. Equals comparison.";
547      case NOTEQUALS:
548        return "Not equals comparison.";
549      case IN:
550        return "Compare value within a known set of values.";
551      case NOTIN:
552        return "Compare value not within a known set of values.";
553      case GREATERTHAN:
554        return "Compare value to be greater than a known value.";
555      case LESSTHAN:
556        return "Compare value to be less than a known value.";
557      case EMPTY:
558        return "Compare value is empty.";
559      case NOTEMPTY:
560        return "Compare value is not empty.";
561      case CONTAINS:
562        return "Compare value string contains a known value.";
563      case NOTCONTAINS:
564        return "Compare value string does not contain a known value.";
565      case EVAL:
566        return "Evaluate the FHIRPath expression as a boolean condition.";
567      case NULL:
568        return null;
569      default:
570        return "?";
571      }
572    }
573
574    public String getDisplay() {
575      switch (this) {
576      case EQUALS:
577        return "equals";
578      case NOTEQUALS:
579        return "notEquals";
580      case IN:
581        return "in";
582      case NOTIN:
583        return "notIn";
584      case GREATERTHAN:
585        return "greaterThan";
586      case LESSTHAN:
587        return "lessThan";
588      case EMPTY:
589        return "empty";
590      case NOTEMPTY:
591        return "notEmpty";
592      case CONTAINS:
593        return "contains";
594      case NOTCONTAINS:
595        return "notContains";
596      case EVAL:
597        return "evaluate";
598      case NULL:
599        return null;
600      default:
601        return "?";
602      }
603    }
604  }
605
606  public static class AssertionOperatorTypeEnumFactory implements EnumFactory<AssertionOperatorType> {
607    public AssertionOperatorType fromCode(String codeString) throws IllegalArgumentException {
608      if (codeString == null || "".equals(codeString))
609        if (codeString == null || "".equals(codeString))
610          return null;
611      if ("equals".equals(codeString))
612        return AssertionOperatorType.EQUALS;
613      if ("notEquals".equals(codeString))
614        return AssertionOperatorType.NOTEQUALS;
615      if ("in".equals(codeString))
616        return AssertionOperatorType.IN;
617      if ("notIn".equals(codeString))
618        return AssertionOperatorType.NOTIN;
619      if ("greaterThan".equals(codeString))
620        return AssertionOperatorType.GREATERTHAN;
621      if ("lessThan".equals(codeString))
622        return AssertionOperatorType.LESSTHAN;
623      if ("empty".equals(codeString))
624        return AssertionOperatorType.EMPTY;
625      if ("notEmpty".equals(codeString))
626        return AssertionOperatorType.NOTEMPTY;
627      if ("contains".equals(codeString))
628        return AssertionOperatorType.CONTAINS;
629      if ("notContains".equals(codeString))
630        return AssertionOperatorType.NOTCONTAINS;
631      if ("eval".equals(codeString))
632        return AssertionOperatorType.EVAL;
633      throw new IllegalArgumentException("Unknown AssertionOperatorType code '" + codeString + "'");
634    }
635
636    public Enumeration<AssertionOperatorType> fromType(PrimitiveType<?> code) throws FHIRException {
637      if (code == null)
638        return null;
639      if (code.isEmpty())
640        return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.NULL, code);
641      String codeString = code.asStringValue();
642      if (codeString == null || "".equals(codeString))
643        return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.NULL, code);
644      if ("equals".equals(codeString))
645        return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.EQUALS, code);
646      if ("notEquals".equals(codeString))
647        return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.NOTEQUALS, code);
648      if ("in".equals(codeString))
649        return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.IN, code);
650      if ("notIn".equals(codeString))
651        return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.NOTIN, code);
652      if ("greaterThan".equals(codeString))
653        return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.GREATERTHAN, code);
654      if ("lessThan".equals(codeString))
655        return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.LESSTHAN, code);
656      if ("empty".equals(codeString))
657        return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.EMPTY, code);
658      if ("notEmpty".equals(codeString))
659        return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.NOTEMPTY, code);
660      if ("contains".equals(codeString))
661        return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.CONTAINS, code);
662      if ("notContains".equals(codeString))
663        return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.NOTCONTAINS, code);
664      if ("eval".equals(codeString))
665        return new Enumeration<AssertionOperatorType>(this, AssertionOperatorType.EVAL, code);
666      throw new FHIRException("Unknown AssertionOperatorType code '" + codeString + "'");
667    }
668
669    public String toCode(AssertionOperatorType code) {
670      if (code == AssertionOperatorType.EQUALS)
671        return "equals";
672      if (code == AssertionOperatorType.NOTEQUALS)
673        return "notEquals";
674      if (code == AssertionOperatorType.IN)
675        return "in";
676      if (code == AssertionOperatorType.NOTIN)
677        return "notIn";
678      if (code == AssertionOperatorType.GREATERTHAN)
679        return "greaterThan";
680      if (code == AssertionOperatorType.LESSTHAN)
681        return "lessThan";
682      if (code == AssertionOperatorType.EMPTY)
683        return "empty";
684      if (code == AssertionOperatorType.NOTEMPTY)
685        return "notEmpty";
686      if (code == AssertionOperatorType.CONTAINS)
687        return "contains";
688      if (code == AssertionOperatorType.NOTCONTAINS)
689        return "notContains";
690      if (code == AssertionOperatorType.EVAL)
691        return "eval";
692      return "?";
693    }
694
695    public String toSystem(AssertionOperatorType code) {
696      return code.getSystem();
697    }
698  }
699
700  public enum AssertionResponseTypes {
701    /**
702     * Response code is 200.
703     */
704    OKAY,
705    /**
706     * Response code is 201.
707     */
708    CREATED,
709    /**
710     * Response code is 204.
711     */
712    NOCONTENT,
713    /**
714     * Response code is 304.
715     */
716    NOTMODIFIED,
717    /**
718     * Response code is 400.
719     */
720    BAD,
721    /**
722     * Response code is 403.
723     */
724    FORBIDDEN,
725    /**
726     * Response code is 404.
727     */
728    NOTFOUND,
729    /**
730     * Response code is 405.
731     */
732    METHODNOTALLOWED,
733    /**
734     * Response code is 409.
735     */
736    CONFLICT,
737    /**
738     * Response code is 410.
739     */
740    GONE,
741    /**
742     * Response code is 412.
743     */
744    PRECONDITIONFAILED,
745    /**
746     * Response code is 422.
747     */
748    UNPROCESSABLE,
749    /**
750     * added to help the parsers with the generic types
751     */
752    NULL;
753
754    public static AssertionResponseTypes fromCode(String codeString) throws FHIRException {
755      if (codeString == null || "".equals(codeString))
756        return null;
757      if ("okay".equals(codeString))
758        return OKAY;
759      if ("created".equals(codeString))
760        return CREATED;
761      if ("noContent".equals(codeString))
762        return NOCONTENT;
763      if ("notModified".equals(codeString))
764        return NOTMODIFIED;
765      if ("bad".equals(codeString))
766        return BAD;
767      if ("forbidden".equals(codeString))
768        return FORBIDDEN;
769      if ("notFound".equals(codeString))
770        return NOTFOUND;
771      if ("methodNotAllowed".equals(codeString))
772        return METHODNOTALLOWED;
773      if ("conflict".equals(codeString))
774        return CONFLICT;
775      if ("gone".equals(codeString))
776        return GONE;
777      if ("preconditionFailed".equals(codeString))
778        return PRECONDITIONFAILED;
779      if ("unprocessable".equals(codeString))
780        return UNPROCESSABLE;
781      if (Configuration.isAcceptInvalidEnums())
782        return null;
783      else
784        throw new FHIRException("Unknown AssertionResponseTypes code '" + codeString + "'");
785    }
786
787    public String toCode() {
788      switch (this) {
789      case OKAY:
790        return "okay";
791      case CREATED:
792        return "created";
793      case NOCONTENT:
794        return "noContent";
795      case NOTMODIFIED:
796        return "notModified";
797      case BAD:
798        return "bad";
799      case FORBIDDEN:
800        return "forbidden";
801      case NOTFOUND:
802        return "notFound";
803      case METHODNOTALLOWED:
804        return "methodNotAllowed";
805      case CONFLICT:
806        return "conflict";
807      case GONE:
808        return "gone";
809      case PRECONDITIONFAILED:
810        return "preconditionFailed";
811      case UNPROCESSABLE:
812        return "unprocessable";
813      case NULL:
814        return null;
815      default:
816        return "?";
817      }
818    }
819
820    public String getSystem() {
821      switch (this) {
822      case OKAY:
823        return "http://hl7.org/fhir/assert-response-code-types";
824      case CREATED:
825        return "http://hl7.org/fhir/assert-response-code-types";
826      case NOCONTENT:
827        return "http://hl7.org/fhir/assert-response-code-types";
828      case NOTMODIFIED:
829        return "http://hl7.org/fhir/assert-response-code-types";
830      case BAD:
831        return "http://hl7.org/fhir/assert-response-code-types";
832      case FORBIDDEN:
833        return "http://hl7.org/fhir/assert-response-code-types";
834      case NOTFOUND:
835        return "http://hl7.org/fhir/assert-response-code-types";
836      case METHODNOTALLOWED:
837        return "http://hl7.org/fhir/assert-response-code-types";
838      case CONFLICT:
839        return "http://hl7.org/fhir/assert-response-code-types";
840      case GONE:
841        return "http://hl7.org/fhir/assert-response-code-types";
842      case PRECONDITIONFAILED:
843        return "http://hl7.org/fhir/assert-response-code-types";
844      case UNPROCESSABLE:
845        return "http://hl7.org/fhir/assert-response-code-types";
846      case NULL:
847        return null;
848      default:
849        return "?";
850      }
851    }
852
853    public String getDefinition() {
854      switch (this) {
855      case OKAY:
856        return "Response code is 200.";
857      case CREATED:
858        return "Response code is 201.";
859      case NOCONTENT:
860        return "Response code is 204.";
861      case NOTMODIFIED:
862        return "Response code is 304.";
863      case BAD:
864        return "Response code is 400.";
865      case FORBIDDEN:
866        return "Response code is 403.";
867      case NOTFOUND:
868        return "Response code is 404.";
869      case METHODNOTALLOWED:
870        return "Response code is 405.";
871      case CONFLICT:
872        return "Response code is 409.";
873      case GONE:
874        return "Response code is 410.";
875      case PRECONDITIONFAILED:
876        return "Response code is 412.";
877      case UNPROCESSABLE:
878        return "Response code is 422.";
879      case NULL:
880        return null;
881      default:
882        return "?";
883      }
884    }
885
886    public String getDisplay() {
887      switch (this) {
888      case OKAY:
889        return "okay";
890      case CREATED:
891        return "created";
892      case NOCONTENT:
893        return "noContent";
894      case NOTMODIFIED:
895        return "notModified";
896      case BAD:
897        return "bad";
898      case FORBIDDEN:
899        return "forbidden";
900      case NOTFOUND:
901        return "notFound";
902      case METHODNOTALLOWED:
903        return "methodNotAllowed";
904      case CONFLICT:
905        return "conflict";
906      case GONE:
907        return "gone";
908      case PRECONDITIONFAILED:
909        return "preconditionFailed";
910      case UNPROCESSABLE:
911        return "unprocessable";
912      case NULL:
913        return null;
914      default:
915        return "?";
916      }
917    }
918  }
919
920  public static class AssertionResponseTypesEnumFactory implements EnumFactory<AssertionResponseTypes> {
921    public AssertionResponseTypes fromCode(String codeString) throws IllegalArgumentException {
922      if (codeString == null || "".equals(codeString))
923        if (codeString == null || "".equals(codeString))
924          return null;
925      if ("okay".equals(codeString))
926        return AssertionResponseTypes.OKAY;
927      if ("created".equals(codeString))
928        return AssertionResponseTypes.CREATED;
929      if ("noContent".equals(codeString))
930        return AssertionResponseTypes.NOCONTENT;
931      if ("notModified".equals(codeString))
932        return AssertionResponseTypes.NOTMODIFIED;
933      if ("bad".equals(codeString))
934        return AssertionResponseTypes.BAD;
935      if ("forbidden".equals(codeString))
936        return AssertionResponseTypes.FORBIDDEN;
937      if ("notFound".equals(codeString))
938        return AssertionResponseTypes.NOTFOUND;
939      if ("methodNotAllowed".equals(codeString))
940        return AssertionResponseTypes.METHODNOTALLOWED;
941      if ("conflict".equals(codeString))
942        return AssertionResponseTypes.CONFLICT;
943      if ("gone".equals(codeString))
944        return AssertionResponseTypes.GONE;
945      if ("preconditionFailed".equals(codeString))
946        return AssertionResponseTypes.PRECONDITIONFAILED;
947      if ("unprocessable".equals(codeString))
948        return AssertionResponseTypes.UNPROCESSABLE;
949      throw new IllegalArgumentException("Unknown AssertionResponseTypes code '" + codeString + "'");
950    }
951
952    public Enumeration<AssertionResponseTypes> fromType(PrimitiveType<?> code) throws FHIRException {
953      if (code == null)
954        return null;
955      if (code.isEmpty())
956        return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.NULL, code);
957      String codeString = code.asStringValue();
958      if (codeString == null || "".equals(codeString))
959        return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.NULL, code);
960      if ("okay".equals(codeString))
961        return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.OKAY, code);
962      if ("created".equals(codeString))
963        return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.CREATED, code);
964      if ("noContent".equals(codeString))
965        return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.NOCONTENT, code);
966      if ("notModified".equals(codeString))
967        return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.NOTMODIFIED, code);
968      if ("bad".equals(codeString))
969        return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.BAD, code);
970      if ("forbidden".equals(codeString))
971        return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.FORBIDDEN, code);
972      if ("notFound".equals(codeString))
973        return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.NOTFOUND, code);
974      if ("methodNotAllowed".equals(codeString))
975        return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.METHODNOTALLOWED, code);
976      if ("conflict".equals(codeString))
977        return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.CONFLICT, code);
978      if ("gone".equals(codeString))
979        return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.GONE, code);
980      if ("preconditionFailed".equals(codeString))
981        return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.PRECONDITIONFAILED, code);
982      if ("unprocessable".equals(codeString))
983        return new Enumeration<AssertionResponseTypes>(this, AssertionResponseTypes.UNPROCESSABLE, code);
984      throw new FHIRException("Unknown AssertionResponseTypes code '" + codeString + "'");
985    }
986
987    public String toCode(AssertionResponseTypes code) {
988      if (code == AssertionResponseTypes.OKAY)
989        return "okay";
990      if (code == AssertionResponseTypes.CREATED)
991        return "created";
992      if (code == AssertionResponseTypes.NOCONTENT)
993        return "noContent";
994      if (code == AssertionResponseTypes.NOTMODIFIED)
995        return "notModified";
996      if (code == AssertionResponseTypes.BAD)
997        return "bad";
998      if (code == AssertionResponseTypes.FORBIDDEN)
999        return "forbidden";
1000      if (code == AssertionResponseTypes.NOTFOUND)
1001        return "notFound";
1002      if (code == AssertionResponseTypes.METHODNOTALLOWED)
1003        return "methodNotAllowed";
1004      if (code == AssertionResponseTypes.CONFLICT)
1005        return "conflict";
1006      if (code == AssertionResponseTypes.GONE)
1007        return "gone";
1008      if (code == AssertionResponseTypes.PRECONDITIONFAILED)
1009        return "preconditionFailed";
1010      if (code == AssertionResponseTypes.UNPROCESSABLE)
1011        return "unprocessable";
1012      return "?";
1013    }
1014
1015    public String toSystem(AssertionResponseTypes code) {
1016      return code.getSystem();
1017    }
1018  }
1019
1020  @Block()
1021  public static class TestScriptOriginComponent extends BackboneElement implements IBaseBackboneElement {
1022    /**
1023     * Abstract name given to an origin server in this test script. The name is
1024     * provided as a number starting at 1.
1025     */
1026    @Child(name = "index", type = { IntegerType.class }, order = 1, min = 1, max = 1, modifier = false, summary = false)
1027    @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.")
1028    protected IntegerType index;
1029
1030    /**
1031     * The type of origin profile the test system supports.
1032     */
1033    @Child(name = "profile", type = { Coding.class }, order = 2, min = 1, max = 1, modifier = false, summary = false)
1034    @Description(shortDefinition = "FHIR-Client | FHIR-SDC-FormFiller", formalDefinition = "The type of origin profile the test system supports.")
1035    @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/testscript-profile-origin-types")
1036    protected Coding profile;
1037
1038    private static final long serialVersionUID = -1239935149L;
1039
1040    /**
1041     * Constructor
1042     */
1043    public TestScriptOriginComponent() {
1044      super();
1045    }
1046
1047    /**
1048     * Constructor
1049     */
1050    public TestScriptOriginComponent(IntegerType index, Coding profile) {
1051      super();
1052      this.index = index;
1053      this.profile = profile;
1054    }
1055
1056    /**
1057     * @return {@link #index} (Abstract name given to an origin server in this test
1058     *         script. The name is provided as a number starting at 1.). This is the
1059     *         underlying object with id, value and extensions. The accessor
1060     *         "getIndex" gives direct access to the value
1061     */
1062    public IntegerType getIndexElement() {
1063      if (this.index == null)
1064        if (Configuration.errorOnAutoCreate())
1065          throw new Error("Attempt to auto-create TestScriptOriginComponent.index");
1066        else if (Configuration.doAutoCreate())
1067          this.index = new IntegerType(); // bb
1068      return this.index;
1069    }
1070
1071    public boolean hasIndexElement() {
1072      return this.index != null && !this.index.isEmpty();
1073    }
1074
1075    public boolean hasIndex() {
1076      return this.index != null && !this.index.isEmpty();
1077    }
1078
1079    /**
1080     * @param value {@link #index} (Abstract name given to an origin server in this
1081     *              test script. The name is provided as a number starting at 1.).
1082     *              This is the underlying object with id, value and extensions. The
1083     *              accessor "getIndex" gives direct access to the value
1084     */
1085    public TestScriptOriginComponent setIndexElement(IntegerType value) {
1086      this.index = value;
1087      return this;
1088    }
1089
1090    /**
1091     * @return Abstract name given to an origin server in this test script. The name
1092     *         is provided as a number starting at 1.
1093     */
1094    public int getIndex() {
1095      return this.index == null || this.index.isEmpty() ? 0 : this.index.getValue();
1096    }
1097
1098    /**
1099     * @param value Abstract name given to an origin server in this test script. The
1100     *              name is provided as a number starting at 1.
1101     */
1102    public TestScriptOriginComponent setIndex(int value) {
1103      if (this.index == null)
1104        this.index = new IntegerType();
1105      this.index.setValue(value);
1106      return this;
1107    }
1108
1109    /**
1110     * @return {@link #profile} (The type of origin profile the test system
1111     *         supports.)
1112     */
1113    public Coding getProfile() {
1114      if (this.profile == null)
1115        if (Configuration.errorOnAutoCreate())
1116          throw new Error("Attempt to auto-create TestScriptOriginComponent.profile");
1117        else if (Configuration.doAutoCreate())
1118          this.profile = new Coding(); // cc
1119      return this.profile;
1120    }
1121
1122    public boolean hasProfile() {
1123      return this.profile != null && !this.profile.isEmpty();
1124    }
1125
1126    /**
1127     * @param value {@link #profile} (The type of origin profile the test system
1128     *              supports.)
1129     */
1130    public TestScriptOriginComponent setProfile(Coding value) {
1131      this.profile = value;
1132      return this;
1133    }
1134
1135    protected void listChildren(List<Property> children) {
1136      super.listChildren(children);
1137      children.add(new Property("index", "integer",
1138          "Abstract name given to an origin server in this test script.  The name is provided as a number starting at 1.",
1139          0, 1, index));
1140      children.add(
1141          new Property("profile", "Coding", "The type of origin profile the test system supports.", 0, 1, profile));
1142    }
1143
1144    @Override
1145    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1146      switch (_hash) {
1147      case 100346066:
1148        /* index */ return new Property("index", "integer",
1149            "Abstract name given to an origin server in this test script.  The name is provided as a number starting at 1.",
1150            0, 1, index);
1151      case -309425751:
1152        /* profile */ return new Property("profile", "Coding", "The type of origin profile the test system supports.",
1153            0, 1, profile);
1154      default:
1155        return super.getNamedProperty(_hash, _name, _checkValid);
1156      }
1157
1158    }
1159
1160    @Override
1161    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1162      switch (hash) {
1163      case 100346066:
1164        /* index */ return this.index == null ? new Base[0] : new Base[] { this.index }; // IntegerType
1165      case -309425751:
1166        /* profile */ return this.profile == null ? new Base[0] : new Base[] { this.profile }; // Coding
1167      default:
1168        return super.getProperty(hash, name, checkValid);
1169      }
1170
1171    }
1172
1173    @Override
1174    public Base setProperty(int hash, String name, Base value) throws FHIRException {
1175      switch (hash) {
1176      case 100346066: // index
1177        this.index = castToInteger(value); // IntegerType
1178        return value;
1179      case -309425751: // profile
1180        this.profile = castToCoding(value); // Coding
1181        return value;
1182      default:
1183        return super.setProperty(hash, name, value);
1184      }
1185
1186    }
1187
1188    @Override
1189    public Base setProperty(String name, Base value) throws FHIRException {
1190      if (name.equals("index")) {
1191        this.index = castToInteger(value); // IntegerType
1192      } else if (name.equals("profile")) {
1193        this.profile = castToCoding(value); // Coding
1194      } else
1195        return super.setProperty(name, value);
1196      return value;
1197    }
1198
1199    @Override
1200    public Base makeProperty(int hash, String name) throws FHIRException {
1201      switch (hash) {
1202      case 100346066:
1203        return getIndexElement();
1204      case -309425751:
1205        return getProfile();
1206      default:
1207        return super.makeProperty(hash, name);
1208      }
1209
1210    }
1211
1212    @Override
1213    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1214      switch (hash) {
1215      case 100346066:
1216        /* index */ return new String[] { "integer" };
1217      case -309425751:
1218        /* profile */ return new String[] { "Coding" };
1219      default:
1220        return super.getTypesForProperty(hash, name);
1221      }
1222
1223    }
1224
1225    @Override
1226    public Base addChild(String name) throws FHIRException {
1227      if (name.equals("index")) {
1228        throw new FHIRException("Cannot call addChild on a singleton property TestScript.index");
1229      } else if (name.equals("profile")) {
1230        this.profile = new Coding();
1231        return this.profile;
1232      } else
1233        return super.addChild(name);
1234    }
1235
1236    public TestScriptOriginComponent copy() {
1237      TestScriptOriginComponent dst = new TestScriptOriginComponent();
1238      copyValues(dst);
1239      return dst;
1240    }
1241
1242    public void copyValues(TestScriptOriginComponent dst) {
1243      super.copyValues(dst);
1244      dst.index = index == null ? null : index.copy();
1245      dst.profile = profile == null ? null : profile.copy();
1246    }
1247
1248    @Override
1249    public boolean equalsDeep(Base other_) {
1250      if (!super.equalsDeep(other_))
1251        return false;
1252      if (!(other_ instanceof TestScriptOriginComponent))
1253        return false;
1254      TestScriptOriginComponent o = (TestScriptOriginComponent) other_;
1255      return compareDeep(index, o.index, true) && compareDeep(profile, o.profile, true);
1256    }
1257
1258    @Override
1259    public boolean equalsShallow(Base other_) {
1260      if (!super.equalsShallow(other_))
1261        return false;
1262      if (!(other_ instanceof TestScriptOriginComponent))
1263        return false;
1264      TestScriptOriginComponent o = (TestScriptOriginComponent) other_;
1265      return compareValues(index, o.index, true);
1266    }
1267
1268    public boolean isEmpty() {
1269      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(index, profile);
1270    }
1271
1272    public String fhirType() {
1273      return "TestScript.origin";
1274
1275    }
1276
1277  }
1278
1279  @Block()
1280  public static class TestScriptDestinationComponent extends BackboneElement implements IBaseBackboneElement {
1281    /**
1282     * Abstract name given to a destination server in this test script. The name is
1283     * provided as a number starting at 1.
1284     */
1285    @Child(name = "index", type = { IntegerType.class }, order = 1, min = 1, max = 1, modifier = false, summary = false)
1286    @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.")
1287    protected IntegerType index;
1288
1289    /**
1290     * The type of destination profile the test system supports.
1291     */
1292    @Child(name = "profile", type = { Coding.class }, order = 2, min = 1, max = 1, modifier = false, summary = false)
1293    @Description(shortDefinition = "FHIR-Server | FHIR-SDC-FormManager | FHIR-SDC-FormReceiver | FHIR-SDC-FormProcessor", formalDefinition = "The type of destination profile the test system supports.")
1294    @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/testscript-profile-destination-types")
1295    protected Coding profile;
1296
1297    private static final long serialVersionUID = -1239935149L;
1298
1299    /**
1300     * Constructor
1301     */
1302    public TestScriptDestinationComponent() {
1303      super();
1304    }
1305
1306    /**
1307     * Constructor
1308     */
1309    public TestScriptDestinationComponent(IntegerType index, Coding profile) {
1310      super();
1311      this.index = index;
1312      this.profile = profile;
1313    }
1314
1315    /**
1316     * @return {@link #index} (Abstract name given to a destination server in this
1317     *         test script. The name is provided as a number starting at 1.). This
1318     *         is the underlying object with id, value and extensions. The accessor
1319     *         "getIndex" gives direct access to the value
1320     */
1321    public IntegerType getIndexElement() {
1322      if (this.index == null)
1323        if (Configuration.errorOnAutoCreate())
1324          throw new Error("Attempt to auto-create TestScriptDestinationComponent.index");
1325        else if (Configuration.doAutoCreate())
1326          this.index = new IntegerType(); // bb
1327      return this.index;
1328    }
1329
1330    public boolean hasIndexElement() {
1331      return this.index != null && !this.index.isEmpty();
1332    }
1333
1334    public boolean hasIndex() {
1335      return this.index != null && !this.index.isEmpty();
1336    }
1337
1338    /**
1339     * @param value {@link #index} (Abstract name given to a destination server in
1340     *              this test script. The name is provided as a number starting at
1341     *              1.). This is the underlying object with id, value and
1342     *              extensions. The accessor "getIndex" gives direct access to the
1343     *              value
1344     */
1345    public TestScriptDestinationComponent setIndexElement(IntegerType value) {
1346      this.index = value;
1347      return this;
1348    }
1349
1350    /**
1351     * @return Abstract name given to a destination server in this test script. The
1352     *         name is provided as a number starting at 1.
1353     */
1354    public int getIndex() {
1355      return this.index == null || this.index.isEmpty() ? 0 : this.index.getValue();
1356    }
1357
1358    /**
1359     * @param value Abstract name given to a destination server in this test script.
1360     *              The name is provided as a number starting at 1.
1361     */
1362    public TestScriptDestinationComponent setIndex(int value) {
1363      if (this.index == null)
1364        this.index = new IntegerType();
1365      this.index.setValue(value);
1366      return this;
1367    }
1368
1369    /**
1370     * @return {@link #profile} (The type of destination profile the test system
1371     *         supports.)
1372     */
1373    public Coding getProfile() {
1374      if (this.profile == null)
1375        if (Configuration.errorOnAutoCreate())
1376          throw new Error("Attempt to auto-create TestScriptDestinationComponent.profile");
1377        else if (Configuration.doAutoCreate())
1378          this.profile = new Coding(); // cc
1379      return this.profile;
1380    }
1381
1382    public boolean hasProfile() {
1383      return this.profile != null && !this.profile.isEmpty();
1384    }
1385
1386    /**
1387     * @param value {@link #profile} (The type of destination profile the test
1388     *              system supports.)
1389     */
1390    public TestScriptDestinationComponent setProfile(Coding value) {
1391      this.profile = value;
1392      return this;
1393    }
1394
1395    protected void listChildren(List<Property> children) {
1396      super.listChildren(children);
1397      children.add(new Property("index", "integer",
1398          "Abstract name given to a destination server in this test script.  The name is provided as a number starting at 1.",
1399          0, 1, index));
1400      children.add(new Property("profile", "Coding", "The type of destination profile the test system supports.", 0, 1,
1401          profile));
1402    }
1403
1404    @Override
1405    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1406      switch (_hash) {
1407      case 100346066:
1408        /* index */ return new Property("index", "integer",
1409            "Abstract name given to a destination server in this test script.  The name is provided as a number starting at 1.",
1410            0, 1, index);
1411      case -309425751:
1412        /* profile */ return new Property("profile", "Coding",
1413            "The type of destination profile the test system supports.", 0, 1, profile);
1414      default:
1415        return super.getNamedProperty(_hash, _name, _checkValid);
1416      }
1417
1418    }
1419
1420    @Override
1421    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1422      switch (hash) {
1423      case 100346066:
1424        /* index */ return this.index == null ? new Base[0] : new Base[] { this.index }; // IntegerType
1425      case -309425751:
1426        /* profile */ return this.profile == null ? new Base[0] : new Base[] { this.profile }; // Coding
1427      default:
1428        return super.getProperty(hash, name, checkValid);
1429      }
1430
1431    }
1432
1433    @Override
1434    public Base setProperty(int hash, String name, Base value) throws FHIRException {
1435      switch (hash) {
1436      case 100346066: // index
1437        this.index = castToInteger(value); // IntegerType
1438        return value;
1439      case -309425751: // profile
1440        this.profile = castToCoding(value); // Coding
1441        return value;
1442      default:
1443        return super.setProperty(hash, name, value);
1444      }
1445
1446    }
1447
1448    @Override
1449    public Base setProperty(String name, Base value) throws FHIRException {
1450      if (name.equals("index")) {
1451        this.index = castToInteger(value); // IntegerType
1452      } else if (name.equals("profile")) {
1453        this.profile = castToCoding(value); // Coding
1454      } else
1455        return super.setProperty(name, value);
1456      return value;
1457    }
1458
1459    @Override
1460    public Base makeProperty(int hash, String name) throws FHIRException {
1461      switch (hash) {
1462      case 100346066:
1463        return getIndexElement();
1464      case -309425751:
1465        return getProfile();
1466      default:
1467        return super.makeProperty(hash, name);
1468      }
1469
1470    }
1471
1472    @Override
1473    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1474      switch (hash) {
1475      case 100346066:
1476        /* index */ return new String[] { "integer" };
1477      case -309425751:
1478        /* profile */ return new String[] { "Coding" };
1479      default:
1480        return super.getTypesForProperty(hash, name);
1481      }
1482
1483    }
1484
1485    @Override
1486    public Base addChild(String name) throws FHIRException {
1487      if (name.equals("index")) {
1488        throw new FHIRException("Cannot call addChild on a singleton property TestScript.index");
1489      } else if (name.equals("profile")) {
1490        this.profile = new Coding();
1491        return this.profile;
1492      } else
1493        return super.addChild(name);
1494    }
1495
1496    public TestScriptDestinationComponent copy() {
1497      TestScriptDestinationComponent dst = new TestScriptDestinationComponent();
1498      copyValues(dst);
1499      return dst;
1500    }
1501
1502    public void copyValues(TestScriptDestinationComponent dst) {
1503      super.copyValues(dst);
1504      dst.index = index == null ? null : index.copy();
1505      dst.profile = profile == null ? null : profile.copy();
1506    }
1507
1508    @Override
1509    public boolean equalsDeep(Base other_) {
1510      if (!super.equalsDeep(other_))
1511        return false;
1512      if (!(other_ instanceof TestScriptDestinationComponent))
1513        return false;
1514      TestScriptDestinationComponent o = (TestScriptDestinationComponent) other_;
1515      return compareDeep(index, o.index, true) && compareDeep(profile, o.profile, true);
1516    }
1517
1518    @Override
1519    public boolean equalsShallow(Base other_) {
1520      if (!super.equalsShallow(other_))
1521        return false;
1522      if (!(other_ instanceof TestScriptDestinationComponent))
1523        return false;
1524      TestScriptDestinationComponent o = (TestScriptDestinationComponent) other_;
1525      return compareValues(index, o.index, true);
1526    }
1527
1528    public boolean isEmpty() {
1529      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(index, profile);
1530    }
1531
1532    public String fhirType() {
1533      return "TestScript.destination";
1534
1535    }
1536
1537  }
1538
1539  @Block()
1540  public static class TestScriptMetadataComponent extends BackboneElement implements IBaseBackboneElement {
1541    /**
1542     * A link to the FHIR specification that this test is covering.
1543     */
1544    @Child(name = "link", type = {}, order = 1, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false)
1545    @Description(shortDefinition = "Links to the FHIR specification", formalDefinition = "A link to the FHIR specification that this test is covering.")
1546    protected List<TestScriptMetadataLinkComponent> link;
1547
1548    /**
1549     * Capabilities that must exist and are assumed to function correctly on the
1550     * FHIR server being tested.
1551     */
1552    @Child(name = "capability", type = {}, order = 2, min = 1, max = Child.MAX_UNLIMITED, modifier = false, summary = false)
1553    @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.")
1554    protected List<TestScriptMetadataCapabilityComponent> capability;
1555
1556    private static final long serialVersionUID = 745183328L;
1557
1558    /**
1559     * Constructor
1560     */
1561    public TestScriptMetadataComponent() {
1562      super();
1563    }
1564
1565    /**
1566     * @return {@link #link} (A link to the FHIR specification that this test is
1567     *         covering.)
1568     */
1569    public List<TestScriptMetadataLinkComponent> getLink() {
1570      if (this.link == null)
1571        this.link = new ArrayList<TestScriptMetadataLinkComponent>();
1572      return this.link;
1573    }
1574
1575    /**
1576     * @return Returns a reference to <code>this</code> for easy method chaining
1577     */
1578    public TestScriptMetadataComponent setLink(List<TestScriptMetadataLinkComponent> theLink) {
1579      this.link = theLink;
1580      return this;
1581    }
1582
1583    public boolean hasLink() {
1584      if (this.link == null)
1585        return false;
1586      for (TestScriptMetadataLinkComponent item : this.link)
1587        if (!item.isEmpty())
1588          return true;
1589      return false;
1590    }
1591
1592    public TestScriptMetadataLinkComponent addLink() { // 3
1593      TestScriptMetadataLinkComponent t = new TestScriptMetadataLinkComponent();
1594      if (this.link == null)
1595        this.link = new ArrayList<TestScriptMetadataLinkComponent>();
1596      this.link.add(t);
1597      return t;
1598    }
1599
1600    public TestScriptMetadataComponent addLink(TestScriptMetadataLinkComponent t) { // 3
1601      if (t == null)
1602        return this;
1603      if (this.link == null)
1604        this.link = new ArrayList<TestScriptMetadataLinkComponent>();
1605      this.link.add(t);
1606      return this;
1607    }
1608
1609    /**
1610     * @return The first repetition of repeating field {@link #link}, creating it if
1611     *         it does not already exist
1612     */
1613    public TestScriptMetadataLinkComponent getLinkFirstRep() {
1614      if (getLink().isEmpty()) {
1615        addLink();
1616      }
1617      return getLink().get(0);
1618    }
1619
1620    /**
1621     * @return {@link #capability} (Capabilities that must exist and are assumed to
1622     *         function correctly on the FHIR server being tested.)
1623     */
1624    public List<TestScriptMetadataCapabilityComponent> getCapability() {
1625      if (this.capability == null)
1626        this.capability = new ArrayList<TestScriptMetadataCapabilityComponent>();
1627      return this.capability;
1628    }
1629
1630    /**
1631     * @return Returns a reference to <code>this</code> for easy method chaining
1632     */
1633    public TestScriptMetadataComponent setCapability(List<TestScriptMetadataCapabilityComponent> theCapability) {
1634      this.capability = theCapability;
1635      return this;
1636    }
1637
1638    public boolean hasCapability() {
1639      if (this.capability == null)
1640        return false;
1641      for (TestScriptMetadataCapabilityComponent item : this.capability)
1642        if (!item.isEmpty())
1643          return true;
1644      return false;
1645    }
1646
1647    public TestScriptMetadataCapabilityComponent addCapability() { // 3
1648      TestScriptMetadataCapabilityComponent t = new TestScriptMetadataCapabilityComponent();
1649      if (this.capability == null)
1650        this.capability = new ArrayList<TestScriptMetadataCapabilityComponent>();
1651      this.capability.add(t);
1652      return t;
1653    }
1654
1655    public TestScriptMetadataComponent addCapability(TestScriptMetadataCapabilityComponent t) { // 3
1656      if (t == null)
1657        return this;
1658      if (this.capability == null)
1659        this.capability = new ArrayList<TestScriptMetadataCapabilityComponent>();
1660      this.capability.add(t);
1661      return this;
1662    }
1663
1664    /**
1665     * @return The first repetition of repeating field {@link #capability}, creating
1666     *         it if it does not already exist
1667     */
1668    public TestScriptMetadataCapabilityComponent getCapabilityFirstRep() {
1669      if (getCapability().isEmpty()) {
1670        addCapability();
1671      }
1672      return getCapability().get(0);
1673    }
1674
1675    protected void listChildren(List<Property> children) {
1676      super.listChildren(children);
1677      children.add(new Property("link", "", "A link to the FHIR specification that this test is covering.", 0,
1678          java.lang.Integer.MAX_VALUE, link));
1679      children.add(new Property("capability", "",
1680          "Capabilities that must exist and are assumed to function correctly on the FHIR server being tested.", 0,
1681          java.lang.Integer.MAX_VALUE, capability));
1682    }
1683
1684    @Override
1685    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1686      switch (_hash) {
1687      case 3321850:
1688        /* link */ return new Property("link", "", "A link to the FHIR specification that this test is covering.", 0,
1689            java.lang.Integer.MAX_VALUE, link);
1690      case -783669992:
1691        /* capability */ return new Property("capability", "",
1692            "Capabilities that must exist and are assumed to function correctly on the FHIR server being tested.", 0,
1693            java.lang.Integer.MAX_VALUE, capability);
1694      default:
1695        return super.getNamedProperty(_hash, _name, _checkValid);
1696      }
1697
1698    }
1699
1700    @Override
1701    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1702      switch (hash) {
1703      case 3321850:
1704        /* link */ return this.link == null ? new Base[0] : this.link.toArray(new Base[this.link.size()]); // TestScriptMetadataLinkComponent
1705      case -783669992:
1706        /* capability */ return this.capability == null ? new Base[0]
1707            : this.capability.toArray(new Base[this.capability.size()]); // TestScriptMetadataCapabilityComponent
1708      default:
1709        return super.getProperty(hash, name, checkValid);
1710      }
1711
1712    }
1713
1714    @Override
1715    public Base setProperty(int hash, String name, Base value) throws FHIRException {
1716      switch (hash) {
1717      case 3321850: // link
1718        this.getLink().add((TestScriptMetadataLinkComponent) value); // TestScriptMetadataLinkComponent
1719        return value;
1720      case -783669992: // capability
1721        this.getCapability().add((TestScriptMetadataCapabilityComponent) value); // TestScriptMetadataCapabilityComponent
1722        return value;
1723      default:
1724        return super.setProperty(hash, name, value);
1725      }
1726
1727    }
1728
1729    @Override
1730    public Base setProperty(String name, Base value) throws FHIRException {
1731      if (name.equals("link")) {
1732        this.getLink().add((TestScriptMetadataLinkComponent) value);
1733      } else if (name.equals("capability")) {
1734        this.getCapability().add((TestScriptMetadataCapabilityComponent) value);
1735      } else
1736        return super.setProperty(name, value);
1737      return value;
1738    }
1739
1740    @Override
1741    public Base makeProperty(int hash, String name) throws FHIRException {
1742      switch (hash) {
1743      case 3321850:
1744        return addLink();
1745      case -783669992:
1746        return addCapability();
1747      default:
1748        return super.makeProperty(hash, name);
1749      }
1750
1751    }
1752
1753    @Override
1754    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
1755      switch (hash) {
1756      case 3321850:
1757        /* link */ return new String[] {};
1758      case -783669992:
1759        /* capability */ return new String[] {};
1760      default:
1761        return super.getTypesForProperty(hash, name);
1762      }
1763
1764    }
1765
1766    @Override
1767    public Base addChild(String name) throws FHIRException {
1768      if (name.equals("link")) {
1769        return addLink();
1770      } else if (name.equals("capability")) {
1771        return addCapability();
1772      } else
1773        return super.addChild(name);
1774    }
1775
1776    public TestScriptMetadataComponent copy() {
1777      TestScriptMetadataComponent dst = new TestScriptMetadataComponent();
1778      copyValues(dst);
1779      return dst;
1780    }
1781
1782    public void copyValues(TestScriptMetadataComponent dst) {
1783      super.copyValues(dst);
1784      if (link != null) {
1785        dst.link = new ArrayList<TestScriptMetadataLinkComponent>();
1786        for (TestScriptMetadataLinkComponent i : link)
1787          dst.link.add(i.copy());
1788      }
1789      ;
1790      if (capability != null) {
1791        dst.capability = new ArrayList<TestScriptMetadataCapabilityComponent>();
1792        for (TestScriptMetadataCapabilityComponent i : capability)
1793          dst.capability.add(i.copy());
1794      }
1795      ;
1796    }
1797
1798    @Override
1799    public boolean equalsDeep(Base other_) {
1800      if (!super.equalsDeep(other_))
1801        return false;
1802      if (!(other_ instanceof TestScriptMetadataComponent))
1803        return false;
1804      TestScriptMetadataComponent o = (TestScriptMetadataComponent) other_;
1805      return compareDeep(link, o.link, true) && compareDeep(capability, o.capability, true);
1806    }
1807
1808    @Override
1809    public boolean equalsShallow(Base other_) {
1810      if (!super.equalsShallow(other_))
1811        return false;
1812      if (!(other_ instanceof TestScriptMetadataComponent))
1813        return false;
1814      TestScriptMetadataComponent o = (TestScriptMetadataComponent) other_;
1815      return true;
1816    }
1817
1818    public boolean isEmpty() {
1819      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(link, capability);
1820    }
1821
1822    public String fhirType() {
1823      return "TestScript.metadata";
1824
1825    }
1826
1827  }
1828
1829  @Block()
1830  public static class TestScriptMetadataLinkComponent extends BackboneElement implements IBaseBackboneElement {
1831    /**
1832     * URL to a particular requirement or feature within the FHIR specification.
1833     */
1834    @Child(name = "url", type = { UriType.class }, order = 1, min = 1, max = 1, modifier = false, summary = false)
1835    @Description(shortDefinition = "URL to the specification", formalDefinition = "URL to a particular requirement or feature within the FHIR specification.")
1836    protected UriType url;
1837
1838    /**
1839     * Short description of the link.
1840     */
1841    @Child(name = "description", type = {
1842        StringType.class }, order = 2, min = 0, max = 1, modifier = false, summary = false)
1843    @Description(shortDefinition = "Short description", formalDefinition = "Short description of the link.")
1844    protected StringType description;
1845
1846    private static final long serialVersionUID = 213372298L;
1847
1848    /**
1849     * Constructor
1850     */
1851    public TestScriptMetadataLinkComponent() {
1852      super();
1853    }
1854
1855    /**
1856     * Constructor
1857     */
1858    public TestScriptMetadataLinkComponent(UriType url) {
1859      super();
1860      this.url = url;
1861    }
1862
1863    /**
1864     * @return {@link #url} (URL to a particular requirement or feature within the
1865     *         FHIR specification.). This is the underlying object with id, value
1866     *         and extensions. The accessor "getUrl" gives direct access to the
1867     *         value
1868     */
1869    public UriType getUrlElement() {
1870      if (this.url == null)
1871        if (Configuration.errorOnAutoCreate())
1872          throw new Error("Attempt to auto-create TestScriptMetadataLinkComponent.url");
1873        else if (Configuration.doAutoCreate())
1874          this.url = new UriType(); // bb
1875      return this.url;
1876    }
1877
1878    public boolean hasUrlElement() {
1879      return this.url != null && !this.url.isEmpty();
1880    }
1881
1882    public boolean hasUrl() {
1883      return this.url != null && !this.url.isEmpty();
1884    }
1885
1886    /**
1887     * @param value {@link #url} (URL to a particular requirement or feature within
1888     *              the FHIR specification.). This is the underlying object with id,
1889     *              value and extensions. The accessor "getUrl" gives direct access
1890     *              to the value
1891     */
1892    public TestScriptMetadataLinkComponent setUrlElement(UriType value) {
1893      this.url = value;
1894      return this;
1895    }
1896
1897    /**
1898     * @return URL to a particular requirement or feature within the FHIR
1899     *         specification.
1900     */
1901    public String getUrl() {
1902      return this.url == null ? null : this.url.getValue();
1903    }
1904
1905    /**
1906     * @param value URL to a particular requirement or feature within the FHIR
1907     *              specification.
1908     */
1909    public TestScriptMetadataLinkComponent setUrl(String value) {
1910      if (this.url == null)
1911        this.url = new UriType();
1912      this.url.setValue(value);
1913      return this;
1914    }
1915
1916    /**
1917     * @return {@link #description} (Short description of the link.). This is the
1918     *         underlying object with id, value and extensions. The accessor
1919     *         "getDescription" gives direct access to the value
1920     */
1921    public StringType getDescriptionElement() {
1922      if (this.description == null)
1923        if (Configuration.errorOnAutoCreate())
1924          throw new Error("Attempt to auto-create TestScriptMetadataLinkComponent.description");
1925        else if (Configuration.doAutoCreate())
1926          this.description = new StringType(); // bb
1927      return this.description;
1928    }
1929
1930    public boolean hasDescriptionElement() {
1931      return this.description != null && !this.description.isEmpty();
1932    }
1933
1934    public boolean hasDescription() {
1935      return this.description != null && !this.description.isEmpty();
1936    }
1937
1938    /**
1939     * @param value {@link #description} (Short description of the link.). This is
1940     *              the underlying object with id, value and extensions. The
1941     *              accessor "getDescription" gives direct access to the value
1942     */
1943    public TestScriptMetadataLinkComponent setDescriptionElement(StringType value) {
1944      this.description = value;
1945      return this;
1946    }
1947
1948    /**
1949     * @return Short description of the link.
1950     */
1951    public String getDescription() {
1952      return this.description == null ? null : this.description.getValue();
1953    }
1954
1955    /**
1956     * @param value Short description of the link.
1957     */
1958    public TestScriptMetadataLinkComponent setDescription(String value) {
1959      if (Utilities.noString(value))
1960        this.description = null;
1961      else {
1962        if (this.description == null)
1963          this.description = new StringType();
1964        this.description.setValue(value);
1965      }
1966      return this;
1967    }
1968
1969    protected void listChildren(List<Property> children) {
1970      super.listChildren(children);
1971      children.add(new Property("url", "uri",
1972          "URL to a particular requirement or feature within the FHIR specification.", 0, 1, url));
1973      children.add(new Property("description", "string", "Short description of the link.", 0, 1, description));
1974    }
1975
1976    @Override
1977    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
1978      switch (_hash) {
1979      case 116079:
1980        /* url */ return new Property("url", "uri",
1981            "URL to a particular requirement or feature within the FHIR specification.", 0, 1, url);
1982      case -1724546052:
1983        /* description */ return new Property("description", "string", "Short description of the link.", 0, 1,
1984            description);
1985      default:
1986        return super.getNamedProperty(_hash, _name, _checkValid);
1987      }
1988
1989    }
1990
1991    @Override
1992    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
1993      switch (hash) {
1994      case 116079:
1995        /* url */ return this.url == null ? new Base[0] : new Base[] { this.url }; // UriType
1996      case -1724546052:
1997        /* description */ return this.description == null ? new Base[0] : new Base[] { this.description }; // StringType
1998      default:
1999        return super.getProperty(hash, name, checkValid);
2000      }
2001
2002    }
2003
2004    @Override
2005    public Base setProperty(int hash, String name, Base value) throws FHIRException {
2006      switch (hash) {
2007      case 116079: // url
2008        this.url = castToUri(value); // UriType
2009        return value;
2010      case -1724546052: // description
2011        this.description = castToString(value); // StringType
2012        return value;
2013      default:
2014        return super.setProperty(hash, name, value);
2015      }
2016
2017    }
2018
2019    @Override
2020    public Base setProperty(String name, Base value) throws FHIRException {
2021      if (name.equals("url")) {
2022        this.url = castToUri(value); // UriType
2023      } else if (name.equals("description")) {
2024        this.description = castToString(value); // StringType
2025      } else
2026        return super.setProperty(name, value);
2027      return value;
2028    }
2029
2030    @Override
2031    public Base makeProperty(int hash, String name) throws FHIRException {
2032      switch (hash) {
2033      case 116079:
2034        return getUrlElement();
2035      case -1724546052:
2036        return getDescriptionElement();
2037      default:
2038        return super.makeProperty(hash, name);
2039      }
2040
2041    }
2042
2043    @Override
2044    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2045      switch (hash) {
2046      case 116079:
2047        /* url */ return new String[] { "uri" };
2048      case -1724546052:
2049        /* description */ return new String[] { "string" };
2050      default:
2051        return super.getTypesForProperty(hash, name);
2052      }
2053
2054    }
2055
2056    @Override
2057    public Base addChild(String name) throws FHIRException {
2058      if (name.equals("url")) {
2059        throw new FHIRException("Cannot call addChild on a singleton property TestScript.url");
2060      } else if (name.equals("description")) {
2061        throw new FHIRException("Cannot call addChild on a singleton property TestScript.description");
2062      } else
2063        return super.addChild(name);
2064    }
2065
2066    public TestScriptMetadataLinkComponent copy() {
2067      TestScriptMetadataLinkComponent dst = new TestScriptMetadataLinkComponent();
2068      copyValues(dst);
2069      return dst;
2070    }
2071
2072    public void copyValues(TestScriptMetadataLinkComponent dst) {
2073      super.copyValues(dst);
2074      dst.url = url == null ? null : url.copy();
2075      dst.description = description == null ? null : description.copy();
2076    }
2077
2078    @Override
2079    public boolean equalsDeep(Base other_) {
2080      if (!super.equalsDeep(other_))
2081        return false;
2082      if (!(other_ instanceof TestScriptMetadataLinkComponent))
2083        return false;
2084      TestScriptMetadataLinkComponent o = (TestScriptMetadataLinkComponent) other_;
2085      return compareDeep(url, o.url, true) && compareDeep(description, o.description, true);
2086    }
2087
2088    @Override
2089    public boolean equalsShallow(Base other_) {
2090      if (!super.equalsShallow(other_))
2091        return false;
2092      if (!(other_ instanceof TestScriptMetadataLinkComponent))
2093        return false;
2094      TestScriptMetadataLinkComponent o = (TestScriptMetadataLinkComponent) other_;
2095      return compareValues(url, o.url, true) && compareValues(description, o.description, true);
2096    }
2097
2098    public boolean isEmpty() {
2099      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(url, description);
2100    }
2101
2102    public String fhirType() {
2103      return "TestScript.metadata.link";
2104
2105    }
2106
2107  }
2108
2109  @Block()
2110  public static class TestScriptMetadataCapabilityComponent extends BackboneElement implements IBaseBackboneElement {
2111    /**
2112     * Whether or not the test execution will require the given capabilities of the
2113     * server in order for this test script to execute.
2114     */
2115    @Child(name = "required", type = {
2116        BooleanType.class }, order = 1, min = 1, max = 1, modifier = false, summary = false)
2117    @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.")
2118    protected BooleanType required;
2119
2120    /**
2121     * Whether or not the test execution will validate the given capabilities of the
2122     * server in order for this test script to execute.
2123     */
2124    @Child(name = "validated", type = {
2125        BooleanType.class }, order = 2, min = 1, max = 1, modifier = false, summary = false)
2126    @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.")
2127    protected BooleanType validated;
2128
2129    /**
2130     * Description of the capabilities that this test script is requiring the server
2131     * to support.
2132     */
2133    @Child(name = "description", type = {
2134        StringType.class }, order = 3, min = 0, max = 1, modifier = false, summary = false)
2135    @Description(shortDefinition = "The expected capabilities of the server", formalDefinition = "Description of the capabilities that this test script is requiring the server to support.")
2136    protected StringType description;
2137
2138    /**
2139     * Which origin server these requirements apply to.
2140     */
2141    @Child(name = "origin", type = {
2142        IntegerType.class }, order = 4, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false)
2143    @Description(shortDefinition = "Which origin server these requirements apply to", formalDefinition = "Which origin server these requirements apply to.")
2144    protected List<IntegerType> origin;
2145
2146    /**
2147     * Which server these requirements apply to.
2148     */
2149    @Child(name = "destination", type = {
2150        IntegerType.class }, order = 5, min = 0, max = 1, modifier = false, summary = false)
2151    @Description(shortDefinition = "Which server these requirements apply to", formalDefinition = "Which server these requirements apply to.")
2152    protected IntegerType destination;
2153
2154    /**
2155     * Links to the FHIR specification that describes this interaction and the
2156     * resources involved in more detail.
2157     */
2158    @Child(name = "link", type = {
2159        UriType.class }, order = 6, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false)
2160    @Description(shortDefinition = "Links to the FHIR specification", formalDefinition = "Links to the FHIR specification that describes this interaction and the resources involved in more detail.")
2161    protected List<UriType> link;
2162
2163    /**
2164     * Minimum capabilities required of server for test script to execute
2165     * successfully. If server does not meet at a minimum the referenced capability
2166     * statement, then all tests in this script are skipped.
2167     */
2168    @Child(name = "capabilities", type = {
2169        CanonicalType.class }, order = 7, min = 1, max = 1, modifier = false, summary = false)
2170    @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.")
2171    protected CanonicalType capabilities;
2172
2173    private static final long serialVersionUID = -1368199288L;
2174
2175    /**
2176     * Constructor
2177     */
2178    public TestScriptMetadataCapabilityComponent() {
2179      super();
2180    }
2181
2182    /**
2183     * Constructor
2184     */
2185    public TestScriptMetadataCapabilityComponent(BooleanType required, BooleanType validated,
2186        CanonicalType capabilities) {
2187      super();
2188      this.required = required;
2189      this.validated = validated;
2190      this.capabilities = capabilities;
2191    }
2192
2193    /**
2194     * @return {@link #required} (Whether or not the test execution will require the
2195     *         given capabilities of the server in order for this test script to
2196     *         execute.). This is the underlying object with id, value and
2197     *         extensions. The accessor "getRequired" gives direct access to the
2198     *         value
2199     */
2200    public BooleanType getRequiredElement() {
2201      if (this.required == null)
2202        if (Configuration.errorOnAutoCreate())
2203          throw new Error("Attempt to auto-create TestScriptMetadataCapabilityComponent.required");
2204        else if (Configuration.doAutoCreate())
2205          this.required = new BooleanType(); // bb
2206      return this.required;
2207    }
2208
2209    public boolean hasRequiredElement() {
2210      return this.required != null && !this.required.isEmpty();
2211    }
2212
2213    public boolean hasRequired() {
2214      return this.required != null && !this.required.isEmpty();
2215    }
2216
2217    /**
2218     * @param value {@link #required} (Whether or not the test execution will
2219     *              require the given capabilities of the server in order for this
2220     *              test script to execute.). This is the underlying object with id,
2221     *              value and extensions. The accessor "getRequired" gives direct
2222     *              access to the value
2223     */
2224    public TestScriptMetadataCapabilityComponent setRequiredElement(BooleanType value) {
2225      this.required = value;
2226      return this;
2227    }
2228
2229    /**
2230     * @return Whether or not the test execution will require the given capabilities
2231     *         of the server in order for this test script to execute.
2232     */
2233    public boolean getRequired() {
2234      return this.required == null || this.required.isEmpty() ? false : this.required.getValue();
2235    }
2236
2237    /**
2238     * @param value Whether or not the test execution will require the given
2239     *              capabilities of the server in order for this test script to
2240     *              execute.
2241     */
2242    public TestScriptMetadataCapabilityComponent setRequired(boolean value) {
2243      if (this.required == null)
2244        this.required = new BooleanType();
2245      this.required.setValue(value);
2246      return this;
2247    }
2248
2249    /**
2250     * @return {@link #validated} (Whether or not the test execution will validate
2251     *         the given capabilities of the server in order for this test script to
2252     *         execute.). This is the underlying object with id, value and
2253     *         extensions. The accessor "getValidated" gives direct access to the
2254     *         value
2255     */
2256    public BooleanType getValidatedElement() {
2257      if (this.validated == null)
2258        if (Configuration.errorOnAutoCreate())
2259          throw new Error("Attempt to auto-create TestScriptMetadataCapabilityComponent.validated");
2260        else if (Configuration.doAutoCreate())
2261          this.validated = new BooleanType(); // bb
2262      return this.validated;
2263    }
2264
2265    public boolean hasValidatedElement() {
2266      return this.validated != null && !this.validated.isEmpty();
2267    }
2268
2269    public boolean hasValidated() {
2270      return this.validated != null && !this.validated.isEmpty();
2271    }
2272
2273    /**
2274     * @param value {@link #validated} (Whether or not the test execution will
2275     *              validate the given capabilities of the server in order for this
2276     *              test script to execute.). This is the underlying object with id,
2277     *              value and extensions. The accessor "getValidated" gives direct
2278     *              access to the value
2279     */
2280    public TestScriptMetadataCapabilityComponent setValidatedElement(BooleanType value) {
2281      this.validated = value;
2282      return this;
2283    }
2284
2285    /**
2286     * @return Whether or not the test execution will validate the given
2287     *         capabilities of the server in order for this test script to execute.
2288     */
2289    public boolean getValidated() {
2290      return this.validated == null || this.validated.isEmpty() ? false : this.validated.getValue();
2291    }
2292
2293    /**
2294     * @param value Whether or not the test execution will validate the given
2295     *              capabilities of the server in order for this test script to
2296     *              execute.
2297     */
2298    public TestScriptMetadataCapabilityComponent setValidated(boolean value) {
2299      if (this.validated == null)
2300        this.validated = new BooleanType();
2301      this.validated.setValue(value);
2302      return this;
2303    }
2304
2305    /**
2306     * @return {@link #description} (Description of the capabilities that this test
2307     *         script is requiring the server to support.). This is the underlying
2308     *         object with id, value and extensions. The accessor "getDescription"
2309     *         gives direct access to the value
2310     */
2311    public StringType getDescriptionElement() {
2312      if (this.description == null)
2313        if (Configuration.errorOnAutoCreate())
2314          throw new Error("Attempt to auto-create TestScriptMetadataCapabilityComponent.description");
2315        else if (Configuration.doAutoCreate())
2316          this.description = new StringType(); // bb
2317      return this.description;
2318    }
2319
2320    public boolean hasDescriptionElement() {
2321      return this.description != null && !this.description.isEmpty();
2322    }
2323
2324    public boolean hasDescription() {
2325      return this.description != null && !this.description.isEmpty();
2326    }
2327
2328    /**
2329     * @param value {@link #description} (Description of the capabilities that this
2330     *              test script is requiring the server to support.). This is the
2331     *              underlying object with id, value and extensions. The accessor
2332     *              "getDescription" gives direct access to the value
2333     */
2334    public TestScriptMetadataCapabilityComponent setDescriptionElement(StringType value) {
2335      this.description = value;
2336      return this;
2337    }
2338
2339    /**
2340     * @return Description of the capabilities that this test script is requiring
2341     *         the server to support.
2342     */
2343    public String getDescription() {
2344      return this.description == null ? null : this.description.getValue();
2345    }
2346
2347    /**
2348     * @param value Description of the capabilities that this test script is
2349     *              requiring the server to support.
2350     */
2351    public TestScriptMetadataCapabilityComponent setDescription(String value) {
2352      if (Utilities.noString(value))
2353        this.description = null;
2354      else {
2355        if (this.description == null)
2356          this.description = new StringType();
2357        this.description.setValue(value);
2358      }
2359      return this;
2360    }
2361
2362    /**
2363     * @return {@link #origin} (Which origin server these requirements apply to.)
2364     */
2365    public List<IntegerType> getOrigin() {
2366      if (this.origin == null)
2367        this.origin = new ArrayList<IntegerType>();
2368      return this.origin;
2369    }
2370
2371    /**
2372     * @return Returns a reference to <code>this</code> for easy method chaining
2373     */
2374    public TestScriptMetadataCapabilityComponent setOrigin(List<IntegerType> theOrigin) {
2375      this.origin = theOrigin;
2376      return this;
2377    }
2378
2379    public boolean hasOrigin() {
2380      if (this.origin == null)
2381        return false;
2382      for (IntegerType item : this.origin)
2383        if (!item.isEmpty())
2384          return true;
2385      return false;
2386    }
2387
2388    /**
2389     * @return {@link #origin} (Which origin server these requirements apply to.)
2390     */
2391    public IntegerType addOriginElement() {// 2
2392      IntegerType t = new IntegerType();
2393      if (this.origin == null)
2394        this.origin = new ArrayList<IntegerType>();
2395      this.origin.add(t);
2396      return t;
2397    }
2398
2399    /**
2400     * @param value {@link #origin} (Which origin server these requirements apply
2401     *              to.)
2402     */
2403    public TestScriptMetadataCapabilityComponent addOrigin(int value) { // 1
2404      IntegerType t = new IntegerType();
2405      t.setValue(value);
2406      if (this.origin == null)
2407        this.origin = new ArrayList<IntegerType>();
2408      this.origin.add(t);
2409      return this;
2410    }
2411
2412    /**
2413     * @param value {@link #origin} (Which origin server these requirements apply
2414     *              to.)
2415     */
2416    public boolean hasOrigin(int value) {
2417      if (this.origin == null)
2418        return false;
2419      for (IntegerType v : this.origin)
2420        if (v.getValue().equals(value)) // integer
2421          return true;
2422      return false;
2423    }
2424
2425    /**
2426     * @return {@link #destination} (Which server these requirements apply to.).
2427     *         This is the underlying object with id, value and extensions. The
2428     *         accessor "getDestination" gives direct access to the value
2429     */
2430    public IntegerType getDestinationElement() {
2431      if (this.destination == null)
2432        if (Configuration.errorOnAutoCreate())
2433          throw new Error("Attempt to auto-create TestScriptMetadataCapabilityComponent.destination");
2434        else if (Configuration.doAutoCreate())
2435          this.destination = new IntegerType(); // bb
2436      return this.destination;
2437    }
2438
2439    public boolean hasDestinationElement() {
2440      return this.destination != null && !this.destination.isEmpty();
2441    }
2442
2443    public boolean hasDestination() {
2444      return this.destination != null && !this.destination.isEmpty();
2445    }
2446
2447    /**
2448     * @param value {@link #destination} (Which server these requirements apply
2449     *              to.). This is the underlying object with id, value and
2450     *              extensions. The accessor "getDestination" gives direct access to
2451     *              the value
2452     */
2453    public TestScriptMetadataCapabilityComponent setDestinationElement(IntegerType value) {
2454      this.destination = value;
2455      return this;
2456    }
2457
2458    /**
2459     * @return Which server these requirements apply to.
2460     */
2461    public int getDestination() {
2462      return this.destination == null || this.destination.isEmpty() ? 0 : this.destination.getValue();
2463    }
2464
2465    /**
2466     * @param value Which server these requirements apply to.
2467     */
2468    public TestScriptMetadataCapabilityComponent setDestination(int value) {
2469      if (this.destination == null)
2470        this.destination = new IntegerType();
2471      this.destination.setValue(value);
2472      return this;
2473    }
2474
2475    /**
2476     * @return {@link #link} (Links to the FHIR specification that describes this
2477     *         interaction and the resources involved in more detail.)
2478     */
2479    public List<UriType> getLink() {
2480      if (this.link == null)
2481        this.link = new ArrayList<UriType>();
2482      return this.link;
2483    }
2484
2485    /**
2486     * @return Returns a reference to <code>this</code> for easy method chaining
2487     */
2488    public TestScriptMetadataCapabilityComponent setLink(List<UriType> theLink) {
2489      this.link = theLink;
2490      return this;
2491    }
2492
2493    public boolean hasLink() {
2494      if (this.link == null)
2495        return false;
2496      for (UriType item : this.link)
2497        if (!item.isEmpty())
2498          return true;
2499      return false;
2500    }
2501
2502    /**
2503     * @return {@link #link} (Links to the FHIR specification that describes this
2504     *         interaction and the resources involved in more detail.)
2505     */
2506    public UriType addLinkElement() {// 2
2507      UriType t = new UriType();
2508      if (this.link == null)
2509        this.link = new ArrayList<UriType>();
2510      this.link.add(t);
2511      return t;
2512    }
2513
2514    /**
2515     * @param value {@link #link} (Links to the FHIR specification that describes
2516     *              this interaction and the resources involved in more detail.)
2517     */
2518    public TestScriptMetadataCapabilityComponent addLink(String value) { // 1
2519      UriType t = new UriType();
2520      t.setValue(value);
2521      if (this.link == null)
2522        this.link = new ArrayList<UriType>();
2523      this.link.add(t);
2524      return this;
2525    }
2526
2527    /**
2528     * @param value {@link #link} (Links to the FHIR specification that describes
2529     *              this interaction and the resources involved in more detail.)
2530     */
2531    public boolean hasLink(String value) {
2532      if (this.link == null)
2533        return false;
2534      for (UriType v : this.link)
2535        if (v.getValue().equals(value)) // uri
2536          return true;
2537      return false;
2538    }
2539
2540    /**
2541     * @return {@link #capabilities} (Minimum capabilities required of server for
2542     *         test script to execute successfully. If server does not meet at a
2543     *         minimum the referenced capability statement, then all tests in this
2544     *         script are skipped.). This is the underlying object with id, value
2545     *         and extensions. The accessor "getCapabilities" gives direct access to
2546     *         the value
2547     */
2548    public CanonicalType getCapabilitiesElement() {
2549      if (this.capabilities == null)
2550        if (Configuration.errorOnAutoCreate())
2551          throw new Error("Attempt to auto-create TestScriptMetadataCapabilityComponent.capabilities");
2552        else if (Configuration.doAutoCreate())
2553          this.capabilities = new CanonicalType(); // bb
2554      return this.capabilities;
2555    }
2556
2557    public boolean hasCapabilitiesElement() {
2558      return this.capabilities != null && !this.capabilities.isEmpty();
2559    }
2560
2561    public boolean hasCapabilities() {
2562      return this.capabilities != null && !this.capabilities.isEmpty();
2563    }
2564
2565    /**
2566     * @param value {@link #capabilities} (Minimum capabilities required of server
2567     *              for test script to execute successfully. If server does not meet
2568     *              at a minimum the referenced capability statement, then all tests
2569     *              in this script are skipped.). This is the underlying object with
2570     *              id, value and extensions. The accessor "getCapabilities" gives
2571     *              direct access to the value
2572     */
2573    public TestScriptMetadataCapabilityComponent setCapabilitiesElement(CanonicalType value) {
2574      this.capabilities = value;
2575      return this;
2576    }
2577
2578    /**
2579     * @return Minimum capabilities required of server for test script to execute
2580     *         successfully. If server does not meet at a minimum the referenced
2581     *         capability statement, then all tests in this script are skipped.
2582     */
2583    public String getCapabilities() {
2584      return this.capabilities == null ? null : this.capabilities.getValue();
2585    }
2586
2587    /**
2588     * @param value Minimum capabilities required of server for test script to
2589     *              execute successfully. If server does not meet at a minimum the
2590     *              referenced capability statement, then all tests in this script
2591     *              are skipped.
2592     */
2593    public TestScriptMetadataCapabilityComponent setCapabilities(String value) {
2594      if (this.capabilities == null)
2595        this.capabilities = new CanonicalType();
2596      this.capabilities.setValue(value);
2597      return this;
2598    }
2599
2600    protected void listChildren(List<Property> children) {
2601      super.listChildren(children);
2602      children.add(new Property("required", "boolean",
2603          "Whether or not the test execution will require the given capabilities of the server in order for this test script to execute.",
2604          0, 1, required));
2605      children.add(new Property("validated", "boolean",
2606          "Whether or not the test execution will validate the given capabilities of the server in order for this test script to execute.",
2607          0, 1, validated));
2608      children.add(new Property("description", "string",
2609          "Description of the capabilities that this test script is requiring the server to support.", 0, 1,
2610          description));
2611      children.add(new Property("origin", "integer", "Which origin server these requirements apply to.", 0,
2612          java.lang.Integer.MAX_VALUE, origin));
2613      children
2614          .add(new Property("destination", "integer", "Which server these requirements apply to.", 0, 1, destination));
2615      children.add(new Property("link", "uri",
2616          "Links to the FHIR specification that describes this interaction and the resources involved in more detail.",
2617          0, java.lang.Integer.MAX_VALUE, link));
2618      children.add(new Property("capabilities", "canonical(CapabilityStatement)",
2619          "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.",
2620          0, 1, capabilities));
2621    }
2622
2623    @Override
2624    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2625      switch (_hash) {
2626      case -393139297:
2627        /* required */ return new Property("required", "boolean",
2628            "Whether or not the test execution will require the given capabilities of the server in order for this test script to execute.",
2629            0, 1, required);
2630      case -1109784050:
2631        /* validated */ return new Property("validated", "boolean",
2632            "Whether or not the test execution will validate the given capabilities of the server in order for this test script to execute.",
2633            0, 1, validated);
2634      case -1724546052:
2635        /* description */ return new Property("description", "string",
2636            "Description of the capabilities that this test script is requiring the server to support.", 0, 1,
2637            description);
2638      case -1008619738:
2639        /* origin */ return new Property("origin", "integer", "Which origin server these requirements apply to.", 0,
2640            java.lang.Integer.MAX_VALUE, origin);
2641      case -1429847026:
2642        /* destination */ return new Property("destination", "integer", "Which server these requirements apply to.", 0,
2643            1, destination);
2644      case 3321850:
2645        /* link */ return new Property("link", "uri",
2646            "Links to the FHIR specification that describes this interaction and the resources involved in more detail.",
2647            0, java.lang.Integer.MAX_VALUE, link);
2648      case -1487597642:
2649        /* capabilities */ return new Property("capabilities", "canonical(CapabilityStatement)",
2650            "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.",
2651            0, 1, capabilities);
2652      default:
2653        return super.getNamedProperty(_hash, _name, _checkValid);
2654      }
2655
2656    }
2657
2658    @Override
2659    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2660      switch (hash) {
2661      case -393139297:
2662        /* required */ return this.required == null ? new Base[0] : new Base[] { this.required }; // BooleanType
2663      case -1109784050:
2664        /* validated */ return this.validated == null ? new Base[0] : new Base[] { this.validated }; // BooleanType
2665      case -1724546052:
2666        /* description */ return this.description == null ? new Base[0] : new Base[] { this.description }; // StringType
2667      case -1008619738:
2668        /* origin */ return this.origin == null ? new Base[0] : this.origin.toArray(new Base[this.origin.size()]); // IntegerType
2669      case -1429847026:
2670        /* destination */ return this.destination == null ? new Base[0] : new Base[] { this.destination }; // IntegerType
2671      case 3321850:
2672        /* link */ return this.link == null ? new Base[0] : this.link.toArray(new Base[this.link.size()]); // UriType
2673      case -1487597642:
2674        /* capabilities */ return this.capabilities == null ? new Base[0] : new Base[] { this.capabilities }; // CanonicalType
2675      default:
2676        return super.getProperty(hash, name, checkValid);
2677      }
2678
2679    }
2680
2681    @Override
2682    public Base setProperty(int hash, String name, Base value) throws FHIRException {
2683      switch (hash) {
2684      case -393139297: // required
2685        this.required = castToBoolean(value); // BooleanType
2686        return value;
2687      case -1109784050: // validated
2688        this.validated = castToBoolean(value); // BooleanType
2689        return value;
2690      case -1724546052: // description
2691        this.description = castToString(value); // StringType
2692        return value;
2693      case -1008619738: // origin
2694        this.getOrigin().add(castToInteger(value)); // IntegerType
2695        return value;
2696      case -1429847026: // destination
2697        this.destination = castToInteger(value); // IntegerType
2698        return value;
2699      case 3321850: // link
2700        this.getLink().add(castToUri(value)); // UriType
2701        return value;
2702      case -1487597642: // capabilities
2703        this.capabilities = castToCanonical(value); // CanonicalType
2704        return value;
2705      default:
2706        return super.setProperty(hash, name, value);
2707      }
2708
2709    }
2710
2711    @Override
2712    public Base setProperty(String name, Base value) throws FHIRException {
2713      if (name.equals("required")) {
2714        this.required = castToBoolean(value); // BooleanType
2715      } else if (name.equals("validated")) {
2716        this.validated = castToBoolean(value); // BooleanType
2717      } else if (name.equals("description")) {
2718        this.description = castToString(value); // StringType
2719      } else if (name.equals("origin")) {
2720        this.getOrigin().add(castToInteger(value));
2721      } else if (name.equals("destination")) {
2722        this.destination = castToInteger(value); // IntegerType
2723      } else if (name.equals("link")) {
2724        this.getLink().add(castToUri(value));
2725      } else if (name.equals("capabilities")) {
2726        this.capabilities = castToCanonical(value); // CanonicalType
2727      } else
2728        return super.setProperty(name, value);
2729      return value;
2730    }
2731
2732    @Override
2733    public Base makeProperty(int hash, String name) throws FHIRException {
2734      switch (hash) {
2735      case -393139297:
2736        return getRequiredElement();
2737      case -1109784050:
2738        return getValidatedElement();
2739      case -1724546052:
2740        return getDescriptionElement();
2741      case -1008619738:
2742        return addOriginElement();
2743      case -1429847026:
2744        return getDestinationElement();
2745      case 3321850:
2746        return addLinkElement();
2747      case -1487597642:
2748        return getCapabilitiesElement();
2749      default:
2750        return super.makeProperty(hash, name);
2751      }
2752
2753    }
2754
2755    @Override
2756    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2757      switch (hash) {
2758      case -393139297:
2759        /* required */ return new String[] { "boolean" };
2760      case -1109784050:
2761        /* validated */ return new String[] { "boolean" };
2762      case -1724546052:
2763        /* description */ return new String[] { "string" };
2764      case -1008619738:
2765        /* origin */ return new String[] { "integer" };
2766      case -1429847026:
2767        /* destination */ return new String[] { "integer" };
2768      case 3321850:
2769        /* link */ return new String[] { "uri" };
2770      case -1487597642:
2771        /* capabilities */ return new String[] { "canonical" };
2772      default:
2773        return super.getTypesForProperty(hash, name);
2774      }
2775
2776    }
2777
2778    @Override
2779    public Base addChild(String name) throws FHIRException {
2780      if (name.equals("required")) {
2781        throw new FHIRException("Cannot call addChild on a singleton property TestScript.required");
2782      } else if (name.equals("validated")) {
2783        throw new FHIRException("Cannot call addChild on a singleton property TestScript.validated");
2784      } else if (name.equals("description")) {
2785        throw new FHIRException("Cannot call addChild on a singleton property TestScript.description");
2786      } else if (name.equals("origin")) {
2787        throw new FHIRException("Cannot call addChild on a singleton property TestScript.origin");
2788      } else if (name.equals("destination")) {
2789        throw new FHIRException("Cannot call addChild on a singleton property TestScript.destination");
2790      } else if (name.equals("link")) {
2791        throw new FHIRException("Cannot call addChild on a singleton property TestScript.link");
2792      } else if (name.equals("capabilities")) {
2793        throw new FHIRException("Cannot call addChild on a singleton property TestScript.capabilities");
2794      } else
2795        return super.addChild(name);
2796    }
2797
2798    public TestScriptMetadataCapabilityComponent copy() {
2799      TestScriptMetadataCapabilityComponent dst = new TestScriptMetadataCapabilityComponent();
2800      copyValues(dst);
2801      return dst;
2802    }
2803
2804    public void copyValues(TestScriptMetadataCapabilityComponent dst) {
2805      super.copyValues(dst);
2806      dst.required = required == null ? null : required.copy();
2807      dst.validated = validated == null ? null : validated.copy();
2808      dst.description = description == null ? null : description.copy();
2809      if (origin != null) {
2810        dst.origin = new ArrayList<IntegerType>();
2811        for (IntegerType i : origin)
2812          dst.origin.add(i.copy());
2813      }
2814      ;
2815      dst.destination = destination == null ? null : destination.copy();
2816      if (link != null) {
2817        dst.link = new ArrayList<UriType>();
2818        for (UriType i : link)
2819          dst.link.add(i.copy());
2820      }
2821      ;
2822      dst.capabilities = capabilities == null ? null : capabilities.copy();
2823    }
2824
2825    @Override
2826    public boolean equalsDeep(Base other_) {
2827      if (!super.equalsDeep(other_))
2828        return false;
2829      if (!(other_ instanceof TestScriptMetadataCapabilityComponent))
2830        return false;
2831      TestScriptMetadataCapabilityComponent o = (TestScriptMetadataCapabilityComponent) other_;
2832      return compareDeep(required, o.required, true) && compareDeep(validated, o.validated, true)
2833          && compareDeep(description, o.description, true) && compareDeep(origin, o.origin, true)
2834          && compareDeep(destination, o.destination, true) && compareDeep(link, o.link, true)
2835          && compareDeep(capabilities, o.capabilities, true);
2836    }
2837
2838    @Override
2839    public boolean equalsShallow(Base other_) {
2840      if (!super.equalsShallow(other_))
2841        return false;
2842      if (!(other_ instanceof TestScriptMetadataCapabilityComponent))
2843        return false;
2844      TestScriptMetadataCapabilityComponent o = (TestScriptMetadataCapabilityComponent) other_;
2845      return compareValues(required, o.required, true) && compareValues(validated, o.validated, true)
2846          && compareValues(description, o.description, true) && compareValues(origin, o.origin, true)
2847          && compareValues(destination, o.destination, true) && compareValues(link, o.link, true);
2848    }
2849
2850    public boolean isEmpty() {
2851      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(required, validated, description, origin,
2852          destination, link, capabilities);
2853    }
2854
2855    public String fhirType() {
2856      return "TestScript.metadata.capability";
2857
2858    }
2859
2860  }
2861
2862  @Block()
2863  public static class TestScriptFixtureComponent extends BackboneElement implements IBaseBackboneElement {
2864    /**
2865     * Whether or not to implicitly create the fixture during setup. If true, the
2866     * fixture is automatically created on each server being tested during setup,
2867     * therefore no create operation is required for this fixture in the
2868     * TestScript.setup section.
2869     */
2870    @Child(name = "autocreate", type = {
2871        BooleanType.class }, order = 1, min = 1, max = 1, modifier = false, summary = false)
2872    @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.")
2873    protected BooleanType autocreate;
2874
2875    /**
2876     * Whether or not to implicitly delete the fixture during teardown. If true, the
2877     * fixture is automatically deleted on each server being tested during teardown,
2878     * therefore no delete operation is required for this fixture in the
2879     * TestScript.teardown section.
2880     */
2881    @Child(name = "autodelete", type = {
2882        BooleanType.class }, order = 2, min = 1, max = 1, modifier = false, summary = false)
2883    @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.")
2884    protected BooleanType autodelete;
2885
2886    /**
2887     * Reference to the resource (containing the contents of the resource needed for
2888     * operations).
2889     */
2890    @Child(name = "resource", type = {
2891        Reference.class }, order = 3, min = 0, max = 1, modifier = false, summary = false)
2892    @Description(shortDefinition = "Reference of the resource", formalDefinition = "Reference to the resource (containing the contents of the resource needed for operations).")
2893    protected Reference resource;
2894
2895    /**
2896     * The actual object that is the target of the reference (Reference to the
2897     * resource (containing the contents of the resource needed for operations).)
2898     */
2899    protected Resource resourceTarget;
2900
2901    private static final long serialVersionUID = 1110683307L;
2902
2903    /**
2904     * Constructor
2905     */
2906    public TestScriptFixtureComponent() {
2907      super();
2908    }
2909
2910    /**
2911     * Constructor
2912     */
2913    public TestScriptFixtureComponent(BooleanType autocreate, BooleanType autodelete) {
2914      super();
2915      this.autocreate = autocreate;
2916      this.autodelete = autodelete;
2917    }
2918
2919    /**
2920     * @return {@link #autocreate} (Whether or not to implicitly create the fixture
2921     *         during setup. If true, the fixture is automatically created on each
2922     *         server being tested during setup, therefore no create operation is
2923     *         required for this fixture in the TestScript.setup section.). This is
2924     *         the underlying object with id, value and extensions. The accessor
2925     *         "getAutocreate" gives direct access to the value
2926     */
2927    public BooleanType getAutocreateElement() {
2928      if (this.autocreate == null)
2929        if (Configuration.errorOnAutoCreate())
2930          throw new Error("Attempt to auto-create TestScriptFixtureComponent.autocreate");
2931        else if (Configuration.doAutoCreate())
2932          this.autocreate = new BooleanType(); // bb
2933      return this.autocreate;
2934    }
2935
2936    public boolean hasAutocreateElement() {
2937      return this.autocreate != null && !this.autocreate.isEmpty();
2938    }
2939
2940    public boolean hasAutocreate() {
2941      return this.autocreate != null && !this.autocreate.isEmpty();
2942    }
2943
2944    /**
2945     * @param value {@link #autocreate} (Whether or not to implicitly create the
2946     *              fixture during setup. If true, the fixture is automatically
2947     *              created on each server being tested during setup, therefore no
2948     *              create operation is required for this fixture in the
2949     *              TestScript.setup section.). This is the underlying object with
2950     *              id, value and extensions. The accessor "getAutocreate" gives
2951     *              direct access to the value
2952     */
2953    public TestScriptFixtureComponent setAutocreateElement(BooleanType value) {
2954      this.autocreate = value;
2955      return this;
2956    }
2957
2958    /**
2959     * @return Whether or not to implicitly create the fixture during setup. If
2960     *         true, the fixture is automatically created on each server being
2961     *         tested during setup, therefore no create operation is required for
2962     *         this fixture in the TestScript.setup section.
2963     */
2964    public boolean getAutocreate() {
2965      return this.autocreate == null || this.autocreate.isEmpty() ? false : this.autocreate.getValue();
2966    }
2967
2968    /**
2969     * @param value Whether or not to implicitly create the fixture during setup. If
2970     *              true, the fixture is automatically created on each server being
2971     *              tested during setup, therefore no create operation is required
2972     *              for this fixture in the TestScript.setup section.
2973     */
2974    public TestScriptFixtureComponent setAutocreate(boolean value) {
2975      if (this.autocreate == null)
2976        this.autocreate = new BooleanType();
2977      this.autocreate.setValue(value);
2978      return this;
2979    }
2980
2981    /**
2982     * @return {@link #autodelete} (Whether or not to implicitly delete the fixture
2983     *         during teardown. If true, the fixture is automatically deleted on
2984     *         each server being tested during teardown, therefore no delete
2985     *         operation is required for this fixture in the TestScript.teardown
2986     *         section.). This is the underlying object with id, value and
2987     *         extensions. The accessor "getAutodelete" gives direct access to the
2988     *         value
2989     */
2990    public BooleanType getAutodeleteElement() {
2991      if (this.autodelete == null)
2992        if (Configuration.errorOnAutoCreate())
2993          throw new Error("Attempt to auto-create TestScriptFixtureComponent.autodelete");
2994        else if (Configuration.doAutoCreate())
2995          this.autodelete = new BooleanType(); // bb
2996      return this.autodelete;
2997    }
2998
2999    public boolean hasAutodeleteElement() {
3000      return this.autodelete != null && !this.autodelete.isEmpty();
3001    }
3002
3003    public boolean hasAutodelete() {
3004      return this.autodelete != null && !this.autodelete.isEmpty();
3005    }
3006
3007    /**
3008     * @param value {@link #autodelete} (Whether or not to implicitly delete the
3009     *              fixture during teardown. If true, the fixture is automatically
3010     *              deleted on each server being tested during teardown, therefore
3011     *              no delete operation is required for this fixture in the
3012     *              TestScript.teardown section.). This is the underlying object
3013     *              with id, value and extensions. The accessor "getAutodelete"
3014     *              gives direct access to the value
3015     */
3016    public TestScriptFixtureComponent setAutodeleteElement(BooleanType value) {
3017      this.autodelete = value;
3018      return this;
3019    }
3020
3021    /**
3022     * @return Whether or not to implicitly delete the fixture during teardown. If
3023     *         true, the fixture is automatically deleted on each server being
3024     *         tested during teardown, therefore no delete operation is required for
3025     *         this fixture in the TestScript.teardown section.
3026     */
3027    public boolean getAutodelete() {
3028      return this.autodelete == null || this.autodelete.isEmpty() ? false : this.autodelete.getValue();
3029    }
3030
3031    /**
3032     * @param value Whether or not to implicitly delete the fixture during teardown.
3033     *              If true, the fixture is automatically deleted on each server
3034     *              being tested during teardown, therefore no delete operation is
3035     *              required for this fixture in the TestScript.teardown section.
3036     */
3037    public TestScriptFixtureComponent setAutodelete(boolean value) {
3038      if (this.autodelete == null)
3039        this.autodelete = new BooleanType();
3040      this.autodelete.setValue(value);
3041      return this;
3042    }
3043
3044    /**
3045     * @return {@link #resource} (Reference to the resource (containing the contents
3046     *         of the resource needed for operations).)
3047     */
3048    public Reference getResource() {
3049      if (this.resource == null)
3050        if (Configuration.errorOnAutoCreate())
3051          throw new Error("Attempt to auto-create TestScriptFixtureComponent.resource");
3052        else if (Configuration.doAutoCreate())
3053          this.resource = new Reference(); // cc
3054      return this.resource;
3055    }
3056
3057    public boolean hasResource() {
3058      return this.resource != null && !this.resource.isEmpty();
3059    }
3060
3061    /**
3062     * @param value {@link #resource} (Reference to the resource (containing the
3063     *              contents of the resource needed for operations).)
3064     */
3065    public TestScriptFixtureComponent setResource(Reference value) {
3066      this.resource = value;
3067      return this;
3068    }
3069
3070    /**
3071     * @return {@link #resource} The actual object that is the target of the
3072     *         reference. The reference library doesn't populate this, but you can
3073     *         use it to hold the resource if you resolve it. (Reference to the
3074     *         resource (containing the contents of the resource needed for
3075     *         operations).)
3076     */
3077    public Resource getResourceTarget() {
3078      return this.resourceTarget;
3079    }
3080
3081    /**
3082     * @param value {@link #resource} The actual object that is the target of the
3083     *              reference. The reference library doesn't use these, but you can
3084     *              use it to hold the resource if you resolve it. (Reference to the
3085     *              resource (containing the contents of the resource needed for
3086     *              operations).)
3087     */
3088    public TestScriptFixtureComponent setResourceTarget(Resource value) {
3089      this.resourceTarget = value;
3090      return this;
3091    }
3092
3093    protected void listChildren(List<Property> children) {
3094      super.listChildren(children);
3095      children.add(new Property("autocreate", "boolean",
3096          "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.",
3097          0, 1, autocreate));
3098      children.add(new Property("autodelete", "boolean",
3099          "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.",
3100          0, 1, autodelete));
3101      children.add(new Property("resource", "Reference(Any)",
3102          "Reference to the resource (containing the contents of the resource needed for operations).", 0, 1,
3103          resource));
3104    }
3105
3106    @Override
3107    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
3108      switch (_hash) {
3109      case 73154411:
3110        /* autocreate */ return new Property("autocreate", "boolean",
3111            "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.",
3112            0, 1, autocreate);
3113      case 89990170:
3114        /* autodelete */ return new Property("autodelete", "boolean",
3115            "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.",
3116            0, 1, autodelete);
3117      case -341064690:
3118        /* resource */ return new Property("resource", "Reference(Any)",
3119            "Reference to the resource (containing the contents of the resource needed for operations).", 0, 1,
3120            resource);
3121      default:
3122        return super.getNamedProperty(_hash, _name, _checkValid);
3123      }
3124
3125    }
3126
3127    @Override
3128    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3129      switch (hash) {
3130      case 73154411:
3131        /* autocreate */ return this.autocreate == null ? new Base[0] : new Base[] { this.autocreate }; // BooleanType
3132      case 89990170:
3133        /* autodelete */ return this.autodelete == null ? new Base[0] : new Base[] { this.autodelete }; // BooleanType
3134      case -341064690:
3135        /* resource */ return this.resource == null ? new Base[0] : new Base[] { this.resource }; // Reference
3136      default:
3137        return super.getProperty(hash, name, checkValid);
3138      }
3139
3140    }
3141
3142    @Override
3143    public Base setProperty(int hash, String name, Base value) throws FHIRException {
3144      switch (hash) {
3145      case 73154411: // autocreate
3146        this.autocreate = castToBoolean(value); // BooleanType
3147        return value;
3148      case 89990170: // autodelete
3149        this.autodelete = castToBoolean(value); // BooleanType
3150        return value;
3151      case -341064690: // resource
3152        this.resource = castToReference(value); // Reference
3153        return value;
3154      default:
3155        return super.setProperty(hash, name, value);
3156      }
3157
3158    }
3159
3160    @Override
3161    public Base setProperty(String name, Base value) throws FHIRException {
3162      if (name.equals("autocreate")) {
3163        this.autocreate = castToBoolean(value); // BooleanType
3164      } else if (name.equals("autodelete")) {
3165        this.autodelete = castToBoolean(value); // BooleanType
3166      } else if (name.equals("resource")) {
3167        this.resource = castToReference(value); // Reference
3168      } else
3169        return super.setProperty(name, value);
3170      return value;
3171    }
3172
3173    @Override
3174    public Base makeProperty(int hash, String name) throws FHIRException {
3175      switch (hash) {
3176      case 73154411:
3177        return getAutocreateElement();
3178      case 89990170:
3179        return getAutodeleteElement();
3180      case -341064690:
3181        return getResource();
3182      default:
3183        return super.makeProperty(hash, name);
3184      }
3185
3186    }
3187
3188    @Override
3189    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
3190      switch (hash) {
3191      case 73154411:
3192        /* autocreate */ return new String[] { "boolean" };
3193      case 89990170:
3194        /* autodelete */ return new String[] { "boolean" };
3195      case -341064690:
3196        /* resource */ return new String[] { "Reference" };
3197      default:
3198        return super.getTypesForProperty(hash, name);
3199      }
3200
3201    }
3202
3203    @Override
3204    public Base addChild(String name) throws FHIRException {
3205      if (name.equals("autocreate")) {
3206        throw new FHIRException("Cannot call addChild on a singleton property TestScript.autocreate");
3207      } else if (name.equals("autodelete")) {
3208        throw new FHIRException("Cannot call addChild on a singleton property TestScript.autodelete");
3209      } else if (name.equals("resource")) {
3210        this.resource = new Reference();
3211        return this.resource;
3212      } else
3213        return super.addChild(name);
3214    }
3215
3216    public TestScriptFixtureComponent copy() {
3217      TestScriptFixtureComponent dst = new TestScriptFixtureComponent();
3218      copyValues(dst);
3219      return dst;
3220    }
3221
3222    public void copyValues(TestScriptFixtureComponent dst) {
3223      super.copyValues(dst);
3224      dst.autocreate = autocreate == null ? null : autocreate.copy();
3225      dst.autodelete = autodelete == null ? null : autodelete.copy();
3226      dst.resource = resource == null ? null : resource.copy();
3227    }
3228
3229    @Override
3230    public boolean equalsDeep(Base other_) {
3231      if (!super.equalsDeep(other_))
3232        return false;
3233      if (!(other_ instanceof TestScriptFixtureComponent))
3234        return false;
3235      TestScriptFixtureComponent o = (TestScriptFixtureComponent) other_;
3236      return compareDeep(autocreate, o.autocreate, true) && compareDeep(autodelete, o.autodelete, true)
3237          && compareDeep(resource, o.resource, true);
3238    }
3239
3240    @Override
3241    public boolean equalsShallow(Base other_) {
3242      if (!super.equalsShallow(other_))
3243        return false;
3244      if (!(other_ instanceof TestScriptFixtureComponent))
3245        return false;
3246      TestScriptFixtureComponent o = (TestScriptFixtureComponent) other_;
3247      return compareValues(autocreate, o.autocreate, true) && compareValues(autodelete, o.autodelete, true);
3248    }
3249
3250    public boolean isEmpty() {
3251      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(autocreate, autodelete, resource);
3252    }
3253
3254    public String fhirType() {
3255      return "TestScript.fixture";
3256
3257    }
3258
3259  }
3260
3261  @Block()
3262  public static class TestScriptVariableComponent extends BackboneElement implements IBaseBackboneElement {
3263    /**
3264     * Descriptive name for this variable.
3265     */
3266    @Child(name = "name", type = { StringType.class }, order = 1, min = 1, max = 1, modifier = false, summary = false)
3267    @Description(shortDefinition = "Descriptive name for this variable", formalDefinition = "Descriptive name for this variable.")
3268    protected StringType name;
3269
3270    /**
3271     * A default, hard-coded, or user-defined value for this variable.
3272     */
3273    @Child(name = "defaultValue", type = {
3274        StringType.class }, order = 2, min = 0, max = 1, modifier = false, summary = false)
3275    @Description(shortDefinition = "Default, hard-coded, or user-defined value for this variable", formalDefinition = "A default, hard-coded, or user-defined value for this variable.")
3276    protected StringType defaultValue;
3277
3278    /**
3279     * A free text natural language description of the variable and its purpose.
3280     */
3281    @Child(name = "description", type = {
3282        StringType.class }, order = 3, min = 0, max = 1, modifier = false, summary = false)
3283    @Description(shortDefinition = "Natural language description of the variable", formalDefinition = "A free text natural language description of the variable and its purpose.")
3284    protected StringType description;
3285
3286    /**
3287     * The FHIRPath expression to evaluate against the fixture body. When variables
3288     * are defined, only one of either expression, headerField or path must be
3289     * specified.
3290     */
3291    @Child(name = "expression", type = {
3292        StringType.class }, order = 4, min = 0, max = 1, modifier = false, summary = false)
3293    @Description(shortDefinition = "The FHIRPath expression against the fixture body", formalDefinition = "The FHIRPath expression to evaluate against the fixture body. When variables are defined, only one of either expression, headerField or path must be specified.")
3294    protected StringType expression;
3295
3296    /**
3297     * Will be used to grab the HTTP header field value from the headers that
3298     * sourceId is pointing to.
3299     */
3300    @Child(name = "headerField", type = {
3301        StringType.class }, order = 5, min = 0, max = 1, modifier = false, summary = false)
3302    @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.")
3303    protected StringType headerField;
3304
3305    /**
3306     * Displayable text string with hint help information to the user when entering
3307     * a default value.
3308     */
3309    @Child(name = "hint", type = { StringType.class }, order = 6, min = 0, max = 1, modifier = false, summary = false)
3310    @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.")
3311    protected StringType hint;
3312
3313    /**
3314     * XPath or JSONPath to evaluate against the fixture body. When variables are
3315     * defined, only one of either expression, headerField or path must be
3316     * specified.
3317     */
3318    @Child(name = "path", type = { StringType.class }, order = 7, min = 0, max = 1, modifier = false, summary = false)
3319    @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.")
3320    protected StringType path;
3321
3322    /**
3323     * Fixture to evaluate the XPath/JSONPath expression or the headerField against
3324     * within this variable.
3325     */
3326    @Child(name = "sourceId", type = { IdType.class }, order = 8, min = 0, max = 1, modifier = false, summary = false)
3327    @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.")
3328    protected IdType sourceId;
3329
3330    private static final long serialVersionUID = -1592325432L;
3331
3332    /**
3333     * Constructor
3334     */
3335    public TestScriptVariableComponent() {
3336      super();
3337    }
3338
3339    /**
3340     * Constructor
3341     */
3342    public TestScriptVariableComponent(StringType name) {
3343      super();
3344      this.name = name;
3345    }
3346
3347    /**
3348     * @return {@link #name} (Descriptive name for this variable.). This is the
3349     *         underlying object with id, value and extensions. The accessor
3350     *         "getName" gives direct access to the value
3351     */
3352    public StringType getNameElement() {
3353      if (this.name == null)
3354        if (Configuration.errorOnAutoCreate())
3355          throw new Error("Attempt to auto-create TestScriptVariableComponent.name");
3356        else if (Configuration.doAutoCreate())
3357          this.name = new StringType(); // bb
3358      return this.name;
3359    }
3360
3361    public boolean hasNameElement() {
3362      return this.name != null && !this.name.isEmpty();
3363    }
3364
3365    public boolean hasName() {
3366      return this.name != null && !this.name.isEmpty();
3367    }
3368
3369    /**
3370     * @param value {@link #name} (Descriptive name for this variable.). This is the
3371     *              underlying object with id, value and extensions. The accessor
3372     *              "getName" gives direct access to the value
3373     */
3374    public TestScriptVariableComponent setNameElement(StringType value) {
3375      this.name = value;
3376      return this;
3377    }
3378
3379    /**
3380     * @return Descriptive name for this variable.
3381     */
3382    public String getName() {
3383      return this.name == null ? null : this.name.getValue();
3384    }
3385
3386    /**
3387     * @param value Descriptive name for this variable.
3388     */
3389    public TestScriptVariableComponent setName(String value) {
3390      if (this.name == null)
3391        this.name = new StringType();
3392      this.name.setValue(value);
3393      return this;
3394    }
3395
3396    /**
3397     * @return {@link #defaultValue} (A default, hard-coded, or user-defined value
3398     *         for this variable.). This is the underlying object with id, value and
3399     *         extensions. The accessor "getDefaultValue" gives direct access to the
3400     *         value
3401     */
3402    public StringType getDefaultValueElement() {
3403      if (this.defaultValue == null)
3404        if (Configuration.errorOnAutoCreate())
3405          throw new Error("Attempt to auto-create TestScriptVariableComponent.defaultValue");
3406        else if (Configuration.doAutoCreate())
3407          this.defaultValue = new StringType(); // bb
3408      return this.defaultValue;
3409    }
3410
3411    public boolean hasDefaultValueElement() {
3412      return this.defaultValue != null && !this.defaultValue.isEmpty();
3413    }
3414
3415    public boolean hasDefaultValue() {
3416      return this.defaultValue != null && !this.defaultValue.isEmpty();
3417    }
3418
3419    /**
3420     * @param value {@link #defaultValue} (A default, hard-coded, or user-defined
3421     *              value for this variable.). This is the underlying object with
3422     *              id, value and extensions. The accessor "getDefaultValue" gives
3423     *              direct access to the value
3424     */
3425    public TestScriptVariableComponent setDefaultValueElement(StringType value) {
3426      this.defaultValue = value;
3427      return this;
3428    }
3429
3430    /**
3431     * @return A default, hard-coded, or user-defined value for this variable.
3432     */
3433    public String getDefaultValue() {
3434      return this.defaultValue == null ? null : this.defaultValue.getValue();
3435    }
3436
3437    /**
3438     * @param value A default, hard-coded, or user-defined value for this variable.
3439     */
3440    public TestScriptVariableComponent setDefaultValue(String value) {
3441      if (Utilities.noString(value))
3442        this.defaultValue = null;
3443      else {
3444        if (this.defaultValue == null)
3445          this.defaultValue = new StringType();
3446        this.defaultValue.setValue(value);
3447      }
3448      return this;
3449    }
3450
3451    /**
3452     * @return {@link #description} (A free text natural language description of the
3453     *         variable and its purpose.). This is the underlying object with id,
3454     *         value and extensions. The accessor "getDescription" gives direct
3455     *         access to the value
3456     */
3457    public StringType getDescriptionElement() {
3458      if (this.description == null)
3459        if (Configuration.errorOnAutoCreate())
3460          throw new Error("Attempt to auto-create TestScriptVariableComponent.description");
3461        else if (Configuration.doAutoCreate())
3462          this.description = new StringType(); // bb
3463      return this.description;
3464    }
3465
3466    public boolean hasDescriptionElement() {
3467      return this.description != null && !this.description.isEmpty();
3468    }
3469
3470    public boolean hasDescription() {
3471      return this.description != null && !this.description.isEmpty();
3472    }
3473
3474    /**
3475     * @param value {@link #description} (A free text natural language description
3476     *              of the variable and its purpose.). This is the underlying object
3477     *              with id, value and extensions. The accessor "getDescription"
3478     *              gives direct access to the value
3479     */
3480    public TestScriptVariableComponent setDescriptionElement(StringType value) {
3481      this.description = value;
3482      return this;
3483    }
3484
3485    /**
3486     * @return A free text natural language description of the variable and its
3487     *         purpose.
3488     */
3489    public String getDescription() {
3490      return this.description == null ? null : this.description.getValue();
3491    }
3492
3493    /**
3494     * @param value A free text natural language description of the variable and its
3495     *              purpose.
3496     */
3497    public TestScriptVariableComponent setDescription(String value) {
3498      if (Utilities.noString(value))
3499        this.description = null;
3500      else {
3501        if (this.description == null)
3502          this.description = new StringType();
3503        this.description.setValue(value);
3504      }
3505      return this;
3506    }
3507
3508    /**
3509     * @return {@link #expression} (The FHIRPath expression to evaluate against the
3510     *         fixture body. When variables are defined, only one of either
3511     *         expression, headerField or path must be specified.). This is the
3512     *         underlying object with id, value and extensions. The accessor
3513     *         "getExpression" gives direct access to the value
3514     */
3515    public StringType getExpressionElement() {
3516      if (this.expression == null)
3517        if (Configuration.errorOnAutoCreate())
3518          throw new Error("Attempt to auto-create TestScriptVariableComponent.expression");
3519        else if (Configuration.doAutoCreate())
3520          this.expression = new StringType(); // bb
3521      return this.expression;
3522    }
3523
3524    public boolean hasExpressionElement() {
3525      return this.expression != null && !this.expression.isEmpty();
3526    }
3527
3528    public boolean hasExpression() {
3529      return this.expression != null && !this.expression.isEmpty();
3530    }
3531
3532    /**
3533     * @param value {@link #expression} (The FHIRPath expression to evaluate against
3534     *              the fixture body. When variables are defined, only one of either
3535     *              expression, headerField or path must be specified.). This is the
3536     *              underlying object with id, value and extensions. The accessor
3537     *              "getExpression" gives direct access to the value
3538     */
3539    public TestScriptVariableComponent setExpressionElement(StringType value) {
3540      this.expression = value;
3541      return this;
3542    }
3543
3544    /**
3545     * @return The FHIRPath expression to evaluate against the fixture body. When
3546     *         variables are defined, only one of either expression, headerField or
3547     *         path must be specified.
3548     */
3549    public String getExpression() {
3550      return this.expression == null ? null : this.expression.getValue();
3551    }
3552
3553    /**
3554     * @param value The FHIRPath expression to evaluate against the fixture body.
3555     *              When variables are defined, only one of either expression,
3556     *              headerField or path must be specified.
3557     */
3558    public TestScriptVariableComponent setExpression(String value) {
3559      if (Utilities.noString(value))
3560        this.expression = null;
3561      else {
3562        if (this.expression == null)
3563          this.expression = new StringType();
3564        this.expression.setValue(value);
3565      }
3566      return this;
3567    }
3568
3569    /**
3570     * @return {@link #headerField} (Will be used to grab the HTTP header field
3571     *         value from the headers that sourceId is pointing to.). This is the
3572     *         underlying object with id, value and extensions. The accessor
3573     *         "getHeaderField" gives direct access to the value
3574     */
3575    public StringType getHeaderFieldElement() {
3576      if (this.headerField == null)
3577        if (Configuration.errorOnAutoCreate())
3578          throw new Error("Attempt to auto-create TestScriptVariableComponent.headerField");
3579        else if (Configuration.doAutoCreate())
3580          this.headerField = new StringType(); // bb
3581      return this.headerField;
3582    }
3583
3584    public boolean hasHeaderFieldElement() {
3585      return this.headerField != null && !this.headerField.isEmpty();
3586    }
3587
3588    public boolean hasHeaderField() {
3589      return this.headerField != null && !this.headerField.isEmpty();
3590    }
3591
3592    /**
3593     * @param value {@link #headerField} (Will be used to grab the HTTP header field
3594     *              value from the headers that sourceId is pointing to.). This is
3595     *              the underlying object with id, value and extensions. The
3596     *              accessor "getHeaderField" gives direct access to the value
3597     */
3598    public TestScriptVariableComponent setHeaderFieldElement(StringType value) {
3599      this.headerField = value;
3600      return this;
3601    }
3602
3603    /**
3604     * @return Will be used to grab the HTTP header field value from the headers
3605     *         that sourceId is pointing to.
3606     */
3607    public String getHeaderField() {
3608      return this.headerField == null ? null : this.headerField.getValue();
3609    }
3610
3611    /**
3612     * @param value Will be used to grab the HTTP header field value from the
3613     *              headers that sourceId is pointing to.
3614     */
3615    public TestScriptVariableComponent setHeaderField(String value) {
3616      if (Utilities.noString(value))
3617        this.headerField = null;
3618      else {
3619        if (this.headerField == null)
3620          this.headerField = new StringType();
3621        this.headerField.setValue(value);
3622      }
3623      return this;
3624    }
3625
3626    /**
3627     * @return {@link #hint} (Displayable text string with hint help information to
3628     *         the user when entering a default value.). This is the underlying
3629     *         object with id, value and extensions. The accessor "getHint" gives
3630     *         direct access to the value
3631     */
3632    public StringType getHintElement() {
3633      if (this.hint == null)
3634        if (Configuration.errorOnAutoCreate())
3635          throw new Error("Attempt to auto-create TestScriptVariableComponent.hint");
3636        else if (Configuration.doAutoCreate())
3637          this.hint = new StringType(); // bb
3638      return this.hint;
3639    }
3640
3641    public boolean hasHintElement() {
3642      return this.hint != null && !this.hint.isEmpty();
3643    }
3644
3645    public boolean hasHint() {
3646      return this.hint != null && !this.hint.isEmpty();
3647    }
3648
3649    /**
3650     * @param value {@link #hint} (Displayable text string with hint help
3651     *              information to the user when entering a default value.). This is
3652     *              the underlying object with id, value and extensions. The
3653     *              accessor "getHint" gives direct access to the value
3654     */
3655    public TestScriptVariableComponent setHintElement(StringType value) {
3656      this.hint = value;
3657      return this;
3658    }
3659
3660    /**
3661     * @return Displayable text string with hint help information to the user when
3662     *         entering a default value.
3663     */
3664    public String getHint() {
3665      return this.hint == null ? null : this.hint.getValue();
3666    }
3667
3668    /**
3669     * @param value Displayable text string with hint help information to the user
3670     *              when entering a default value.
3671     */
3672    public TestScriptVariableComponent setHint(String value) {
3673      if (Utilities.noString(value))
3674        this.hint = null;
3675      else {
3676        if (this.hint == null)
3677          this.hint = new StringType();
3678        this.hint.setValue(value);
3679      }
3680      return this;
3681    }
3682
3683    /**
3684     * @return {@link #path} (XPath or JSONPath to evaluate against the fixture
3685     *         body. When variables are defined, only one of either expression,
3686     *         headerField or path must be specified.). This is the underlying
3687     *         object with id, value and extensions. The accessor "getPath" gives
3688     *         direct access to the value
3689     */
3690    public StringType getPathElement() {
3691      if (this.path == null)
3692        if (Configuration.errorOnAutoCreate())
3693          throw new Error("Attempt to auto-create TestScriptVariableComponent.path");
3694        else if (Configuration.doAutoCreate())
3695          this.path = new StringType(); // bb
3696      return this.path;
3697    }
3698
3699    public boolean hasPathElement() {
3700      return this.path != null && !this.path.isEmpty();
3701    }
3702
3703    public boolean hasPath() {
3704      return this.path != null && !this.path.isEmpty();
3705    }
3706
3707    /**
3708     * @param value {@link #path} (XPath or JSONPath to evaluate against the fixture
3709     *              body. When variables are defined, only one of either expression,
3710     *              headerField or path must be specified.). This is the underlying
3711     *              object with id, value and extensions. The accessor "getPath"
3712     *              gives direct access to the value
3713     */
3714    public TestScriptVariableComponent setPathElement(StringType value) {
3715      this.path = value;
3716      return this;
3717    }
3718
3719    /**
3720     * @return XPath or JSONPath to evaluate against the fixture body. When
3721     *         variables are defined, only one of either expression, headerField or
3722     *         path must be specified.
3723     */
3724    public String getPath() {
3725      return this.path == null ? null : this.path.getValue();
3726    }
3727
3728    /**
3729     * @param value XPath or JSONPath to evaluate against the fixture body. When
3730     *              variables are defined, only one of either expression,
3731     *              headerField or path must be specified.
3732     */
3733    public TestScriptVariableComponent setPath(String value) {
3734      if (Utilities.noString(value))
3735        this.path = null;
3736      else {
3737        if (this.path == null)
3738          this.path = new StringType();
3739        this.path.setValue(value);
3740      }
3741      return this;
3742    }
3743
3744    /**
3745     * @return {@link #sourceId} (Fixture to evaluate the XPath/JSONPath expression
3746     *         or the headerField against within this variable.). This is the
3747     *         underlying object with id, value and extensions. The accessor
3748     *         "getSourceId" gives direct access to the value
3749     */
3750    public IdType getSourceIdElement() {
3751      if (this.sourceId == null)
3752        if (Configuration.errorOnAutoCreate())
3753          throw new Error("Attempt to auto-create TestScriptVariableComponent.sourceId");
3754        else if (Configuration.doAutoCreate())
3755          this.sourceId = new IdType(); // bb
3756      return this.sourceId;
3757    }
3758
3759    public boolean hasSourceIdElement() {
3760      return this.sourceId != null && !this.sourceId.isEmpty();
3761    }
3762
3763    public boolean hasSourceId() {
3764      return this.sourceId != null && !this.sourceId.isEmpty();
3765    }
3766
3767    /**
3768     * @param value {@link #sourceId} (Fixture to evaluate the XPath/JSONPath
3769     *              expression or the headerField against within this variable.).
3770     *              This is the underlying object with id, value and extensions. The
3771     *              accessor "getSourceId" gives direct access to the value
3772     */
3773    public TestScriptVariableComponent setSourceIdElement(IdType value) {
3774      this.sourceId = value;
3775      return this;
3776    }
3777
3778    /**
3779     * @return Fixture to evaluate the XPath/JSONPath expression or the headerField
3780     *         against within this variable.
3781     */
3782    public String getSourceId() {
3783      return this.sourceId == null ? null : this.sourceId.getValue();
3784    }
3785
3786    /**
3787     * @param value Fixture to evaluate the XPath/JSONPath expression or the
3788     *              headerField against within this variable.
3789     */
3790    public TestScriptVariableComponent setSourceId(String value) {
3791      if (Utilities.noString(value))
3792        this.sourceId = null;
3793      else {
3794        if (this.sourceId == null)
3795          this.sourceId = new IdType();
3796        this.sourceId.setValue(value);
3797      }
3798      return this;
3799    }
3800
3801    protected void listChildren(List<Property> children) {
3802      super.listChildren(children);
3803      children.add(new Property("name", "string", "Descriptive name for this variable.", 0, 1, name));
3804      children.add(new Property("defaultValue", "string",
3805          "A default, hard-coded, or user-defined value for this variable.", 0, 1, defaultValue));
3806      children.add(new Property("description", "string",
3807          "A free text natural language description of the variable and its purpose.", 0, 1, description));
3808      children.add(new Property("expression", "string",
3809          "The FHIRPath expression to evaluate against the fixture body. When variables are defined, only one of either expression, headerField or path must be specified.",
3810          0, 1, expression));
3811      children.add(new Property("headerField", "string",
3812          "Will be used to grab the HTTP header field value from the headers that sourceId is pointing to.", 0, 1,
3813          headerField));
3814      children.add(new Property("hint", "string",
3815          "Displayable text string with hint help information to the user when entering a default value.", 0, 1, hint));
3816      children.add(new Property("path", "string",
3817          "XPath or JSONPath to evaluate against the fixture body.  When variables are defined, only one of either expression, headerField or path must be specified.",
3818          0, 1, path));
3819      children.add(new Property("sourceId", "id",
3820          "Fixture to evaluate the XPath/JSONPath expression or the headerField  against within this variable.", 0, 1,
3821          sourceId));
3822    }
3823
3824    @Override
3825    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
3826      switch (_hash) {
3827      case 3373707:
3828        /* name */ return new Property("name", "string", "Descriptive name for this variable.", 0, 1, name);
3829      case -659125328:
3830        /* defaultValue */ return new Property("defaultValue", "string",
3831            "A default, hard-coded, or user-defined value for this variable.", 0, 1, defaultValue);
3832      case -1724546052:
3833        /* description */ return new Property("description", "string",
3834            "A free text natural language description of the variable and its purpose.", 0, 1, description);
3835      case -1795452264:
3836        /* expression */ return new Property("expression", "string",
3837            "The FHIRPath expression to evaluate against the fixture body. When variables are defined, only one of either expression, headerField or path must be specified.",
3838            0, 1, expression);
3839      case 1160732269:
3840        /* headerField */ return new Property("headerField", "string",
3841            "Will be used to grab the HTTP header field value from the headers that sourceId is pointing to.", 0, 1,
3842            headerField);
3843      case 3202695:
3844        /* hint */ return new Property("hint", "string",
3845            "Displayable text string with hint help information to the user when entering a default value.", 0, 1,
3846            hint);
3847      case 3433509:
3848        /* path */ return new Property("path", "string",
3849            "XPath or JSONPath to evaluate against the fixture body.  When variables are defined, only one of either expression, headerField or path must be specified.",
3850            0, 1, path);
3851      case 1746327190:
3852        /* sourceId */ return new Property("sourceId", "id",
3853            "Fixture to evaluate the XPath/JSONPath expression or the headerField  against within this variable.", 0, 1,
3854            sourceId);
3855      default:
3856        return super.getNamedProperty(_hash, _name, _checkValid);
3857      }
3858
3859    }
3860
3861    @Override
3862    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3863      switch (hash) {
3864      case 3373707:
3865        /* name */ return this.name == null ? new Base[0] : new Base[] { this.name }; // StringType
3866      case -659125328:
3867        /* defaultValue */ return this.defaultValue == null ? new Base[0] : new Base[] { this.defaultValue }; // StringType
3868      case -1724546052:
3869        /* description */ return this.description == null ? new Base[0] : new Base[] { this.description }; // StringType
3870      case -1795452264:
3871        /* expression */ return this.expression == null ? new Base[0] : new Base[] { this.expression }; // StringType
3872      case 1160732269:
3873        /* headerField */ return this.headerField == null ? new Base[0] : new Base[] { this.headerField }; // StringType
3874      case 3202695:
3875        /* hint */ return this.hint == null ? new Base[0] : new Base[] { this.hint }; // StringType
3876      case 3433509:
3877        /* path */ return this.path == null ? new Base[0] : new Base[] { this.path }; // StringType
3878      case 1746327190:
3879        /* sourceId */ return this.sourceId == null ? new Base[0] : new Base[] { this.sourceId }; // IdType
3880      default:
3881        return super.getProperty(hash, name, checkValid);
3882      }
3883
3884    }
3885
3886    @Override
3887    public Base setProperty(int hash, String name, Base value) throws FHIRException {
3888      switch (hash) {
3889      case 3373707: // name
3890        this.name = castToString(value); // StringType
3891        return value;
3892      case -659125328: // defaultValue
3893        this.defaultValue = castToString(value); // StringType
3894        return value;
3895      case -1724546052: // description
3896        this.description = castToString(value); // StringType
3897        return value;
3898      case -1795452264: // expression
3899        this.expression = castToString(value); // StringType
3900        return value;
3901      case 1160732269: // headerField
3902        this.headerField = castToString(value); // StringType
3903        return value;
3904      case 3202695: // hint
3905        this.hint = castToString(value); // StringType
3906        return value;
3907      case 3433509: // path
3908        this.path = castToString(value); // StringType
3909        return value;
3910      case 1746327190: // sourceId
3911        this.sourceId = castToId(value); // IdType
3912        return value;
3913      default:
3914        return super.setProperty(hash, name, value);
3915      }
3916
3917    }
3918
3919    @Override
3920    public Base setProperty(String name, Base value) throws FHIRException {
3921      if (name.equals("name")) {
3922        this.name = castToString(value); // StringType
3923      } else if (name.equals("defaultValue")) {
3924        this.defaultValue = castToString(value); // StringType
3925      } else if (name.equals("description")) {
3926        this.description = castToString(value); // StringType
3927      } else if (name.equals("expression")) {
3928        this.expression = castToString(value); // StringType
3929      } else if (name.equals("headerField")) {
3930        this.headerField = castToString(value); // StringType
3931      } else if (name.equals("hint")) {
3932        this.hint = castToString(value); // StringType
3933      } else if (name.equals("path")) {
3934        this.path = castToString(value); // StringType
3935      } else if (name.equals("sourceId")) {
3936        this.sourceId = castToId(value); // IdType
3937      } else
3938        return super.setProperty(name, value);
3939      return value;
3940    }
3941
3942    @Override
3943    public Base makeProperty(int hash, String name) throws FHIRException {
3944      switch (hash) {
3945      case 3373707:
3946        return getNameElement();
3947      case -659125328:
3948        return getDefaultValueElement();
3949      case -1724546052:
3950        return getDescriptionElement();
3951      case -1795452264:
3952        return getExpressionElement();
3953      case 1160732269:
3954        return getHeaderFieldElement();
3955      case 3202695:
3956        return getHintElement();
3957      case 3433509:
3958        return getPathElement();
3959      case 1746327190:
3960        return getSourceIdElement();
3961      default:
3962        return super.makeProperty(hash, name);
3963      }
3964
3965    }
3966
3967    @Override
3968    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
3969      switch (hash) {
3970      case 3373707:
3971        /* name */ return new String[] { "string" };
3972      case -659125328:
3973        /* defaultValue */ return new String[] { "string" };
3974      case -1724546052:
3975        /* description */ return new String[] { "string" };
3976      case -1795452264:
3977        /* expression */ return new String[] { "string" };
3978      case 1160732269:
3979        /* headerField */ return new String[] { "string" };
3980      case 3202695:
3981        /* hint */ return new String[] { "string" };
3982      case 3433509:
3983        /* path */ return new String[] { "string" };
3984      case 1746327190:
3985        /* sourceId */ return new String[] { "id" };
3986      default:
3987        return super.getTypesForProperty(hash, name);
3988      }
3989
3990    }
3991
3992    @Override
3993    public Base addChild(String name) throws FHIRException {
3994      if (name.equals("name")) {
3995        throw new FHIRException("Cannot call addChild on a singleton property TestScript.name");
3996      } else if (name.equals("defaultValue")) {
3997        throw new FHIRException("Cannot call addChild on a singleton property TestScript.defaultValue");
3998      } else if (name.equals("description")) {
3999        throw new FHIRException("Cannot call addChild on a singleton property TestScript.description");
4000      } else if (name.equals("expression")) {
4001        throw new FHIRException("Cannot call addChild on a singleton property TestScript.expression");
4002      } else if (name.equals("headerField")) {
4003        throw new FHIRException("Cannot call addChild on a singleton property TestScript.headerField");
4004      } else if (name.equals("hint")) {
4005        throw new FHIRException("Cannot call addChild on a singleton property TestScript.hint");
4006      } else if (name.equals("path")) {
4007        throw new FHIRException("Cannot call addChild on a singleton property TestScript.path");
4008      } else if (name.equals("sourceId")) {
4009        throw new FHIRException("Cannot call addChild on a singleton property TestScript.sourceId");
4010      } else
4011        return super.addChild(name);
4012    }
4013
4014    public TestScriptVariableComponent copy() {
4015      TestScriptVariableComponent dst = new TestScriptVariableComponent();
4016      copyValues(dst);
4017      return dst;
4018    }
4019
4020    public void copyValues(TestScriptVariableComponent dst) {
4021      super.copyValues(dst);
4022      dst.name = name == null ? null : name.copy();
4023      dst.defaultValue = defaultValue == null ? null : defaultValue.copy();
4024      dst.description = description == null ? null : description.copy();
4025      dst.expression = expression == null ? null : expression.copy();
4026      dst.headerField = headerField == null ? null : headerField.copy();
4027      dst.hint = hint == null ? null : hint.copy();
4028      dst.path = path == null ? null : path.copy();
4029      dst.sourceId = sourceId == null ? null : sourceId.copy();
4030    }
4031
4032    @Override
4033    public boolean equalsDeep(Base other_) {
4034      if (!super.equalsDeep(other_))
4035        return false;
4036      if (!(other_ instanceof TestScriptVariableComponent))
4037        return false;
4038      TestScriptVariableComponent o = (TestScriptVariableComponent) other_;
4039      return compareDeep(name, o.name, true) && compareDeep(defaultValue, o.defaultValue, true)
4040          && compareDeep(description, o.description, true) && compareDeep(expression, o.expression, true)
4041          && compareDeep(headerField, o.headerField, true) && compareDeep(hint, o.hint, true)
4042          && compareDeep(path, o.path, true) && compareDeep(sourceId, o.sourceId, true);
4043    }
4044
4045    @Override
4046    public boolean equalsShallow(Base other_) {
4047      if (!super.equalsShallow(other_))
4048        return false;
4049      if (!(other_ instanceof TestScriptVariableComponent))
4050        return false;
4051      TestScriptVariableComponent o = (TestScriptVariableComponent) other_;
4052      return compareValues(name, o.name, true) && compareValues(defaultValue, o.defaultValue, true)
4053          && compareValues(description, o.description, true) && compareValues(expression, o.expression, true)
4054          && compareValues(headerField, o.headerField, true) && compareValues(hint, o.hint, true)
4055          && compareValues(path, o.path, true) && compareValues(sourceId, o.sourceId, true);
4056    }
4057
4058    public boolean isEmpty() {
4059      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, defaultValue, description, expression,
4060          headerField, hint, path, sourceId);
4061    }
4062
4063    public String fhirType() {
4064      return "TestScript.variable";
4065
4066    }
4067
4068  }
4069
4070  @Block()
4071  public static class TestScriptSetupComponent extends BackboneElement implements IBaseBackboneElement {
4072    /**
4073     * Action would contain either an operation or an assertion.
4074     */
4075    @Child(name = "action", type = {}, order = 1, min = 1, max = Child.MAX_UNLIMITED, modifier = false, summary = false)
4076    @Description(shortDefinition = "A setup operation or assert to perform", formalDefinition = "Action would contain either an operation or an assertion.")
4077    protected List<SetupActionComponent> action;
4078
4079    private static final long serialVersionUID = -123374486L;
4080
4081    /**
4082     * Constructor
4083     */
4084    public TestScriptSetupComponent() {
4085      super();
4086    }
4087
4088    /**
4089     * @return {@link #action} (Action would contain either an operation or an
4090     *         assertion.)
4091     */
4092    public List<SetupActionComponent> getAction() {
4093      if (this.action == null)
4094        this.action = new ArrayList<SetupActionComponent>();
4095      return this.action;
4096    }
4097
4098    /**
4099     * @return Returns a reference to <code>this</code> for easy method chaining
4100     */
4101    public TestScriptSetupComponent setAction(List<SetupActionComponent> theAction) {
4102      this.action = theAction;
4103      return this;
4104    }
4105
4106    public boolean hasAction() {
4107      if (this.action == null)
4108        return false;
4109      for (SetupActionComponent item : this.action)
4110        if (!item.isEmpty())
4111          return true;
4112      return false;
4113    }
4114
4115    public SetupActionComponent addAction() { // 3
4116      SetupActionComponent t = new SetupActionComponent();
4117      if (this.action == null)
4118        this.action = new ArrayList<SetupActionComponent>();
4119      this.action.add(t);
4120      return t;
4121    }
4122
4123    public TestScriptSetupComponent addAction(SetupActionComponent t) { // 3
4124      if (t == null)
4125        return this;
4126      if (this.action == null)
4127        this.action = new ArrayList<SetupActionComponent>();
4128      this.action.add(t);
4129      return this;
4130    }
4131
4132    /**
4133     * @return The first repetition of repeating field {@link #action}, creating it
4134     *         if it does not already exist
4135     */
4136    public SetupActionComponent getActionFirstRep() {
4137      if (getAction().isEmpty()) {
4138        addAction();
4139      }
4140      return getAction().get(0);
4141    }
4142
4143    protected void listChildren(List<Property> children) {
4144      super.listChildren(children);
4145      children.add(new Property("action", "", "Action would contain either an operation or an assertion.", 0,
4146          java.lang.Integer.MAX_VALUE, action));
4147    }
4148
4149    @Override
4150    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
4151      switch (_hash) {
4152      case -1422950858:
4153        /* action */ return new Property("action", "", "Action would contain either an operation or an assertion.", 0,
4154            java.lang.Integer.MAX_VALUE, action);
4155      default:
4156        return super.getNamedProperty(_hash, _name, _checkValid);
4157      }
4158
4159    }
4160
4161    @Override
4162    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
4163      switch (hash) {
4164      case -1422950858:
4165        /* action */ return this.action == null ? new Base[0] : this.action.toArray(new Base[this.action.size()]); // SetupActionComponent
4166      default:
4167        return super.getProperty(hash, name, checkValid);
4168      }
4169
4170    }
4171
4172    @Override
4173    public Base setProperty(int hash, String name, Base value) throws FHIRException {
4174      switch (hash) {
4175      case -1422950858: // action
4176        this.getAction().add((SetupActionComponent) value); // SetupActionComponent
4177        return value;
4178      default:
4179        return super.setProperty(hash, name, value);
4180      }
4181
4182    }
4183
4184    @Override
4185    public Base setProperty(String name, Base value) throws FHIRException {
4186      if (name.equals("action")) {
4187        this.getAction().add((SetupActionComponent) value);
4188      } else
4189        return super.setProperty(name, value);
4190      return value;
4191    }
4192
4193    @Override
4194    public Base makeProperty(int hash, String name) throws FHIRException {
4195      switch (hash) {
4196      case -1422950858:
4197        return addAction();
4198      default:
4199        return super.makeProperty(hash, name);
4200      }
4201
4202    }
4203
4204    @Override
4205    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
4206      switch (hash) {
4207      case -1422950858:
4208        /* action */ return new String[] {};
4209      default:
4210        return super.getTypesForProperty(hash, name);
4211      }
4212
4213    }
4214
4215    @Override
4216    public Base addChild(String name) throws FHIRException {
4217      if (name.equals("action")) {
4218        return addAction();
4219      } else
4220        return super.addChild(name);
4221    }
4222
4223    public TestScriptSetupComponent copy() {
4224      TestScriptSetupComponent dst = new TestScriptSetupComponent();
4225      copyValues(dst);
4226      return dst;
4227    }
4228
4229    public void copyValues(TestScriptSetupComponent dst) {
4230      super.copyValues(dst);
4231      if (action != null) {
4232        dst.action = new ArrayList<SetupActionComponent>();
4233        for (SetupActionComponent i : action)
4234          dst.action.add(i.copy());
4235      }
4236      ;
4237    }
4238
4239    @Override
4240    public boolean equalsDeep(Base other_) {
4241      if (!super.equalsDeep(other_))
4242        return false;
4243      if (!(other_ instanceof TestScriptSetupComponent))
4244        return false;
4245      TestScriptSetupComponent o = (TestScriptSetupComponent) other_;
4246      return compareDeep(action, o.action, true);
4247    }
4248
4249    @Override
4250    public boolean equalsShallow(Base other_) {
4251      if (!super.equalsShallow(other_))
4252        return false;
4253      if (!(other_ instanceof TestScriptSetupComponent))
4254        return false;
4255      TestScriptSetupComponent o = (TestScriptSetupComponent) other_;
4256      return true;
4257    }
4258
4259    public boolean isEmpty() {
4260      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(action);
4261    }
4262
4263    public String fhirType() {
4264      return "TestScript.setup";
4265
4266    }
4267
4268  }
4269
4270  @Block()
4271  public static class SetupActionComponent extends BackboneElement implements IBaseBackboneElement {
4272    /**
4273     * The operation to perform.
4274     */
4275    @Child(name = "operation", type = {}, order = 1, min = 0, max = 1, modifier = false, summary = false)
4276    @Description(shortDefinition = "The setup operation to perform", formalDefinition = "The operation to perform.")
4277    protected SetupActionOperationComponent operation;
4278
4279    /**
4280     * Evaluates the results of previous operations to determine if the server under
4281     * test behaves appropriately.
4282     */
4283    @Child(name = "assert", type = {}, order = 2, min = 0, max = 1, modifier = false, summary = false)
4284    @Description(shortDefinition = "The assertion to perform", formalDefinition = "Evaluates the results of previous operations to determine if the server under test behaves appropriately.")
4285    protected SetupActionAssertComponent assert_;
4286
4287    private static final long serialVersionUID = -252088305L;
4288
4289    /**
4290     * Constructor
4291     */
4292    public SetupActionComponent() {
4293      super();
4294    }
4295
4296    /**
4297     * @return {@link #operation} (The operation to perform.)
4298     */
4299    public SetupActionOperationComponent getOperation() {
4300      if (this.operation == null)
4301        if (Configuration.errorOnAutoCreate())
4302          throw new Error("Attempt to auto-create SetupActionComponent.operation");
4303        else if (Configuration.doAutoCreate())
4304          this.operation = new SetupActionOperationComponent(); // cc
4305      return this.operation;
4306    }
4307
4308    public boolean hasOperation() {
4309      return this.operation != null && !this.operation.isEmpty();
4310    }
4311
4312    /**
4313     * @param value {@link #operation} (The operation to perform.)
4314     */
4315    public SetupActionComponent setOperation(SetupActionOperationComponent value) {
4316      this.operation = value;
4317      return this;
4318    }
4319
4320    /**
4321     * @return {@link #assert_} (Evaluates the results of previous operations to
4322     *         determine if the server under test behaves appropriately.)
4323     */
4324    public SetupActionAssertComponent getAssert() {
4325      if (this.assert_ == null)
4326        if (Configuration.errorOnAutoCreate())
4327          throw new Error("Attempt to auto-create SetupActionComponent.assert_");
4328        else if (Configuration.doAutoCreate())
4329          this.assert_ = new SetupActionAssertComponent(); // cc
4330      return this.assert_;
4331    }
4332
4333    public boolean hasAssert() {
4334      return this.assert_ != null && !this.assert_.isEmpty();
4335    }
4336
4337    /**
4338     * @param value {@link #assert_} (Evaluates the results of previous operations
4339     *              to determine if the server under test behaves appropriately.)
4340     */
4341    public SetupActionComponent setAssert(SetupActionAssertComponent value) {
4342      this.assert_ = value;
4343      return this;
4344    }
4345
4346    protected void listChildren(List<Property> children) {
4347      super.listChildren(children);
4348      children.add(new Property("operation", "", "The operation to perform.", 0, 1, operation));
4349      children.add(new Property("assert", "",
4350          "Evaluates the results of previous operations to determine if the server under test behaves appropriately.",
4351          0, 1, assert_));
4352    }
4353
4354    @Override
4355    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
4356      switch (_hash) {
4357      case 1662702951:
4358        /* operation */ return new Property("operation", "", "The operation to perform.", 0, 1, operation);
4359      case -1408208058:
4360        /* assert */ return new Property("assert", "",
4361            "Evaluates the results of previous operations to determine if the server under test behaves appropriately.",
4362            0, 1, assert_);
4363      default:
4364        return super.getNamedProperty(_hash, _name, _checkValid);
4365      }
4366
4367    }
4368
4369    @Override
4370    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
4371      switch (hash) {
4372      case 1662702951:
4373        /* operation */ return this.operation == null ? new Base[0] : new Base[] { this.operation }; // SetupActionOperationComponent
4374      case -1408208058:
4375        /* assert */ return this.assert_ == null ? new Base[0] : new Base[] { this.assert_ }; // SetupActionAssertComponent
4376      default:
4377        return super.getProperty(hash, name, checkValid);
4378      }
4379
4380    }
4381
4382    @Override
4383    public Base setProperty(int hash, String name, Base value) throws FHIRException {
4384      switch (hash) {
4385      case 1662702951: // operation
4386        this.operation = (SetupActionOperationComponent) value; // SetupActionOperationComponent
4387        return value;
4388      case -1408208058: // assert
4389        this.assert_ = (SetupActionAssertComponent) value; // SetupActionAssertComponent
4390        return value;
4391      default:
4392        return super.setProperty(hash, name, value);
4393      }
4394
4395    }
4396
4397    @Override
4398    public Base setProperty(String name, Base value) throws FHIRException {
4399      if (name.equals("operation")) {
4400        this.operation = (SetupActionOperationComponent) value; // SetupActionOperationComponent
4401      } else if (name.equals("assert")) {
4402        this.assert_ = (SetupActionAssertComponent) value; // SetupActionAssertComponent
4403      } else
4404        return super.setProperty(name, value);
4405      return value;
4406    }
4407
4408    @Override
4409    public Base makeProperty(int hash, String name) throws FHIRException {
4410      switch (hash) {
4411      case 1662702951:
4412        return getOperation();
4413      case -1408208058:
4414        return getAssert();
4415      default:
4416        return super.makeProperty(hash, name);
4417      }
4418
4419    }
4420
4421    @Override
4422    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
4423      switch (hash) {
4424      case 1662702951:
4425        /* operation */ return new String[] {};
4426      case -1408208058:
4427        /* assert */ return new String[] {};
4428      default:
4429        return super.getTypesForProperty(hash, name);
4430      }
4431
4432    }
4433
4434    @Override
4435    public Base addChild(String name) throws FHIRException {
4436      if (name.equals("operation")) {
4437        this.operation = new SetupActionOperationComponent();
4438        return this.operation;
4439      } else if (name.equals("assert")) {
4440        this.assert_ = new SetupActionAssertComponent();
4441        return this.assert_;
4442      } else
4443        return super.addChild(name);
4444    }
4445
4446    public SetupActionComponent copy() {
4447      SetupActionComponent dst = new SetupActionComponent();
4448      copyValues(dst);
4449      return dst;
4450    }
4451
4452    public void copyValues(SetupActionComponent dst) {
4453      super.copyValues(dst);
4454      dst.operation = operation == null ? null : operation.copy();
4455      dst.assert_ = assert_ == null ? null : assert_.copy();
4456    }
4457
4458    @Override
4459    public boolean equalsDeep(Base other_) {
4460      if (!super.equalsDeep(other_))
4461        return false;
4462      if (!(other_ instanceof SetupActionComponent))
4463        return false;
4464      SetupActionComponent o = (SetupActionComponent) other_;
4465      return compareDeep(operation, o.operation, true) && compareDeep(assert_, o.assert_, true);
4466    }
4467
4468    @Override
4469    public boolean equalsShallow(Base other_) {
4470      if (!super.equalsShallow(other_))
4471        return false;
4472      if (!(other_ instanceof SetupActionComponent))
4473        return false;
4474      SetupActionComponent o = (SetupActionComponent) other_;
4475      return true;
4476    }
4477
4478    public boolean isEmpty() {
4479      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(operation, assert_);
4480    }
4481
4482    public String fhirType() {
4483      return "TestScript.setup.action";
4484
4485    }
4486
4487  }
4488
4489  @Block()
4490  public static class SetupActionOperationComponent extends BackboneElement implements IBaseBackboneElement {
4491    /**
4492     * Server interaction or operation type.
4493     */
4494    @Child(name = "type", type = { Coding.class }, order = 1, min = 0, max = 1, modifier = false, summary = false)
4495    @Description(shortDefinition = "The operation code type that will be executed", formalDefinition = "Server interaction or operation type.")
4496    @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/testscript-operation-codes")
4497    protected Coding type;
4498
4499    /**
4500     * The type of the resource. See http://build.fhir.org/resourcelist.html.
4501     */
4502    @Child(name = "resource", type = { CodeType.class }, order = 2, min = 0, max = 1, modifier = false, summary = false)
4503    @Description(shortDefinition = "Resource type", formalDefinition = "The type of the resource.  See http://build.fhir.org/resourcelist.html.")
4504    @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/defined-types")
4505    protected CodeType resource;
4506
4507    /**
4508     * The label would be used for tracking/logging purposes by test engines.
4509     */
4510    @Child(name = "label", type = { StringType.class }, order = 3, min = 0, max = 1, modifier = false, summary = false)
4511    @Description(shortDefinition = "Tracking/logging operation label", formalDefinition = "The label would be used for tracking/logging purposes by test engines.")
4512    protected StringType label;
4513
4514    /**
4515     * The description would be used by test engines for tracking and reporting
4516     * purposes.
4517     */
4518    @Child(name = "description", type = {
4519        StringType.class }, order = 4, min = 0, max = 1, modifier = false, summary = false)
4520    @Description(shortDefinition = "Tracking/reporting operation description", formalDefinition = "The description would be used by test engines for tracking and reporting purposes.")
4521    protected StringType description;
4522
4523    /**
4524     * The mime-type to use for RESTful operation in the 'Accept' header.
4525     */
4526    @Child(name = "accept", type = { CodeType.class }, order = 5, min = 0, max = 1, modifier = false, summary = false)
4527    @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.")
4528    @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/mimetypes")
4529    protected CodeType accept;
4530
4531    /**
4532     * The mime-type to use for RESTful operation in the 'Content-Type' header.
4533     */
4534    @Child(name = "contentType", type = {
4535        CodeType.class }, order = 6, min = 0, max = 1, modifier = false, summary = false)
4536    @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.")
4537    @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/mimetypes")
4538    protected CodeType contentType;
4539
4540    /**
4541     * The server where the request message is destined for. Must be one of the
4542     * server numbers listed in TestScript.destination section.
4543     */
4544    @Child(name = "destination", type = {
4545        IntegerType.class }, order = 7, min = 0, max = 1, modifier = false, summary = false)
4546    @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.")
4547    protected IntegerType destination;
4548
4549    /**
4550     * Whether or not to implicitly send the request url in encoded format. The
4551     * default is true to match the standard RESTful client behavior. Set to false
4552     * when communicating with a server that does not support encoded url paths.
4553     */
4554    @Child(name = "encodeRequestUrl", type = {
4555        BooleanType.class }, order = 8, min = 1, max = 1, modifier = false, summary = false)
4556    @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.")
4557    protected BooleanType encodeRequestUrl;
4558
4559    /**
4560     * The HTTP method the test engine MUST use for this operation regardless of any
4561     * other operation details.
4562     */
4563    @Child(name = "method", type = { CodeType.class }, order = 9, min = 0, max = 1, modifier = false, summary = false)
4564    @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.")
4565    @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/http-operations")
4566    protected Enumeration<TestScriptRequestMethodCode> method;
4567
4568    /**
4569     * The server where the request message originates from. Must be one of the
4570     * server numbers listed in TestScript.origin section.
4571     */
4572    @Child(name = "origin", type = {
4573        IntegerType.class }, order = 10, min = 0, max = 1, modifier = false, summary = false)
4574    @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.")
4575    protected IntegerType origin;
4576
4577    /**
4578     * Path plus parameters after [type]. Used to set parts of the request URL
4579     * explicitly.
4580     */
4581    @Child(name = "params", type = {
4582        StringType.class }, order = 11, min = 0, max = 1, modifier = false, summary = false)
4583    @Description(shortDefinition = "Explicitly defined path parameters", formalDefinition = "Path plus parameters after [type].  Used to set parts of the request URL explicitly.")
4584    protected StringType params;
4585
4586    /**
4587     * Header elements would be used to set HTTP headers.
4588     */
4589    @Child(name = "requestHeader", type = {}, order = 12, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false)
4590    @Description(shortDefinition = "Each operation can have one or more header elements", formalDefinition = "Header elements would be used to set HTTP headers.")
4591    protected List<SetupActionOperationRequestHeaderComponent> requestHeader;
4592
4593    /**
4594     * The fixture id (maybe new) to map to the request.
4595     */
4596    @Child(name = "requestId", type = { IdType.class }, order = 13, min = 0, max = 1, modifier = false, summary = false)
4597    @Description(shortDefinition = "Fixture Id of mapped request", formalDefinition = "The fixture id (maybe new) to map to the request.")
4598    protected IdType requestId;
4599
4600    /**
4601     * The fixture id (maybe new) to map to the response.
4602     */
4603    @Child(name = "responseId", type = {
4604        IdType.class }, order = 14, min = 0, max = 1, modifier = false, summary = false)
4605    @Description(shortDefinition = "Fixture Id of mapped response", formalDefinition = "The fixture id (maybe new) to map to the response.")
4606    protected IdType responseId;
4607
4608    /**
4609     * The id of the fixture used as the body of a PUT or POST request.
4610     */
4611    @Child(name = "sourceId", type = { IdType.class }, order = 15, min = 0, max = 1, modifier = false, summary = false)
4612    @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.")
4613    protected IdType sourceId;
4614
4615    /**
4616     * Id of fixture used for extracting the [id], [type], and [vid] for GET
4617     * requests.
4618     */
4619    @Child(name = "targetId", type = { IdType.class }, order = 16, min = 0, max = 1, modifier = false, summary = false)
4620    @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.")
4621    protected IdType targetId;
4622
4623    /**
4624     * Complete request URL.
4625     */
4626    @Child(name = "url", type = { StringType.class }, order = 17, min = 0, max = 1, modifier = false, summary = false)
4627    @Description(shortDefinition = "Request URL", formalDefinition = "Complete request URL.")
4628    protected StringType url;
4629
4630    private static final long serialVersionUID = 300050202L;
4631
4632    /**
4633     * Constructor
4634     */
4635    public SetupActionOperationComponent() {
4636      super();
4637    }
4638
4639    /**
4640     * Constructor
4641     */
4642    public SetupActionOperationComponent(BooleanType encodeRequestUrl) {
4643      super();
4644      this.encodeRequestUrl = encodeRequestUrl;
4645    }
4646
4647    /**
4648     * @return {@link #type} (Server interaction or operation type.)
4649     */
4650    public Coding getType() {
4651      if (this.type == null)
4652        if (Configuration.errorOnAutoCreate())
4653          throw new Error("Attempt to auto-create SetupActionOperationComponent.type");
4654        else if (Configuration.doAutoCreate())
4655          this.type = new Coding(); // cc
4656      return this.type;
4657    }
4658
4659    public boolean hasType() {
4660      return this.type != null && !this.type.isEmpty();
4661    }
4662
4663    /**
4664     * @param value {@link #type} (Server interaction or operation type.)
4665     */
4666    public SetupActionOperationComponent setType(Coding value) {
4667      this.type = value;
4668      return this;
4669    }
4670
4671    /**
4672     * @return {@link #resource} (The type of the resource. See
4673     *         http://build.fhir.org/resourcelist.html.). This is the underlying
4674     *         object with id, value and extensions. The accessor "getResource"
4675     *         gives direct access to the value
4676     */
4677    public CodeType getResourceElement() {
4678      if (this.resource == null)
4679        if (Configuration.errorOnAutoCreate())
4680          throw new Error("Attempt to auto-create SetupActionOperationComponent.resource");
4681        else if (Configuration.doAutoCreate())
4682          this.resource = new CodeType(); // bb
4683      return this.resource;
4684    }
4685
4686    public boolean hasResourceElement() {
4687      return this.resource != null && !this.resource.isEmpty();
4688    }
4689
4690    public boolean hasResource() {
4691      return this.resource != null && !this.resource.isEmpty();
4692    }
4693
4694    /**
4695     * @param value {@link #resource} (The type of the resource. See
4696     *              http://build.fhir.org/resourcelist.html.). This is the
4697     *              underlying object with id, value and extensions. The accessor
4698     *              "getResource" gives direct access to the value
4699     */
4700    public SetupActionOperationComponent setResourceElement(CodeType value) {
4701      this.resource = value;
4702      return this;
4703    }
4704
4705    /**
4706     * @return The type of the resource. See
4707     *         http://build.fhir.org/resourcelist.html.
4708     */
4709    public String getResource() {
4710      return this.resource == null ? null : this.resource.getValue();
4711    }
4712
4713    /**
4714     * @param value The type of the resource. See
4715     *              http://build.fhir.org/resourcelist.html.
4716     */
4717    public SetupActionOperationComponent setResource(String value) {
4718      if (Utilities.noString(value))
4719        this.resource = null;
4720      else {
4721        if (this.resource == null)
4722          this.resource = new CodeType();
4723        this.resource.setValue(value);
4724      }
4725      return this;
4726    }
4727
4728    /**
4729     * @return {@link #label} (The label would be used for tracking/logging purposes
4730     *         by test engines.). This is the underlying object with id, value and
4731     *         extensions. The accessor "getLabel" gives direct access to the value
4732     */
4733    public StringType getLabelElement() {
4734      if (this.label == null)
4735        if (Configuration.errorOnAutoCreate())
4736          throw new Error("Attempt to auto-create SetupActionOperationComponent.label");
4737        else if (Configuration.doAutoCreate())
4738          this.label = new StringType(); // bb
4739      return this.label;
4740    }
4741
4742    public boolean hasLabelElement() {
4743      return this.label != null && !this.label.isEmpty();
4744    }
4745
4746    public boolean hasLabel() {
4747      return this.label != null && !this.label.isEmpty();
4748    }
4749
4750    /**
4751     * @param value {@link #label} (The label would be used for tracking/logging
4752     *              purposes by test engines.). This is the underlying object with
4753     *              id, value and extensions. The accessor "getLabel" gives direct
4754     *              access to the value
4755     */
4756    public SetupActionOperationComponent setLabelElement(StringType value) {
4757      this.label = value;
4758      return this;
4759    }
4760
4761    /**
4762     * @return The label would be used for tracking/logging purposes by test
4763     *         engines.
4764     */
4765    public String getLabel() {
4766      return this.label == null ? null : this.label.getValue();
4767    }
4768
4769    /**
4770     * @param value The label would be used for tracking/logging purposes by test
4771     *              engines.
4772     */
4773    public SetupActionOperationComponent setLabel(String value) {
4774      if (Utilities.noString(value))
4775        this.label = null;
4776      else {
4777        if (this.label == null)
4778          this.label = new StringType();
4779        this.label.setValue(value);
4780      }
4781      return this;
4782    }
4783
4784    /**
4785     * @return {@link #description} (The description would be used by test engines
4786     *         for tracking and reporting purposes.). This is the underlying object
4787     *         with id, value and extensions. The accessor "getDescription" gives
4788     *         direct access to the value
4789     */
4790    public StringType getDescriptionElement() {
4791      if (this.description == null)
4792        if (Configuration.errorOnAutoCreate())
4793          throw new Error("Attempt to auto-create SetupActionOperationComponent.description");
4794        else if (Configuration.doAutoCreate())
4795          this.description = new StringType(); // bb
4796      return this.description;
4797    }
4798
4799    public boolean hasDescriptionElement() {
4800      return this.description != null && !this.description.isEmpty();
4801    }
4802
4803    public boolean hasDescription() {
4804      return this.description != null && !this.description.isEmpty();
4805    }
4806
4807    /**
4808     * @param value {@link #description} (The description would be used by test
4809     *              engines for tracking and reporting purposes.). This is the
4810     *              underlying object with id, value and extensions. The accessor
4811     *              "getDescription" gives direct access to the value
4812     */
4813    public SetupActionOperationComponent setDescriptionElement(StringType value) {
4814      this.description = value;
4815      return this;
4816    }
4817
4818    /**
4819     * @return The description would be used by test engines for tracking and
4820     *         reporting purposes.
4821     */
4822    public String getDescription() {
4823      return this.description == null ? null : this.description.getValue();
4824    }
4825
4826    /**
4827     * @param value The description would be used by test engines for tracking and
4828     *              reporting purposes.
4829     */
4830    public SetupActionOperationComponent setDescription(String value) {
4831      if (Utilities.noString(value))
4832        this.description = null;
4833      else {
4834        if (this.description == null)
4835          this.description = new StringType();
4836        this.description.setValue(value);
4837      }
4838      return this;
4839    }
4840
4841    /**
4842     * @return {@link #accept} (The mime-type to use for RESTful operation in the
4843     *         'Accept' header.). This is the underlying object with id, value and
4844     *         extensions. The accessor "getAccept" gives direct access to the value
4845     */
4846    public CodeType getAcceptElement() {
4847      if (this.accept == null)
4848        if (Configuration.errorOnAutoCreate())
4849          throw new Error("Attempt to auto-create SetupActionOperationComponent.accept");
4850        else if (Configuration.doAutoCreate())
4851          this.accept = new CodeType(); // bb
4852      return this.accept;
4853    }
4854
4855    public boolean hasAcceptElement() {
4856      return this.accept != null && !this.accept.isEmpty();
4857    }
4858
4859    public boolean hasAccept() {
4860      return this.accept != null && !this.accept.isEmpty();
4861    }
4862
4863    /**
4864     * @param value {@link #accept} (The mime-type to use for RESTful operation in
4865     *              the 'Accept' header.). This is the underlying object with id,
4866     *              value and extensions. The accessor "getAccept" gives direct
4867     *              access to the value
4868     */
4869    public SetupActionOperationComponent setAcceptElement(CodeType value) {
4870      this.accept = value;
4871      return this;
4872    }
4873
4874    /**
4875     * @return The mime-type to use for RESTful operation in the 'Accept' header.
4876     */
4877    public String getAccept() {
4878      return this.accept == null ? null : this.accept.getValue();
4879    }
4880
4881    /**
4882     * @param value The mime-type to use for RESTful operation in the 'Accept'
4883     *              header.
4884     */
4885    public SetupActionOperationComponent setAccept(String value) {
4886      if (Utilities.noString(value))
4887        this.accept = null;
4888      else {
4889        if (this.accept == null)
4890          this.accept = new CodeType();
4891        this.accept.setValue(value);
4892      }
4893      return this;
4894    }
4895
4896    /**
4897     * @return {@link #contentType} (The mime-type to use for RESTful operation in
4898     *         the 'Content-Type' header.). This is the underlying object with id,
4899     *         value and extensions. The accessor "getContentType" gives direct
4900     *         access to the value
4901     */
4902    public CodeType getContentTypeElement() {
4903      if (this.contentType == null)
4904        if (Configuration.errorOnAutoCreate())
4905          throw new Error("Attempt to auto-create SetupActionOperationComponent.contentType");
4906        else if (Configuration.doAutoCreate())
4907          this.contentType = new CodeType(); // bb
4908      return this.contentType;
4909    }
4910
4911    public boolean hasContentTypeElement() {
4912      return this.contentType != null && !this.contentType.isEmpty();
4913    }
4914
4915    public boolean hasContentType() {
4916      return this.contentType != null && !this.contentType.isEmpty();
4917    }
4918
4919    /**
4920     * @param value {@link #contentType} (The mime-type to use for RESTful operation
4921     *              in the 'Content-Type' header.). This is the underlying object
4922     *              with id, value and extensions. The accessor "getContentType"
4923     *              gives direct access to the value
4924     */
4925    public SetupActionOperationComponent setContentTypeElement(CodeType value) {
4926      this.contentType = value;
4927      return this;
4928    }
4929
4930    /**
4931     * @return The mime-type to use for RESTful operation in the 'Content-Type'
4932     *         header.
4933     */
4934    public String getContentType() {
4935      return this.contentType == null ? null : this.contentType.getValue();
4936    }
4937
4938    /**
4939     * @param value The mime-type to use for RESTful operation in the 'Content-Type'
4940     *              header.
4941     */
4942    public SetupActionOperationComponent setContentType(String value) {
4943      if (Utilities.noString(value))
4944        this.contentType = null;
4945      else {
4946        if (this.contentType == null)
4947          this.contentType = new CodeType();
4948        this.contentType.setValue(value);
4949      }
4950      return this;
4951    }
4952
4953    /**
4954     * @return {@link #destination} (The server where the request message is
4955     *         destined for. Must be one of the server numbers listed in
4956     *         TestScript.destination section.). This is the underlying object with
4957     *         id, value and extensions. The accessor "getDestination" gives direct
4958     *         access to the value
4959     */
4960    public IntegerType getDestinationElement() {
4961      if (this.destination == null)
4962        if (Configuration.errorOnAutoCreate())
4963          throw new Error("Attempt to auto-create SetupActionOperationComponent.destination");
4964        else if (Configuration.doAutoCreate())
4965          this.destination = new IntegerType(); // bb
4966      return this.destination;
4967    }
4968
4969    public boolean hasDestinationElement() {
4970      return this.destination != null && !this.destination.isEmpty();
4971    }
4972
4973    public boolean hasDestination() {
4974      return this.destination != null && !this.destination.isEmpty();
4975    }
4976
4977    /**
4978     * @param value {@link #destination} (The server where the request message is
4979     *              destined for. Must be one of the server numbers listed in
4980     *              TestScript.destination section.). This is the underlying object
4981     *              with id, value and extensions. The accessor "getDestination"
4982     *              gives direct access to the value
4983     */
4984    public SetupActionOperationComponent setDestinationElement(IntegerType value) {
4985      this.destination = value;
4986      return this;
4987    }
4988
4989    /**
4990     * @return The server where the request message is destined for. Must be one of
4991     *         the server numbers listed in TestScript.destination section.
4992     */
4993    public int getDestination() {
4994      return this.destination == null || this.destination.isEmpty() ? 0 : this.destination.getValue();
4995    }
4996
4997    /**
4998     * @param value The server where the request message is destined for. Must be
4999     *              one of the server numbers listed in TestScript.destination
5000     *              section.
5001     */
5002    public SetupActionOperationComponent setDestination(int value) {
5003      if (this.destination == null)
5004        this.destination = new IntegerType();
5005      this.destination.setValue(value);
5006      return this;
5007    }
5008
5009    /**
5010     * @return {@link #encodeRequestUrl} (Whether or not to implicitly send the
5011     *         request url in encoded format. The default is true to match the
5012     *         standard RESTful client behavior. Set to false when communicating
5013     *         with a server that does not support encoded url paths.). This is the
5014     *         underlying object with id, value and extensions. The accessor
5015     *         "getEncodeRequestUrl" gives direct access to the value
5016     */
5017    public BooleanType getEncodeRequestUrlElement() {
5018      if (this.encodeRequestUrl == null)
5019        if (Configuration.errorOnAutoCreate())
5020          throw new Error("Attempt to auto-create SetupActionOperationComponent.encodeRequestUrl");
5021        else if (Configuration.doAutoCreate())
5022          this.encodeRequestUrl = new BooleanType(); // bb
5023      return this.encodeRequestUrl;
5024    }
5025
5026    public boolean hasEncodeRequestUrlElement() {
5027      return this.encodeRequestUrl != null && !this.encodeRequestUrl.isEmpty();
5028    }
5029
5030    public boolean hasEncodeRequestUrl() {
5031      return this.encodeRequestUrl != null && !this.encodeRequestUrl.isEmpty();
5032    }
5033
5034    /**
5035     * @param value {@link #encodeRequestUrl} (Whether or not to implicitly send the
5036     *              request url in encoded format. The default is true to match the
5037     *              standard RESTful client behavior. Set to false when
5038     *              communicating with a server that does not support encoded url
5039     *              paths.). This is the underlying object with id, value and
5040     *              extensions. The accessor "getEncodeRequestUrl" gives direct
5041     *              access to the value
5042     */
5043    public SetupActionOperationComponent setEncodeRequestUrlElement(BooleanType value) {
5044      this.encodeRequestUrl = value;
5045      return this;
5046    }
5047
5048    /**
5049     * @return Whether or not to implicitly send the request url in encoded format.
5050     *         The default is true to match the standard RESTful client behavior.
5051     *         Set to false when communicating with a server that does not support
5052     *         encoded url paths.
5053     */
5054    public boolean getEncodeRequestUrl() {
5055      return this.encodeRequestUrl == null || this.encodeRequestUrl.isEmpty() ? false
5056          : this.encodeRequestUrl.getValue();
5057    }
5058
5059    /**
5060     * @param value Whether or not to implicitly send the request url in encoded
5061     *              format. The default is true to match the standard RESTful client
5062     *              behavior. Set to false when communicating with a server that
5063     *              does not support encoded url paths.
5064     */
5065    public SetupActionOperationComponent setEncodeRequestUrl(boolean value) {
5066      if (this.encodeRequestUrl == null)
5067        this.encodeRequestUrl = new BooleanType();
5068      this.encodeRequestUrl.setValue(value);
5069      return this;
5070    }
5071
5072    /**
5073     * @return {@link #method} (The HTTP method the test engine MUST use for this
5074     *         operation regardless of any other operation details.). This is the
5075     *         underlying object with id, value and extensions. The accessor
5076     *         "getMethod" gives direct access to the value
5077     */
5078    public Enumeration<TestScriptRequestMethodCode> getMethodElement() {
5079      if (this.method == null)
5080        if (Configuration.errorOnAutoCreate())
5081          throw new Error("Attempt to auto-create SetupActionOperationComponent.method");
5082        else if (Configuration.doAutoCreate())
5083          this.method = new Enumeration<TestScriptRequestMethodCode>(new TestScriptRequestMethodCodeEnumFactory()); // bb
5084      return this.method;
5085    }
5086
5087    public boolean hasMethodElement() {
5088      return this.method != null && !this.method.isEmpty();
5089    }
5090
5091    public boolean hasMethod() {
5092      return this.method != null && !this.method.isEmpty();
5093    }
5094
5095    /**
5096     * @param value {@link #method} (The HTTP method the test engine MUST use for
5097     *              this operation regardless of any other operation details.). This
5098     *              is the underlying object with id, value and extensions. The
5099     *              accessor "getMethod" gives direct access to the value
5100     */
5101    public SetupActionOperationComponent setMethodElement(Enumeration<TestScriptRequestMethodCode> value) {
5102      this.method = value;
5103      return this;
5104    }
5105
5106    /**
5107     * @return The HTTP method the test engine MUST use for this operation
5108     *         regardless of any other operation details.
5109     */
5110    public TestScriptRequestMethodCode getMethod() {
5111      return this.method == null ? null : this.method.getValue();
5112    }
5113
5114    /**
5115     * @param value The HTTP method the test engine MUST use for this operation
5116     *              regardless of any other operation details.
5117     */
5118    public SetupActionOperationComponent setMethod(TestScriptRequestMethodCode value) {
5119      if (value == null)
5120        this.method = null;
5121      else {
5122        if (this.method == null)
5123          this.method = new Enumeration<TestScriptRequestMethodCode>(new TestScriptRequestMethodCodeEnumFactory());
5124        this.method.setValue(value);
5125      }
5126      return this;
5127    }
5128
5129    /**
5130     * @return {@link #origin} (The server where the request message originates
5131     *         from. Must be one of the server numbers listed in TestScript.origin
5132     *         section.). This is the underlying object with id, value and
5133     *         extensions. The accessor "getOrigin" gives direct access to the value
5134     */
5135    public IntegerType getOriginElement() {
5136      if (this.origin == null)
5137        if (Configuration.errorOnAutoCreate())
5138          throw new Error("Attempt to auto-create SetupActionOperationComponent.origin");
5139        else if (Configuration.doAutoCreate())
5140          this.origin = new IntegerType(); // bb
5141      return this.origin;
5142    }
5143
5144    public boolean hasOriginElement() {
5145      return this.origin != null && !this.origin.isEmpty();
5146    }
5147
5148    public boolean hasOrigin() {
5149      return this.origin != null && !this.origin.isEmpty();
5150    }
5151
5152    /**
5153     * @param value {@link #origin} (The server where the request message originates
5154     *              from. Must be one of the server numbers listed in
5155     *              TestScript.origin section.). This is the underlying object with
5156     *              id, value and extensions. The accessor "getOrigin" gives direct
5157     *              access to the value
5158     */
5159    public SetupActionOperationComponent setOriginElement(IntegerType value) {
5160      this.origin = value;
5161      return this;
5162    }
5163
5164    /**
5165     * @return The server where the request message originates from. Must be one of
5166     *         the server numbers listed in TestScript.origin section.
5167     */
5168    public int getOrigin() {
5169      return this.origin == null || this.origin.isEmpty() ? 0 : this.origin.getValue();
5170    }
5171
5172    /**
5173     * @param value The server where the request message originates from. Must be
5174     *              one of the server numbers listed in TestScript.origin section.
5175     */
5176    public SetupActionOperationComponent setOrigin(int value) {
5177      if (this.origin == null)
5178        this.origin = new IntegerType();
5179      this.origin.setValue(value);
5180      return this;
5181    }
5182
5183    /**
5184     * @return {@link #params} (Path plus parameters after [type]. Used to set parts
5185     *         of the request URL explicitly.). This is the underlying object with
5186     *         id, value and extensions. The accessor "getParams" gives direct
5187     *         access to the value
5188     */
5189    public StringType getParamsElement() {
5190      if (this.params == null)
5191        if (Configuration.errorOnAutoCreate())
5192          throw new Error("Attempt to auto-create SetupActionOperationComponent.params");
5193        else if (Configuration.doAutoCreate())
5194          this.params = new StringType(); // bb
5195      return this.params;
5196    }
5197
5198    public boolean hasParamsElement() {
5199      return this.params != null && !this.params.isEmpty();
5200    }
5201
5202    public boolean hasParams() {
5203      return this.params != null && !this.params.isEmpty();
5204    }
5205
5206    /**
5207     * @param value {@link #params} (Path plus parameters after [type]. Used to set
5208     *              parts of the request URL explicitly.). This is the underlying
5209     *              object with id, value and extensions. The accessor "getParams"
5210     *              gives direct access to the value
5211     */
5212    public SetupActionOperationComponent setParamsElement(StringType value) {
5213      this.params = value;
5214      return this;
5215    }
5216
5217    /**
5218     * @return Path plus parameters after [type]. Used to set parts of the request
5219     *         URL explicitly.
5220     */
5221    public String getParams() {
5222      return this.params == null ? null : this.params.getValue();
5223    }
5224
5225    /**
5226     * @param value Path plus parameters after [type]. Used to set parts of the
5227     *              request URL explicitly.
5228     */
5229    public SetupActionOperationComponent setParams(String value) {
5230      if (Utilities.noString(value))
5231        this.params = null;
5232      else {
5233        if (this.params == null)
5234          this.params = new StringType();
5235        this.params.setValue(value);
5236      }
5237      return this;
5238    }
5239
5240    /**
5241     * @return {@link #requestHeader} (Header elements would be used to set HTTP
5242     *         headers.)
5243     */
5244    public List<SetupActionOperationRequestHeaderComponent> getRequestHeader() {
5245      if (this.requestHeader == null)
5246        this.requestHeader = new ArrayList<SetupActionOperationRequestHeaderComponent>();
5247      return this.requestHeader;
5248    }
5249
5250    /**
5251     * @return Returns a reference to <code>this</code> for easy method chaining
5252     */
5253    public SetupActionOperationComponent setRequestHeader(
5254        List<SetupActionOperationRequestHeaderComponent> theRequestHeader) {
5255      this.requestHeader = theRequestHeader;
5256      return this;
5257    }
5258
5259    public boolean hasRequestHeader() {
5260      if (this.requestHeader == null)
5261        return false;
5262      for (SetupActionOperationRequestHeaderComponent item : this.requestHeader)
5263        if (!item.isEmpty())
5264          return true;
5265      return false;
5266    }
5267
5268    public SetupActionOperationRequestHeaderComponent addRequestHeader() { // 3
5269      SetupActionOperationRequestHeaderComponent t = new SetupActionOperationRequestHeaderComponent();
5270      if (this.requestHeader == null)
5271        this.requestHeader = new ArrayList<SetupActionOperationRequestHeaderComponent>();
5272      this.requestHeader.add(t);
5273      return t;
5274    }
5275
5276    public SetupActionOperationComponent addRequestHeader(SetupActionOperationRequestHeaderComponent t) { // 3
5277      if (t == null)
5278        return this;
5279      if (this.requestHeader == null)
5280        this.requestHeader = new ArrayList<SetupActionOperationRequestHeaderComponent>();
5281      this.requestHeader.add(t);
5282      return this;
5283    }
5284
5285    /**
5286     * @return The first repetition of repeating field {@link #requestHeader},
5287     *         creating it if it does not already exist
5288     */
5289    public SetupActionOperationRequestHeaderComponent getRequestHeaderFirstRep() {
5290      if (getRequestHeader().isEmpty()) {
5291        addRequestHeader();
5292      }
5293      return getRequestHeader().get(0);
5294    }
5295
5296    /**
5297     * @return {@link #requestId} (The fixture id (maybe new) to map to the
5298     *         request.). This is the underlying object with id, value and
5299     *         extensions. The accessor "getRequestId" gives direct access to the
5300     *         value
5301     */
5302    public IdType getRequestIdElement() {
5303      if (this.requestId == null)
5304        if (Configuration.errorOnAutoCreate())
5305          throw new Error("Attempt to auto-create SetupActionOperationComponent.requestId");
5306        else if (Configuration.doAutoCreate())
5307          this.requestId = new IdType(); // bb
5308      return this.requestId;
5309    }
5310
5311    public boolean hasRequestIdElement() {
5312      return this.requestId != null && !this.requestId.isEmpty();
5313    }
5314
5315    public boolean hasRequestId() {
5316      return this.requestId != null && !this.requestId.isEmpty();
5317    }
5318
5319    /**
5320     * @param value {@link #requestId} (The fixture id (maybe new) to map to the
5321     *              request.). This is the underlying object with id, value and
5322     *              extensions. The accessor "getRequestId" gives direct access to
5323     *              the value
5324     */
5325    public SetupActionOperationComponent setRequestIdElement(IdType value) {
5326      this.requestId = value;
5327      return this;
5328    }
5329
5330    /**
5331     * @return The fixture id (maybe new) to map to the request.
5332     */
5333    public String getRequestId() {
5334      return this.requestId == null ? null : this.requestId.getValue();
5335    }
5336
5337    /**
5338     * @param value The fixture id (maybe new) to map to the request.
5339     */
5340    public SetupActionOperationComponent setRequestId(String value) {
5341      if (Utilities.noString(value))
5342        this.requestId = null;
5343      else {
5344        if (this.requestId == null)
5345          this.requestId = new IdType();
5346        this.requestId.setValue(value);
5347      }
5348      return this;
5349    }
5350
5351    /**
5352     * @return {@link #responseId} (The fixture id (maybe new) to map to the
5353     *         response.). This is the underlying object with id, value and
5354     *         extensions. The accessor "getResponseId" gives direct access to the
5355     *         value
5356     */
5357    public IdType getResponseIdElement() {
5358      if (this.responseId == null)
5359        if (Configuration.errorOnAutoCreate())
5360          throw new Error("Attempt to auto-create SetupActionOperationComponent.responseId");
5361        else if (Configuration.doAutoCreate())
5362          this.responseId = new IdType(); // bb
5363      return this.responseId;
5364    }
5365
5366    public boolean hasResponseIdElement() {
5367      return this.responseId != null && !this.responseId.isEmpty();
5368    }
5369
5370    public boolean hasResponseId() {
5371      return this.responseId != null && !this.responseId.isEmpty();
5372    }
5373
5374    /**
5375     * @param value {@link #responseId} (The fixture id (maybe new) to map to the
5376     *              response.). This is the underlying object with id, value and
5377     *              extensions. The accessor "getResponseId" gives direct access to
5378     *              the value
5379     */
5380    public SetupActionOperationComponent setResponseIdElement(IdType value) {
5381      this.responseId = value;
5382      return this;
5383    }
5384
5385    /**
5386     * @return The fixture id (maybe new) to map to the response.
5387     */
5388    public String getResponseId() {
5389      return this.responseId == null ? null : this.responseId.getValue();
5390    }
5391
5392    /**
5393     * @param value The fixture id (maybe new) to map to the response.
5394     */
5395    public SetupActionOperationComponent setResponseId(String value) {
5396      if (Utilities.noString(value))
5397        this.responseId = null;
5398      else {
5399        if (this.responseId == null)
5400          this.responseId = new IdType();
5401        this.responseId.setValue(value);
5402      }
5403      return this;
5404    }
5405
5406    /**
5407     * @return {@link #sourceId} (The id of the fixture used as the body of a PUT or
5408     *         POST request.). This is the underlying object with id, value and
5409     *         extensions. The accessor "getSourceId" gives direct access to the
5410     *         value
5411     */
5412    public IdType getSourceIdElement() {
5413      if (this.sourceId == null)
5414        if (Configuration.errorOnAutoCreate())
5415          throw new Error("Attempt to auto-create SetupActionOperationComponent.sourceId");
5416        else if (Configuration.doAutoCreate())
5417          this.sourceId = new IdType(); // bb
5418      return this.sourceId;
5419    }
5420
5421    public boolean hasSourceIdElement() {
5422      return this.sourceId != null && !this.sourceId.isEmpty();
5423    }
5424
5425    public boolean hasSourceId() {
5426      return this.sourceId != null && !this.sourceId.isEmpty();
5427    }
5428
5429    /**
5430     * @param value {@link #sourceId} (The id of the fixture used as the body of a
5431     *              PUT or POST request.). This is the underlying object with id,
5432     *              value and extensions. The accessor "getSourceId" gives direct
5433     *              access to the value
5434     */
5435    public SetupActionOperationComponent setSourceIdElement(IdType value) {
5436      this.sourceId = value;
5437      return this;
5438    }
5439
5440    /**
5441     * @return The id of the fixture used as the body of a PUT or POST request.
5442     */
5443    public String getSourceId() {
5444      return this.sourceId == null ? null : this.sourceId.getValue();
5445    }
5446
5447    /**
5448     * @param value The id of the fixture used as the body of a PUT or POST request.
5449     */
5450    public SetupActionOperationComponent setSourceId(String value) {
5451      if (Utilities.noString(value))
5452        this.sourceId = null;
5453      else {
5454        if (this.sourceId == null)
5455          this.sourceId = new IdType();
5456        this.sourceId.setValue(value);
5457      }
5458      return this;
5459    }
5460
5461    /**
5462     * @return {@link #targetId} (Id of fixture used for extracting the [id],
5463     *         [type], and [vid] for GET requests.). This is the underlying object
5464     *         with id, value and extensions. The accessor "getTargetId" gives
5465     *         direct access to the value
5466     */
5467    public IdType getTargetIdElement() {
5468      if (this.targetId == null)
5469        if (Configuration.errorOnAutoCreate())
5470          throw new Error("Attempt to auto-create SetupActionOperationComponent.targetId");
5471        else if (Configuration.doAutoCreate())
5472          this.targetId = new IdType(); // bb
5473      return this.targetId;
5474    }
5475
5476    public boolean hasTargetIdElement() {
5477      return this.targetId != null && !this.targetId.isEmpty();
5478    }
5479
5480    public boolean hasTargetId() {
5481      return this.targetId != null && !this.targetId.isEmpty();
5482    }
5483
5484    /**
5485     * @param value {@link #targetId} (Id of fixture used for extracting the [id],
5486     *              [type], and [vid] for GET requests.). This is the underlying
5487     *              object with id, value and extensions. The accessor "getTargetId"
5488     *              gives direct access to the value
5489     */
5490    public SetupActionOperationComponent setTargetIdElement(IdType value) {
5491      this.targetId = value;
5492      return this;
5493    }
5494
5495    /**
5496     * @return Id of fixture used for extracting the [id], [type], and [vid] for GET
5497     *         requests.
5498     */
5499    public String getTargetId() {
5500      return this.targetId == null ? null : this.targetId.getValue();
5501    }
5502
5503    /**
5504     * @param value Id of fixture used for extracting the [id], [type], and [vid]
5505     *              for GET requests.
5506     */
5507    public SetupActionOperationComponent setTargetId(String value) {
5508      if (Utilities.noString(value))
5509        this.targetId = null;
5510      else {
5511        if (this.targetId == null)
5512          this.targetId = new IdType();
5513        this.targetId.setValue(value);
5514      }
5515      return this;
5516    }
5517
5518    /**
5519     * @return {@link #url} (Complete request URL.). This is the underlying object
5520     *         with id, value and extensions. The accessor "getUrl" gives direct
5521     *         access to the value
5522     */
5523    public StringType getUrlElement() {
5524      if (this.url == null)
5525        if (Configuration.errorOnAutoCreate())
5526          throw new Error("Attempt to auto-create SetupActionOperationComponent.url");
5527        else if (Configuration.doAutoCreate())
5528          this.url = new StringType(); // bb
5529      return this.url;
5530    }
5531
5532    public boolean hasUrlElement() {
5533      return this.url != null && !this.url.isEmpty();
5534    }
5535
5536    public boolean hasUrl() {
5537      return this.url != null && !this.url.isEmpty();
5538    }
5539
5540    /**
5541     * @param value {@link #url} (Complete request URL.). This is the underlying
5542     *              object with id, value and extensions. The accessor "getUrl"
5543     *              gives direct access to the value
5544     */
5545    public SetupActionOperationComponent setUrlElement(StringType value) {
5546      this.url = value;
5547      return this;
5548    }
5549
5550    /**
5551     * @return Complete request URL.
5552     */
5553    public String getUrl() {
5554      return this.url == null ? null : this.url.getValue();
5555    }
5556
5557    /**
5558     * @param value Complete request URL.
5559     */
5560    public SetupActionOperationComponent setUrl(String value) {
5561      if (Utilities.noString(value))
5562        this.url = null;
5563      else {
5564        if (this.url == null)
5565          this.url = new StringType();
5566        this.url.setValue(value);
5567      }
5568      return this;
5569    }
5570
5571    protected void listChildren(List<Property> children) {
5572      super.listChildren(children);
5573      children.add(new Property("type", "Coding", "Server interaction or operation type.", 0, 1, type));
5574      children.add(new Property("resource", "code",
5575          "The type of the resource.  See http://build.fhir.org/resourcelist.html.", 0, 1, resource));
5576      children.add(new Property("label", "string",
5577          "The label would be used for tracking/logging purposes by test engines.", 0, 1, label));
5578      children.add(new Property("description", "string",
5579          "The description would be used by test engines for tracking and reporting purposes.", 0, 1, description));
5580      children.add(new Property("accept", "code", "The mime-type to use for RESTful operation in the 'Accept' header.",
5581          0, 1, accept));
5582      children.add(new Property("contentType", "code",
5583          "The mime-type to use for RESTful operation in the 'Content-Type' header.", 0, 1, contentType));
5584      children.add(new Property("destination", "integer",
5585          "The server where the request message is destined for.  Must be one of the server numbers listed in TestScript.destination section.",
5586          0, 1, destination));
5587      children.add(new Property("encodeRequestUrl", "boolean",
5588          "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.",
5589          0, 1, encodeRequestUrl));
5590      children.add(new Property("method", "code",
5591          "The HTTP method the test engine MUST use for this operation regardless of any other operation details.", 0,
5592          1, method));
5593      children.add(new Property("origin", "integer",
5594          "The server where the request message originates from.  Must be one of the server numbers listed in TestScript.origin section.",
5595          0, 1, origin));
5596      children.add(new Property("params", "string",
5597          "Path plus parameters after [type].  Used to set parts of the request URL explicitly.", 0, 1, params));
5598      children.add(new Property("requestHeader", "", "Header elements would be used to set HTTP headers.", 0,
5599          java.lang.Integer.MAX_VALUE, requestHeader));
5600      children
5601          .add(new Property("requestId", "id", "The fixture id (maybe new) to map to the request.", 0, 1, requestId));
5602      children.add(
5603          new Property("responseId", "id", "The fixture id (maybe new) to map to the response.", 0, 1, responseId));
5604      children.add(new Property("sourceId", "id", "The id of the fixture used as the body of a PUT or POST request.", 0,
5605          1, sourceId));
5606      children.add(new Property("targetId", "id",
5607          "Id of fixture used for extracting the [id],  [type], and [vid] for GET requests.", 0, 1, targetId));
5608      children.add(new Property("url", "string", "Complete request URL.", 0, 1, url));
5609    }
5610
5611    @Override
5612    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
5613      switch (_hash) {
5614      case 3575610:
5615        /* type */ return new Property("type", "Coding", "Server interaction or operation type.", 0, 1, type);
5616      case -341064690:
5617        /* resource */ return new Property("resource", "code",
5618            "The type of the resource.  See http://build.fhir.org/resourcelist.html.", 0, 1, resource);
5619      case 102727412:
5620        /* label */ return new Property("label", "string",
5621            "The label would be used for tracking/logging purposes by test engines.", 0, 1, label);
5622      case -1724546052:
5623        /* description */ return new Property("description", "string",
5624            "The description would be used by test engines for tracking and reporting purposes.", 0, 1, description);
5625      case -1423461112:
5626        /* accept */ return new Property("accept", "code",
5627            "The mime-type to use for RESTful operation in the 'Accept' header.", 0, 1, accept);
5628      case -389131437:
5629        /* contentType */ return new Property("contentType", "code",
5630            "The mime-type to use for RESTful operation in the 'Content-Type' header.", 0, 1, contentType);
5631      case -1429847026:
5632        /* destination */ return new Property("destination", "integer",
5633            "The server where the request message is destined for.  Must be one of the server numbers listed in TestScript.destination section.",
5634            0, 1, destination);
5635      case -1760554218:
5636        /* encodeRequestUrl */ return new Property("encodeRequestUrl", "boolean",
5637            "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.",
5638            0, 1, encodeRequestUrl);
5639      case -1077554975:
5640        /* method */ return new Property("method", "code",
5641            "The HTTP method the test engine MUST use for this operation regardless of any other operation details.", 0,
5642            1, method);
5643      case -1008619738:
5644        /* origin */ return new Property("origin", "integer",
5645            "The server where the request message originates from.  Must be one of the server numbers listed in TestScript.origin section.",
5646            0, 1, origin);
5647      case -995427962:
5648        /* params */ return new Property("params", "string",
5649            "Path plus parameters after [type].  Used to set parts of the request URL explicitly.", 0, 1, params);
5650      case 1074158076:
5651        /* requestHeader */ return new Property("requestHeader", "",
5652            "Header elements would be used to set HTTP headers.", 0, java.lang.Integer.MAX_VALUE, requestHeader);
5653      case 693933066:
5654        /* requestId */ return new Property("requestId", "id", "The fixture id (maybe new) to map to the request.", 0,
5655            1, requestId);
5656      case -633138884:
5657        /* responseId */ return new Property("responseId", "id", "The fixture id (maybe new) to map to the response.",
5658            0, 1, responseId);
5659      case 1746327190:
5660        /* sourceId */ return new Property("sourceId", "id",
5661            "The id of the fixture used as the body of a PUT or POST request.", 0, 1, sourceId);
5662      case -441951604:
5663        /* targetId */ return new Property("targetId", "id",
5664            "Id of fixture used for extracting the [id],  [type], and [vid] for GET requests.", 0, 1, targetId);
5665      case 116079:
5666        /* url */ return new Property("url", "string", "Complete request URL.", 0, 1, url);
5667      default:
5668        return super.getNamedProperty(_hash, _name, _checkValid);
5669      }
5670
5671    }
5672
5673    @Override
5674    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
5675      switch (hash) {
5676      case 3575610:
5677        /* type */ return this.type == null ? new Base[0] : new Base[] { this.type }; // Coding
5678      case -341064690:
5679        /* resource */ return this.resource == null ? new Base[0] : new Base[] { this.resource }; // CodeType
5680      case 102727412:
5681        /* label */ return this.label == null ? new Base[0] : new Base[] { this.label }; // StringType
5682      case -1724546052:
5683        /* description */ return this.description == null ? new Base[0] : new Base[] { this.description }; // StringType
5684      case -1423461112:
5685        /* accept */ return this.accept == null ? new Base[0] : new Base[] { this.accept }; // CodeType
5686      case -389131437:
5687        /* contentType */ return this.contentType == null ? new Base[0] : new Base[] { this.contentType }; // CodeType
5688      case -1429847026:
5689        /* destination */ return this.destination == null ? new Base[0] : new Base[] { this.destination }; // IntegerType
5690      case -1760554218:
5691        /* encodeRequestUrl */ return this.encodeRequestUrl == null ? new Base[0]
5692            : new Base[] { this.encodeRequestUrl }; // BooleanType
5693      case -1077554975:
5694        /* method */ return this.method == null ? new Base[0] : new Base[] { this.method }; // Enumeration<TestScriptRequestMethodCode>
5695      case -1008619738:
5696        /* origin */ return this.origin == null ? new Base[0] : new Base[] { this.origin }; // IntegerType
5697      case -995427962:
5698        /* params */ return this.params == null ? new Base[0] : new Base[] { this.params }; // StringType
5699      case 1074158076:
5700        /* requestHeader */ return this.requestHeader == null ? new Base[0]
5701            : this.requestHeader.toArray(new Base[this.requestHeader.size()]); // SetupActionOperationRequestHeaderComponent
5702      case 693933066:
5703        /* requestId */ return this.requestId == null ? new Base[0] : new Base[] { this.requestId }; // IdType
5704      case -633138884:
5705        /* responseId */ return this.responseId == null ? new Base[0] : new Base[] { this.responseId }; // IdType
5706      case 1746327190:
5707        /* sourceId */ return this.sourceId == null ? new Base[0] : new Base[] { this.sourceId }; // IdType
5708      case -441951604:
5709        /* targetId */ return this.targetId == null ? new Base[0] : new Base[] { this.targetId }; // IdType
5710      case 116079:
5711        /* url */ return this.url == null ? new Base[0] : new Base[] { this.url }; // StringType
5712      default:
5713        return super.getProperty(hash, name, checkValid);
5714      }
5715
5716    }
5717
5718    @Override
5719    public Base setProperty(int hash, String name, Base value) throws FHIRException {
5720      switch (hash) {
5721      case 3575610: // type
5722        this.type = castToCoding(value); // Coding
5723        return value;
5724      case -341064690: // resource
5725        this.resource = castToCode(value); // CodeType
5726        return value;
5727      case 102727412: // label
5728        this.label = castToString(value); // StringType
5729        return value;
5730      case -1724546052: // description
5731        this.description = castToString(value); // StringType
5732        return value;
5733      case -1423461112: // accept
5734        this.accept = castToCode(value); // CodeType
5735        return value;
5736      case -389131437: // contentType
5737        this.contentType = castToCode(value); // CodeType
5738        return value;
5739      case -1429847026: // destination
5740        this.destination = castToInteger(value); // IntegerType
5741        return value;
5742      case -1760554218: // encodeRequestUrl
5743        this.encodeRequestUrl = castToBoolean(value); // BooleanType
5744        return value;
5745      case -1077554975: // method
5746        value = new TestScriptRequestMethodCodeEnumFactory().fromType(castToCode(value));
5747        this.method = (Enumeration) value; // Enumeration<TestScriptRequestMethodCode>
5748        return value;
5749      case -1008619738: // origin
5750        this.origin = castToInteger(value); // IntegerType
5751        return value;
5752      case -995427962: // params
5753        this.params = castToString(value); // StringType
5754        return value;
5755      case 1074158076: // requestHeader
5756        this.getRequestHeader().add((SetupActionOperationRequestHeaderComponent) value); // SetupActionOperationRequestHeaderComponent
5757        return value;
5758      case 693933066: // requestId
5759        this.requestId = castToId(value); // IdType
5760        return value;
5761      case -633138884: // responseId
5762        this.responseId = castToId(value); // IdType
5763        return value;
5764      case 1746327190: // sourceId
5765        this.sourceId = castToId(value); // IdType
5766        return value;
5767      case -441951604: // targetId
5768        this.targetId = castToId(value); // IdType
5769        return value;
5770      case 116079: // url
5771        this.url = castToString(value); // StringType
5772        return value;
5773      default:
5774        return super.setProperty(hash, name, value);
5775      }
5776
5777    }
5778
5779    @Override
5780    public Base setProperty(String name, Base value) throws FHIRException {
5781      if (name.equals("type")) {
5782        this.type = castToCoding(value); // Coding
5783      } else if (name.equals("resource")) {
5784        this.resource = castToCode(value); // CodeType
5785      } else if (name.equals("label")) {
5786        this.label = castToString(value); // StringType
5787      } else if (name.equals("description")) {
5788        this.description = castToString(value); // StringType
5789      } else if (name.equals("accept")) {
5790        this.accept = castToCode(value); // CodeType
5791      } else if (name.equals("contentType")) {
5792        this.contentType = castToCode(value); // CodeType
5793      } else if (name.equals("destination")) {
5794        this.destination = castToInteger(value); // IntegerType
5795      } else if (name.equals("encodeRequestUrl")) {
5796        this.encodeRequestUrl = castToBoolean(value); // BooleanType
5797      } else if (name.equals("method")) {
5798        value = new TestScriptRequestMethodCodeEnumFactory().fromType(castToCode(value));
5799        this.method = (Enumeration) value; // Enumeration<TestScriptRequestMethodCode>
5800      } else if (name.equals("origin")) {
5801        this.origin = castToInteger(value); // IntegerType
5802      } else if (name.equals("params")) {
5803        this.params = castToString(value); // StringType
5804      } else if (name.equals("requestHeader")) {
5805        this.getRequestHeader().add((SetupActionOperationRequestHeaderComponent) value);
5806      } else if (name.equals("requestId")) {
5807        this.requestId = castToId(value); // IdType
5808      } else if (name.equals("responseId")) {
5809        this.responseId = castToId(value); // IdType
5810      } else if (name.equals("sourceId")) {
5811        this.sourceId = castToId(value); // IdType
5812      } else if (name.equals("targetId")) {
5813        this.targetId = castToId(value); // IdType
5814      } else if (name.equals("url")) {
5815        this.url = castToString(value); // StringType
5816      } else
5817        return super.setProperty(name, value);
5818      return value;
5819    }
5820
5821    @Override
5822    public Base makeProperty(int hash, String name) throws FHIRException {
5823      switch (hash) {
5824      case 3575610:
5825        return getType();
5826      case -341064690:
5827        return getResourceElement();
5828      case 102727412:
5829        return getLabelElement();
5830      case -1724546052:
5831        return getDescriptionElement();
5832      case -1423461112:
5833        return getAcceptElement();
5834      case -389131437:
5835        return getContentTypeElement();
5836      case -1429847026:
5837        return getDestinationElement();
5838      case -1760554218:
5839        return getEncodeRequestUrlElement();
5840      case -1077554975:
5841        return getMethodElement();
5842      case -1008619738:
5843        return getOriginElement();
5844      case -995427962:
5845        return getParamsElement();
5846      case 1074158076:
5847        return addRequestHeader();
5848      case 693933066:
5849        return getRequestIdElement();
5850      case -633138884:
5851        return getResponseIdElement();
5852      case 1746327190:
5853        return getSourceIdElement();
5854      case -441951604:
5855        return getTargetIdElement();
5856      case 116079:
5857        return getUrlElement();
5858      default:
5859        return super.makeProperty(hash, name);
5860      }
5861
5862    }
5863
5864    @Override
5865    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
5866      switch (hash) {
5867      case 3575610:
5868        /* type */ return new String[] { "Coding" };
5869      case -341064690:
5870        /* resource */ return new String[] { "code" };
5871      case 102727412:
5872        /* label */ return new String[] { "string" };
5873      case -1724546052:
5874        /* description */ return new String[] { "string" };
5875      case -1423461112:
5876        /* accept */ return new String[] { "code" };
5877      case -389131437:
5878        /* contentType */ return new String[] { "code" };
5879      case -1429847026:
5880        /* destination */ return new String[] { "integer" };
5881      case -1760554218:
5882        /* encodeRequestUrl */ return new String[] { "boolean" };
5883      case -1077554975:
5884        /* method */ return new String[] { "code" };
5885      case -1008619738:
5886        /* origin */ return new String[] { "integer" };
5887      case -995427962:
5888        /* params */ return new String[] { "string" };
5889      case 1074158076:
5890        /* requestHeader */ return new String[] {};
5891      case 693933066:
5892        /* requestId */ return new String[] { "id" };
5893      case -633138884:
5894        /* responseId */ return new String[] { "id" };
5895      case 1746327190:
5896        /* sourceId */ return new String[] { "id" };
5897      case -441951604:
5898        /* targetId */ return new String[] { "id" };
5899      case 116079:
5900        /* url */ return new String[] { "string" };
5901      default:
5902        return super.getTypesForProperty(hash, name);
5903      }
5904
5905    }
5906
5907    @Override
5908    public Base addChild(String name) throws FHIRException {
5909      if (name.equals("type")) {
5910        this.type = new Coding();
5911        return this.type;
5912      } else if (name.equals("resource")) {
5913        throw new FHIRException("Cannot call addChild on a singleton property TestScript.resource");
5914      } else if (name.equals("label")) {
5915        throw new FHIRException("Cannot call addChild on a singleton property TestScript.label");
5916      } else if (name.equals("description")) {
5917        throw new FHIRException("Cannot call addChild on a singleton property TestScript.description");
5918      } else if (name.equals("accept")) {
5919        throw new FHIRException("Cannot call addChild on a singleton property TestScript.accept");
5920      } else if (name.equals("contentType")) {
5921        throw new FHIRException("Cannot call addChild on a singleton property TestScript.contentType");
5922      } else if (name.equals("destination")) {
5923        throw new FHIRException("Cannot call addChild on a singleton property TestScript.destination");
5924      } else if (name.equals("encodeRequestUrl")) {
5925        throw new FHIRException("Cannot call addChild on a singleton property TestScript.encodeRequestUrl");
5926      } else if (name.equals("method")) {
5927        throw new FHIRException("Cannot call addChild on a singleton property TestScript.method");
5928      } else if (name.equals("origin")) {
5929        throw new FHIRException("Cannot call addChild on a singleton property TestScript.origin");
5930      } else if (name.equals("params")) {
5931        throw new FHIRException("Cannot call addChild on a singleton property TestScript.params");
5932      } else if (name.equals("requestHeader")) {
5933        return addRequestHeader();
5934      } else if (name.equals("requestId")) {
5935        throw new FHIRException("Cannot call addChild on a singleton property TestScript.requestId");
5936      } else if (name.equals("responseId")) {
5937        throw new FHIRException("Cannot call addChild on a singleton property TestScript.responseId");
5938      } else if (name.equals("sourceId")) {
5939        throw new FHIRException("Cannot call addChild on a singleton property TestScript.sourceId");
5940      } else if (name.equals("targetId")) {
5941        throw new FHIRException("Cannot call addChild on a singleton property TestScript.targetId");
5942      } else if (name.equals("url")) {
5943        throw new FHIRException("Cannot call addChild on a singleton property TestScript.url");
5944      } else
5945        return super.addChild(name);
5946    }
5947
5948    public SetupActionOperationComponent copy() {
5949      SetupActionOperationComponent dst = new SetupActionOperationComponent();
5950      copyValues(dst);
5951      return dst;
5952    }
5953
5954    public void copyValues(SetupActionOperationComponent dst) {
5955      super.copyValues(dst);
5956      dst.type = type == null ? null : type.copy();
5957      dst.resource = resource == null ? null : resource.copy();
5958      dst.label = label == null ? null : label.copy();
5959      dst.description = description == null ? null : description.copy();
5960      dst.accept = accept == null ? null : accept.copy();
5961      dst.contentType = contentType == null ? null : contentType.copy();
5962      dst.destination = destination == null ? null : destination.copy();
5963      dst.encodeRequestUrl = encodeRequestUrl == null ? null : encodeRequestUrl.copy();
5964      dst.method = method == null ? null : method.copy();
5965      dst.origin = origin == null ? null : origin.copy();
5966      dst.params = params == null ? null : params.copy();
5967      if (requestHeader != null) {
5968        dst.requestHeader = new ArrayList<SetupActionOperationRequestHeaderComponent>();
5969        for (SetupActionOperationRequestHeaderComponent i : requestHeader)
5970          dst.requestHeader.add(i.copy());
5971      }
5972      ;
5973      dst.requestId = requestId == null ? null : requestId.copy();
5974      dst.responseId = responseId == null ? null : responseId.copy();
5975      dst.sourceId = sourceId == null ? null : sourceId.copy();
5976      dst.targetId = targetId == null ? null : targetId.copy();
5977      dst.url = url == null ? null : url.copy();
5978    }
5979
5980    @Override
5981    public boolean equalsDeep(Base other_) {
5982      if (!super.equalsDeep(other_))
5983        return false;
5984      if (!(other_ instanceof SetupActionOperationComponent))
5985        return false;
5986      SetupActionOperationComponent o = (SetupActionOperationComponent) other_;
5987      return compareDeep(type, o.type, true) && compareDeep(resource, o.resource, true)
5988          && compareDeep(label, o.label, true) && compareDeep(description, o.description, true)
5989          && compareDeep(accept, o.accept, true) && compareDeep(contentType, o.contentType, true)
5990          && compareDeep(destination, o.destination, true) && compareDeep(encodeRequestUrl, o.encodeRequestUrl, true)
5991          && compareDeep(method, o.method, true) && compareDeep(origin, o.origin, true)
5992          && compareDeep(params, o.params, true) && compareDeep(requestHeader, o.requestHeader, true)
5993          && compareDeep(requestId, o.requestId, true) && compareDeep(responseId, o.responseId, true)
5994          && compareDeep(sourceId, o.sourceId, true) && compareDeep(targetId, o.targetId, true)
5995          && compareDeep(url, o.url, true);
5996    }
5997
5998    @Override
5999    public boolean equalsShallow(Base other_) {
6000      if (!super.equalsShallow(other_))
6001        return false;
6002      if (!(other_ instanceof SetupActionOperationComponent))
6003        return false;
6004      SetupActionOperationComponent o = (SetupActionOperationComponent) other_;
6005      return compareValues(resource, o.resource, true) && compareValues(label, o.label, true)
6006          && compareValues(description, o.description, true) && compareValues(accept, o.accept, true)
6007          && compareValues(contentType, o.contentType, true) && compareValues(destination, o.destination, true)
6008          && compareValues(encodeRequestUrl, o.encodeRequestUrl, true) && compareValues(method, o.method, true)
6009          && compareValues(origin, o.origin, true) && compareValues(params, o.params, true)
6010          && compareValues(requestId, o.requestId, true) && compareValues(responseId, o.responseId, true)
6011          && compareValues(sourceId, o.sourceId, true) && compareValues(targetId, o.targetId, true)
6012          && compareValues(url, o.url, true);
6013    }
6014
6015    public boolean isEmpty() {
6016      return super.isEmpty()
6017          && ca.uhn.fhir.util.ElementUtil.isEmpty(type, resource, label, description, accept, contentType, destination,
6018              encodeRequestUrl, method, origin, params, requestHeader, requestId, responseId, sourceId, targetId, url);
6019    }
6020
6021    public String fhirType() {
6022      return "TestScript.setup.action.operation";
6023
6024    }
6025
6026  }
6027
6028  @Block()
6029  public static class SetupActionOperationRequestHeaderComponent extends BackboneElement
6030      implements IBaseBackboneElement {
6031    /**
6032     * The HTTP header field e.g. "Accept".
6033     */
6034    @Child(name = "field", type = { StringType.class }, order = 1, min = 1, max = 1, modifier = false, summary = false)
6035    @Description(shortDefinition = "HTTP header field name", formalDefinition = "The HTTP header field e.g. \"Accept\".")
6036    protected StringType field;
6037
6038    /**
6039     * The value of the header e.g. "application/fhir+xml".
6040     */
6041    @Child(name = "value", type = { StringType.class }, order = 2, min = 1, max = 1, modifier = false, summary = false)
6042    @Description(shortDefinition = "HTTP headerfield value", formalDefinition = "The value of the header e.g. \"application/fhir+xml\".")
6043    protected StringType value;
6044
6045    private static final long serialVersionUID = 274395337L;
6046
6047    /**
6048     * Constructor
6049     */
6050    public SetupActionOperationRequestHeaderComponent() {
6051      super();
6052    }
6053
6054    /**
6055     * Constructor
6056     */
6057    public SetupActionOperationRequestHeaderComponent(StringType field, StringType value) {
6058      super();
6059      this.field = field;
6060      this.value = value;
6061    }
6062
6063    /**
6064     * @return {@link #field} (The HTTP header field e.g. "Accept".). This is the
6065     *         underlying object with id, value and extensions. The accessor
6066     *         "getField" gives direct access to the value
6067     */
6068    public StringType getFieldElement() {
6069      if (this.field == null)
6070        if (Configuration.errorOnAutoCreate())
6071          throw new Error("Attempt to auto-create SetupActionOperationRequestHeaderComponent.field");
6072        else if (Configuration.doAutoCreate())
6073          this.field = new StringType(); // bb
6074      return this.field;
6075    }
6076
6077    public boolean hasFieldElement() {
6078      return this.field != null && !this.field.isEmpty();
6079    }
6080
6081    public boolean hasField() {
6082      return this.field != null && !this.field.isEmpty();
6083    }
6084
6085    /**
6086     * @param value {@link #field} (The HTTP header field e.g. "Accept".). This is
6087     *              the underlying object with id, value and extensions. The
6088     *              accessor "getField" gives direct access to the value
6089     */
6090    public SetupActionOperationRequestHeaderComponent setFieldElement(StringType value) {
6091      this.field = value;
6092      return this;
6093    }
6094
6095    /**
6096     * @return The HTTP header field e.g. "Accept".
6097     */
6098    public String getField() {
6099      return this.field == null ? null : this.field.getValue();
6100    }
6101
6102    /**
6103     * @param value The HTTP header field e.g. "Accept".
6104     */
6105    public SetupActionOperationRequestHeaderComponent setField(String value) {
6106      if (this.field == null)
6107        this.field = new StringType();
6108      this.field.setValue(value);
6109      return this;
6110    }
6111
6112    /**
6113     * @return {@link #value} (The value of the header e.g.
6114     *         "application/fhir+xml".). This is the underlying object with id,
6115     *         value and extensions. The accessor "getValue" gives direct access to
6116     *         the value
6117     */
6118    public StringType getValueElement() {
6119      if (this.value == null)
6120        if (Configuration.errorOnAutoCreate())
6121          throw new Error("Attempt to auto-create SetupActionOperationRequestHeaderComponent.value");
6122        else if (Configuration.doAutoCreate())
6123          this.value = new StringType(); // bb
6124      return this.value;
6125    }
6126
6127    public boolean hasValueElement() {
6128      return this.value != null && !this.value.isEmpty();
6129    }
6130
6131    public boolean hasValue() {
6132      return this.value != null && !this.value.isEmpty();
6133    }
6134
6135    /**
6136     * @param value {@link #value} (The value of the header e.g.
6137     *              "application/fhir+xml".). This is the underlying object with id,
6138     *              value and extensions. The accessor "getValue" gives direct
6139     *              access to the value
6140     */
6141    public SetupActionOperationRequestHeaderComponent setValueElement(StringType value) {
6142      this.value = value;
6143      return this;
6144    }
6145
6146    /**
6147     * @return The value of the header e.g. "application/fhir+xml".
6148     */
6149    public String getValue() {
6150      return this.value == null ? null : this.value.getValue();
6151    }
6152
6153    /**
6154     * @param value The value of the header e.g. "application/fhir+xml".
6155     */
6156    public SetupActionOperationRequestHeaderComponent setValue(String value) {
6157      if (this.value == null)
6158        this.value = new StringType();
6159      this.value.setValue(value);
6160      return this;
6161    }
6162
6163    protected void listChildren(List<Property> children) {
6164      super.listChildren(children);
6165      children.add(new Property("field", "string", "The HTTP header field e.g. \"Accept\".", 0, 1, field));
6166      children
6167          .add(new Property("value", "string", "The value of the header e.g. \"application/fhir+xml\".", 0, 1, value));
6168    }
6169
6170    @Override
6171    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
6172      switch (_hash) {
6173      case 97427706:
6174        /* field */ return new Property("field", "string", "The HTTP header field e.g. \"Accept\".", 0, 1, field);
6175      case 111972721:
6176        /* value */ return new Property("value", "string", "The value of the header e.g. \"application/fhir+xml\".", 0,
6177            1, value);
6178      default:
6179        return super.getNamedProperty(_hash, _name, _checkValid);
6180      }
6181
6182    }
6183
6184    @Override
6185    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
6186      switch (hash) {
6187      case 97427706:
6188        /* field */ return this.field == null ? new Base[0] : new Base[] { this.field }; // StringType
6189      case 111972721:
6190        /* value */ return this.value == null ? new Base[0] : new Base[] { this.value }; // StringType
6191      default:
6192        return super.getProperty(hash, name, checkValid);
6193      }
6194
6195    }
6196
6197    @Override
6198    public Base setProperty(int hash, String name, Base value) throws FHIRException {
6199      switch (hash) {
6200      case 97427706: // field
6201        this.field = castToString(value); // StringType
6202        return value;
6203      case 111972721: // value
6204        this.value = castToString(value); // StringType
6205        return value;
6206      default:
6207        return super.setProperty(hash, name, value);
6208      }
6209
6210    }
6211
6212    @Override
6213    public Base setProperty(String name, Base value) throws FHIRException {
6214      if (name.equals("field")) {
6215        this.field = castToString(value); // StringType
6216      } else if (name.equals("value")) {
6217        this.value = castToString(value); // StringType
6218      } else
6219        return super.setProperty(name, value);
6220      return value;
6221    }
6222
6223    @Override
6224    public Base makeProperty(int hash, String name) throws FHIRException {
6225      switch (hash) {
6226      case 97427706:
6227        return getFieldElement();
6228      case 111972721:
6229        return getValueElement();
6230      default:
6231        return super.makeProperty(hash, name);
6232      }
6233
6234    }
6235
6236    @Override
6237    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
6238      switch (hash) {
6239      case 97427706:
6240        /* field */ return new String[] { "string" };
6241      case 111972721:
6242        /* value */ return new String[] { "string" };
6243      default:
6244        return super.getTypesForProperty(hash, name);
6245      }
6246
6247    }
6248
6249    @Override
6250    public Base addChild(String name) throws FHIRException {
6251      if (name.equals("field")) {
6252        throw new FHIRException("Cannot call addChild on a singleton property TestScript.field");
6253      } else if (name.equals("value")) {
6254        throw new FHIRException("Cannot call addChild on a singleton property TestScript.value");
6255      } else
6256        return super.addChild(name);
6257    }
6258
6259    public SetupActionOperationRequestHeaderComponent copy() {
6260      SetupActionOperationRequestHeaderComponent dst = new SetupActionOperationRequestHeaderComponent();
6261      copyValues(dst);
6262      return dst;
6263    }
6264
6265    public void copyValues(SetupActionOperationRequestHeaderComponent dst) {
6266      super.copyValues(dst);
6267      dst.field = field == null ? null : field.copy();
6268      dst.value = value == null ? null : value.copy();
6269    }
6270
6271    @Override
6272    public boolean equalsDeep(Base other_) {
6273      if (!super.equalsDeep(other_))
6274        return false;
6275      if (!(other_ instanceof SetupActionOperationRequestHeaderComponent))
6276        return false;
6277      SetupActionOperationRequestHeaderComponent o = (SetupActionOperationRequestHeaderComponent) other_;
6278      return compareDeep(field, o.field, true) && compareDeep(value, o.value, true);
6279    }
6280
6281    @Override
6282    public boolean equalsShallow(Base other_) {
6283      if (!super.equalsShallow(other_))
6284        return false;
6285      if (!(other_ instanceof SetupActionOperationRequestHeaderComponent))
6286        return false;
6287      SetupActionOperationRequestHeaderComponent o = (SetupActionOperationRequestHeaderComponent) other_;
6288      return compareValues(field, o.field, true) && compareValues(value, o.value, true);
6289    }
6290
6291    public boolean isEmpty() {
6292      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(field, value);
6293    }
6294
6295    public String fhirType() {
6296      return "TestScript.setup.action.operation.requestHeader";
6297
6298    }
6299
6300  }
6301
6302  @Block()
6303  public static class SetupActionAssertComponent extends BackboneElement implements IBaseBackboneElement {
6304    /**
6305     * The label would be used for tracking/logging purposes by test engines.
6306     */
6307    @Child(name = "label", type = { StringType.class }, order = 1, min = 0, max = 1, modifier = false, summary = false)
6308    @Description(shortDefinition = "Tracking/logging assertion label", formalDefinition = "The label would be used for tracking/logging purposes by test engines.")
6309    protected StringType label;
6310
6311    /**
6312     * The description would be used by test engines for tracking and reporting
6313     * purposes.
6314     */
6315    @Child(name = "description", type = {
6316        StringType.class }, order = 2, min = 0, max = 1, modifier = false, summary = false)
6317    @Description(shortDefinition = "Tracking/reporting assertion description", formalDefinition = "The description would be used by test engines for tracking and reporting purposes.")
6318    protected StringType description;
6319
6320    /**
6321     * The direction to use for the assertion.
6322     */
6323    @Child(name = "direction", type = {
6324        CodeType.class }, order = 3, min = 0, max = 1, modifier = false, summary = false)
6325    @Description(shortDefinition = "response | request", formalDefinition = "The direction to use for the assertion.")
6326    @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/assert-direction-codes")
6327    protected Enumeration<AssertionDirectionType> direction;
6328
6329    /**
6330     * Id of the source fixture used as the contents to be evaluated by either the
6331     * "source/expression" or "sourceId/path" definition.
6332     */
6333    @Child(name = "compareToSourceId", type = {
6334        StringType.class }, order = 4, min = 0, max = 1, modifier = false, summary = false)
6335    @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.")
6336    protected StringType compareToSourceId;
6337
6338    /**
6339     * The FHIRPath expression to evaluate against the source fixture. When
6340     * compareToSourceId is defined, either compareToSourceExpression or
6341     * compareToSourcePath must be defined, but not both.
6342     */
6343    @Child(name = "compareToSourceExpression", type = {
6344        StringType.class }, order = 5, min = 0, max = 1, modifier = false, summary = false)
6345    @Description(shortDefinition = "The FHIRPath expression to evaluate against the source fixture", formalDefinition = "The FHIRPath expression to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.")
6346    protected StringType compareToSourceExpression;
6347
6348    /**
6349     * XPath or JSONPath expression to evaluate against the source fixture. When
6350     * compareToSourceId is defined, either compareToSourceExpression or
6351     * compareToSourcePath must be defined, but not both.
6352     */
6353    @Child(name = "compareToSourcePath", type = {
6354        StringType.class }, order = 6, min = 0, max = 1, modifier = false, summary = false)
6355    @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.")
6356    protected StringType compareToSourcePath;
6357
6358    /**
6359     * The mime-type contents to compare against the request or response message
6360     * 'Content-Type' header.
6361     */
6362    @Child(name = "contentType", type = {
6363        CodeType.class }, order = 7, min = 0, max = 1, modifier = false, summary = false)
6364    @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.")
6365    @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/mimetypes")
6366    protected CodeType contentType;
6367
6368    /**
6369     * The FHIRPath expression to be evaluated against the request or response
6370     * message contents - HTTP headers and payload.
6371     */
6372    @Child(name = "expression", type = {
6373        StringType.class }, order = 8, min = 0, max = 1, modifier = false, summary = false)
6374    @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.")
6375    protected StringType expression;
6376
6377    /**
6378     * The HTTP header field name e.g. 'Location'.
6379     */
6380    @Child(name = "headerField", type = {
6381        StringType.class }, order = 9, min = 0, max = 1, modifier = false, summary = false)
6382    @Description(shortDefinition = "HTTP header field name", formalDefinition = "The HTTP header field name e.g. 'Location'.")
6383    protected StringType headerField;
6384
6385    /**
6386     * The ID of a fixture. Asserts that the response contains at a minimum the
6387     * fixture specified by minimumId.
6388     */
6389    @Child(name = "minimumId", type = {
6390        StringType.class }, order = 10, min = 0, max = 1, modifier = false, summary = false)
6391    @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.")
6392    protected StringType minimumId;
6393
6394    /**
6395     * Whether or not the test execution performs validation on the bundle
6396     * navigation links.
6397     */
6398    @Child(name = "navigationLinks", type = {
6399        BooleanType.class }, order = 11, min = 0, max = 1, modifier = false, summary = false)
6400    @Description(shortDefinition = "Perform validation on navigation links?", formalDefinition = "Whether or not the test execution performs validation on the bundle navigation links.")
6401    protected BooleanType navigationLinks;
6402
6403    /**
6404     * The operator type defines the conditional behavior of the assert. If not
6405     * defined, the default is equals.
6406     */
6407    @Child(name = "operator", type = {
6408        CodeType.class }, order = 12, min = 0, max = 1, modifier = false, summary = false)
6409    @Description(shortDefinition = "equals | notEquals | in | notIn | greaterThan | lessThan | empty | notEmpty | contains | notContains | eval", formalDefinition = "The operator type defines the conditional behavior of the assert. If not defined, the default is equals.")
6410    @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/assert-operator-codes")
6411    protected Enumeration<AssertionOperatorType> operator;
6412
6413    /**
6414     * The XPath or JSONPath expression to be evaluated against the fixture
6415     * representing the response received from server.
6416     */
6417    @Child(name = "path", type = { StringType.class }, order = 13, min = 0, max = 1, modifier = false, summary = false)
6418    @Description(shortDefinition = "XPath or JSONPath expression", formalDefinition = "The XPath or JSONPath expression to be evaluated against the fixture representing the response received from server.")
6419    protected StringType path;
6420
6421    /**
6422     * The request method or HTTP operation code to compare against that used by the
6423     * client system under test.
6424     */
6425    @Child(name = "requestMethod", type = {
6426        CodeType.class }, order = 14, min = 0, max = 1, modifier = false, summary = false)
6427    @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.")
6428    @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/http-operations")
6429    protected Enumeration<TestScriptRequestMethodCode> requestMethod;
6430
6431    /**
6432     * The value to use in a comparison against the request URL path string.
6433     */
6434    @Child(name = "requestURL", type = {
6435        StringType.class }, order = 15, min = 0, max = 1, modifier = false, summary = false)
6436    @Description(shortDefinition = "Request URL comparison value", formalDefinition = "The value to use in a comparison against the request URL path string.")
6437    protected StringType requestURL;
6438
6439    /**
6440     * The type of the resource. See http://build.fhir.org/resourcelist.html.
6441     */
6442    @Child(name = "resource", type = {
6443        CodeType.class }, order = 16, min = 0, max = 1, modifier = false, summary = false)
6444    @Description(shortDefinition = "Resource type", formalDefinition = "The type of the resource.  See http://build.fhir.org/resourcelist.html.")
6445    @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/defined-types")
6446    protected CodeType resource;
6447
6448    /**
6449     * okay | created | noContent | notModified | bad | forbidden | notFound |
6450     * methodNotAllowed | conflict | gone | preconditionFailed | unprocessable.
6451     */
6452    @Child(name = "response", type = {
6453        CodeType.class }, order = 17, min = 0, max = 1, modifier = false, summary = false)
6454    @Description(shortDefinition = "okay | created | noContent | notModified | bad | forbidden | notFound | methodNotAllowed | conflict | gone | preconditionFailed | unprocessable", formalDefinition = "okay | created | noContent | notModified | bad | forbidden | notFound | methodNotAllowed | conflict | gone | preconditionFailed | unprocessable.")
6455    @ca.uhn.fhir.model.api.annotation.Binding(valueSet = "http://hl7.org/fhir/ValueSet/assert-response-code-types")
6456    protected Enumeration<AssertionResponseTypes> response;
6457
6458    /**
6459     * The value of the HTTP response code to be tested.
6460     */
6461    @Child(name = "responseCode", type = {
6462        StringType.class }, order = 18, min = 0, max = 1, modifier = false, summary = false)
6463    @Description(shortDefinition = "HTTP response code to test", formalDefinition = "The value of the HTTP response code to be tested.")
6464    protected StringType responseCode;
6465
6466    /**
6467     * Fixture to evaluate the XPath/JSONPath expression or the headerField against.
6468     */
6469    @Child(name = "sourceId", type = { IdType.class }, order = 19, min = 0, max = 1, modifier = false, summary = false)
6470    @Description(shortDefinition = "Fixture Id of source expression or headerField", formalDefinition = "Fixture to evaluate the XPath/JSONPath expression or the headerField  against.")
6471    protected IdType sourceId;
6472
6473    /**
6474     * The ID of the Profile to validate against.
6475     */
6476    @Child(name = "validateProfileId", type = {
6477        IdType.class }, order = 20, min = 0, max = 1, modifier = false, summary = false)
6478    @Description(shortDefinition = "Profile Id of validation profile reference", formalDefinition = "The ID of the Profile to validate against.")
6479    protected IdType validateProfileId;
6480
6481    /**
6482     * The value to compare to.
6483     */
6484    @Child(name = "value", type = { StringType.class }, order = 21, min = 0, max = 1, modifier = false, summary = false)
6485    @Description(shortDefinition = "The value to compare to", formalDefinition = "The value to compare to.")
6486    protected StringType value;
6487
6488    /**
6489     * Whether or not the test execution will produce a warning only on error for
6490     * this assert.
6491     */
6492    @Child(name = "warningOnly", type = {
6493        BooleanType.class }, order = 22, min = 1, max = 1, modifier = false, summary = false)
6494    @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.")
6495    protected BooleanType warningOnly;
6496
6497    private static final long serialVersionUID = -1086518778L;
6498
6499    /**
6500     * Constructor
6501     */
6502    public SetupActionAssertComponent() {
6503      super();
6504    }
6505
6506    /**
6507     * Constructor
6508     */
6509    public SetupActionAssertComponent(BooleanType warningOnly) {
6510      super();
6511      this.warningOnly = warningOnly;
6512    }
6513
6514    /**
6515     * @return {@link #label} (The label would be used for tracking/logging purposes
6516     *         by test engines.). This is the underlying object with id, value and
6517     *         extensions. The accessor "getLabel" gives direct access to the value
6518     */
6519    public StringType getLabelElement() {
6520      if (this.label == null)
6521        if (Configuration.errorOnAutoCreate())
6522          throw new Error("Attempt to auto-create SetupActionAssertComponent.label");
6523        else if (Configuration.doAutoCreate())
6524          this.label = new StringType(); // bb
6525      return this.label;
6526    }
6527
6528    public boolean hasLabelElement() {
6529      return this.label != null && !this.label.isEmpty();
6530    }
6531
6532    public boolean hasLabel() {
6533      return this.label != null && !this.label.isEmpty();
6534    }
6535
6536    /**
6537     * @param value {@link #label} (The label would be used for tracking/logging
6538     *              purposes by test engines.). This is the underlying object with
6539     *              id, value and extensions. The accessor "getLabel" gives direct
6540     *              access to the value
6541     */
6542    public SetupActionAssertComponent setLabelElement(StringType value) {
6543      this.label = value;
6544      return this;
6545    }
6546
6547    /**
6548     * @return The label would be used for tracking/logging purposes by test
6549     *         engines.
6550     */
6551    public String getLabel() {
6552      return this.label == null ? null : this.label.getValue();
6553    }
6554
6555    /**
6556     * @param value The label would be used for tracking/logging purposes by test
6557     *              engines.
6558     */
6559    public SetupActionAssertComponent setLabel(String value) {
6560      if (Utilities.noString(value))
6561        this.label = null;
6562      else {
6563        if (this.label == null)
6564          this.label = new StringType();
6565        this.label.setValue(value);
6566      }
6567      return this;
6568    }
6569
6570    /**
6571     * @return {@link #description} (The description would be used by test engines
6572     *         for tracking and reporting purposes.). This is the underlying object
6573     *         with id, value and extensions. The accessor "getDescription" gives
6574     *         direct access to the value
6575     */
6576    public StringType getDescriptionElement() {
6577      if (this.description == null)
6578        if (Configuration.errorOnAutoCreate())
6579          throw new Error("Attempt to auto-create SetupActionAssertComponent.description");
6580        else if (Configuration.doAutoCreate())
6581          this.description = new StringType(); // bb
6582      return this.description;
6583    }
6584
6585    public boolean hasDescriptionElement() {
6586      return this.description != null && !this.description.isEmpty();
6587    }
6588
6589    public boolean hasDescription() {
6590      return this.description != null && !this.description.isEmpty();
6591    }
6592
6593    /**
6594     * @param value {@link #description} (The description would be used by test
6595     *              engines for tracking and reporting purposes.). This is the
6596     *              underlying object with id, value and extensions. The accessor
6597     *              "getDescription" gives direct access to the value
6598     */
6599    public SetupActionAssertComponent setDescriptionElement(StringType value) {
6600      this.description = value;
6601      return this;
6602    }
6603
6604    /**
6605     * @return The description would be used by test engines for tracking and
6606     *         reporting purposes.
6607     */
6608    public String getDescription() {
6609      return this.description == null ? null : this.description.getValue();
6610    }
6611
6612    /**
6613     * @param value The description would be used by test engines for tracking and
6614     *              reporting purposes.
6615     */
6616    public SetupActionAssertComponent setDescription(String value) {
6617      if (Utilities.noString(value))
6618        this.description = null;
6619      else {
6620        if (this.description == null)
6621          this.description = new StringType();
6622        this.description.setValue(value);
6623      }
6624      return this;
6625    }
6626
6627    /**
6628     * @return {@link #direction} (The direction to use for the assertion.). This is
6629     *         the underlying object with id, value and extensions. The accessor
6630     *         "getDirection" gives direct access to the value
6631     */
6632    public Enumeration<AssertionDirectionType> getDirectionElement() {
6633      if (this.direction == null)
6634        if (Configuration.errorOnAutoCreate())
6635          throw new Error("Attempt to auto-create SetupActionAssertComponent.direction");
6636        else if (Configuration.doAutoCreate())
6637          this.direction = new Enumeration<AssertionDirectionType>(new AssertionDirectionTypeEnumFactory()); // bb
6638      return this.direction;
6639    }
6640
6641    public boolean hasDirectionElement() {
6642      return this.direction != null && !this.direction.isEmpty();
6643    }
6644
6645    public boolean hasDirection() {
6646      return this.direction != null && !this.direction.isEmpty();
6647    }
6648
6649    /**
6650     * @param value {@link #direction} (The direction to use for the assertion.).
6651     *              This is the underlying object with id, value and extensions. The
6652     *              accessor "getDirection" gives direct access to the value
6653     */
6654    public SetupActionAssertComponent setDirectionElement(Enumeration<AssertionDirectionType> value) {
6655      this.direction = value;
6656      return this;
6657    }
6658
6659    /**
6660     * @return The direction to use for the assertion.
6661     */
6662    public AssertionDirectionType getDirection() {
6663      return this.direction == null ? null : this.direction.getValue();
6664    }
6665
6666    /**
6667     * @param value The direction to use for the assertion.
6668     */
6669    public SetupActionAssertComponent setDirection(AssertionDirectionType value) {
6670      if (value == null)
6671        this.direction = null;
6672      else {
6673        if (this.direction == null)
6674          this.direction = new Enumeration<AssertionDirectionType>(new AssertionDirectionTypeEnumFactory());
6675        this.direction.setValue(value);
6676      }
6677      return this;
6678    }
6679
6680    /**
6681     * @return {@link #compareToSourceId} (Id of the source fixture used as the
6682     *         contents to be evaluated by either the "source/expression" or
6683     *         "sourceId/path" definition.). This is the underlying object with id,
6684     *         value and extensions. The accessor "getCompareToSourceId" gives
6685     *         direct access to the value
6686     */
6687    public StringType getCompareToSourceIdElement() {
6688      if (this.compareToSourceId == null)
6689        if (Configuration.errorOnAutoCreate())
6690          throw new Error("Attempt to auto-create SetupActionAssertComponent.compareToSourceId");
6691        else if (Configuration.doAutoCreate())
6692          this.compareToSourceId = new StringType(); // bb
6693      return this.compareToSourceId;
6694    }
6695
6696    public boolean hasCompareToSourceIdElement() {
6697      return this.compareToSourceId != null && !this.compareToSourceId.isEmpty();
6698    }
6699
6700    public boolean hasCompareToSourceId() {
6701      return this.compareToSourceId != null && !this.compareToSourceId.isEmpty();
6702    }
6703
6704    /**
6705     * @param value {@link #compareToSourceId} (Id of the source fixture used as the
6706     *              contents to be evaluated by either the "source/expression" or
6707     *              "sourceId/path" definition.). This is the underlying object with
6708     *              id, value and extensions. The accessor "getCompareToSourceId"
6709     *              gives direct access to the value
6710     */
6711    public SetupActionAssertComponent setCompareToSourceIdElement(StringType value) {
6712      this.compareToSourceId = value;
6713      return this;
6714    }
6715
6716    /**
6717     * @return Id of the source fixture used as the contents to be evaluated by
6718     *         either the "source/expression" or "sourceId/path" definition.
6719     */
6720    public String getCompareToSourceId() {
6721      return this.compareToSourceId == null ? null : this.compareToSourceId.getValue();
6722    }
6723
6724    /**
6725     * @param value Id of the source fixture used as the contents to be evaluated by
6726     *              either the "source/expression" or "sourceId/path" definition.
6727     */
6728    public SetupActionAssertComponent setCompareToSourceId(String value) {
6729      if (Utilities.noString(value))
6730        this.compareToSourceId = null;
6731      else {
6732        if (this.compareToSourceId == null)
6733          this.compareToSourceId = new StringType();
6734        this.compareToSourceId.setValue(value);
6735      }
6736      return this;
6737    }
6738
6739    /**
6740     * @return {@link #compareToSourceExpression} (The FHIRPath expression to
6741     *         evaluate against the source fixture. When compareToSourceId is
6742     *         defined, either compareToSourceExpression or compareToSourcePath must
6743     *         be defined, but not both.). This is the underlying object with id,
6744     *         value and extensions. The accessor "getCompareToSourceExpression"
6745     *         gives direct access to the value
6746     */
6747    public StringType getCompareToSourceExpressionElement() {
6748      if (this.compareToSourceExpression == null)
6749        if (Configuration.errorOnAutoCreate())
6750          throw new Error("Attempt to auto-create SetupActionAssertComponent.compareToSourceExpression");
6751        else if (Configuration.doAutoCreate())
6752          this.compareToSourceExpression = new StringType(); // bb
6753      return this.compareToSourceExpression;
6754    }
6755
6756    public boolean hasCompareToSourceExpressionElement() {
6757      return this.compareToSourceExpression != null && !this.compareToSourceExpression.isEmpty();
6758    }
6759
6760    public boolean hasCompareToSourceExpression() {
6761      return this.compareToSourceExpression != null && !this.compareToSourceExpression.isEmpty();
6762    }
6763
6764    /**
6765     * @param value {@link #compareToSourceExpression} (The FHIRPath expression to
6766     *              evaluate against the source fixture. When compareToSourceId is
6767     *              defined, either compareToSourceExpression or compareToSourcePath
6768     *              must be defined, but not both.). This is the underlying object
6769     *              with id, value and extensions. The accessor
6770     *              "getCompareToSourceExpression" gives direct access to the value
6771     */
6772    public SetupActionAssertComponent setCompareToSourceExpressionElement(StringType value) {
6773      this.compareToSourceExpression = value;
6774      return this;
6775    }
6776
6777    /**
6778     * @return The FHIRPath expression to evaluate against the source fixture. When
6779     *         compareToSourceId is defined, either compareToSourceExpression or
6780     *         compareToSourcePath must be defined, but not both.
6781     */
6782    public String getCompareToSourceExpression() {
6783      return this.compareToSourceExpression == null ? null : this.compareToSourceExpression.getValue();
6784    }
6785
6786    /**
6787     * @param value The FHIRPath expression to evaluate against the source fixture.
6788     *              When compareToSourceId is defined, either
6789     *              compareToSourceExpression or compareToSourcePath must be
6790     *              defined, but not both.
6791     */
6792    public SetupActionAssertComponent setCompareToSourceExpression(String value) {
6793      if (Utilities.noString(value))
6794        this.compareToSourceExpression = null;
6795      else {
6796        if (this.compareToSourceExpression == null)
6797          this.compareToSourceExpression = new StringType();
6798        this.compareToSourceExpression.setValue(value);
6799      }
6800      return this;
6801    }
6802
6803    /**
6804     * @return {@link #compareToSourcePath} (XPath or JSONPath expression to
6805     *         evaluate against the source fixture. When compareToSourceId is
6806     *         defined, either compareToSourceExpression or compareToSourcePath must
6807     *         be defined, but not both.). This is the underlying object with id,
6808     *         value and extensions. The accessor "getCompareToSourcePath" gives
6809     *         direct access to the value
6810     */
6811    public StringType getCompareToSourcePathElement() {
6812      if (this.compareToSourcePath == null)
6813        if (Configuration.errorOnAutoCreate())
6814          throw new Error("Attempt to auto-create SetupActionAssertComponent.compareToSourcePath");
6815        else if (Configuration.doAutoCreate())
6816          this.compareToSourcePath = new StringType(); // bb
6817      return this.compareToSourcePath;
6818    }
6819
6820    public boolean hasCompareToSourcePathElement() {
6821      return this.compareToSourcePath != null && !this.compareToSourcePath.isEmpty();
6822    }
6823
6824    public boolean hasCompareToSourcePath() {
6825      return this.compareToSourcePath != null && !this.compareToSourcePath.isEmpty();
6826    }
6827
6828    /**
6829     * @param value {@link #compareToSourcePath} (XPath or JSONPath expression to
6830     *              evaluate against the source fixture. When compareToSourceId is
6831     *              defined, either compareToSourceExpression or compareToSourcePath
6832     *              must be defined, but not both.). This is the underlying object
6833     *              with id, value and extensions. The accessor
6834     *              "getCompareToSourcePath" gives direct access to the value
6835     */
6836    public SetupActionAssertComponent setCompareToSourcePathElement(StringType value) {
6837      this.compareToSourcePath = value;
6838      return this;
6839    }
6840
6841    /**
6842     * @return XPath or JSONPath expression to evaluate against the source fixture.
6843     *         When compareToSourceId is defined, either compareToSourceExpression
6844     *         or compareToSourcePath must be defined, but not both.
6845     */
6846    public String getCompareToSourcePath() {
6847      return this.compareToSourcePath == null ? null : this.compareToSourcePath.getValue();
6848    }
6849
6850    /**
6851     * @param value XPath or JSONPath expression to evaluate against the source
6852     *              fixture. When compareToSourceId is defined, either
6853     *              compareToSourceExpression or compareToSourcePath must be
6854     *              defined, but not both.
6855     */
6856    public SetupActionAssertComponent setCompareToSourcePath(String value) {
6857      if (Utilities.noString(value))
6858        this.compareToSourcePath = null;
6859      else {
6860        if (this.compareToSourcePath == null)
6861          this.compareToSourcePath = new StringType();
6862        this.compareToSourcePath.setValue(value);
6863      }
6864      return this;
6865    }
6866
6867    /**
6868     * @return {@link #contentType} (The mime-type contents to compare against the
6869     *         request or response message 'Content-Type' header.). This is the
6870     *         underlying object with id, value and extensions. The accessor
6871     *         "getContentType" gives direct access to the value
6872     */
6873    public CodeType getContentTypeElement() {
6874      if (this.contentType == null)
6875        if (Configuration.errorOnAutoCreate())
6876          throw new Error("Attempt to auto-create SetupActionAssertComponent.contentType");
6877        else if (Configuration.doAutoCreate())
6878          this.contentType = new CodeType(); // bb
6879      return this.contentType;
6880    }
6881
6882    public boolean hasContentTypeElement() {
6883      return this.contentType != null && !this.contentType.isEmpty();
6884    }
6885
6886    public boolean hasContentType() {
6887      return this.contentType != null && !this.contentType.isEmpty();
6888    }
6889
6890    /**
6891     * @param value {@link #contentType} (The mime-type contents to compare against
6892     *              the request or response message 'Content-Type' header.). This is
6893     *              the underlying object with id, value and extensions. The
6894     *              accessor "getContentType" gives direct access to the value
6895     */
6896    public SetupActionAssertComponent setContentTypeElement(CodeType value) {
6897      this.contentType = value;
6898      return this;
6899    }
6900
6901    /**
6902     * @return The mime-type contents to compare against the request or response
6903     *         message 'Content-Type' header.
6904     */
6905    public String getContentType() {
6906      return this.contentType == null ? null : this.contentType.getValue();
6907    }
6908
6909    /**
6910     * @param value The mime-type contents to compare against the request or
6911     *              response message 'Content-Type' header.
6912     */
6913    public SetupActionAssertComponent setContentType(String value) {
6914      if (Utilities.noString(value))
6915        this.contentType = null;
6916      else {
6917        if (this.contentType == null)
6918          this.contentType = new CodeType();
6919        this.contentType.setValue(value);
6920      }
6921      return this;
6922    }
6923
6924    /**
6925     * @return {@link #expression} (The FHIRPath expression to be evaluated against
6926     *         the request or response message contents - HTTP headers and
6927     *         payload.). This is the underlying object with id, value and
6928     *         extensions. The accessor "getExpression" gives direct access to the
6929     *         value
6930     */
6931    public StringType getExpressionElement() {
6932      if (this.expression == null)
6933        if (Configuration.errorOnAutoCreate())
6934          throw new Error("Attempt to auto-create SetupActionAssertComponent.expression");
6935        else if (Configuration.doAutoCreate())
6936          this.expression = new StringType(); // bb
6937      return this.expression;
6938    }
6939
6940    public boolean hasExpressionElement() {
6941      return this.expression != null && !this.expression.isEmpty();
6942    }
6943
6944    public boolean hasExpression() {
6945      return this.expression != null && !this.expression.isEmpty();
6946    }
6947
6948    /**
6949     * @param value {@link #expression} (The FHIRPath expression to be evaluated
6950     *              against the request or response message contents - HTTP headers
6951     *              and payload.). This is the underlying object with id, value and
6952     *              extensions. The accessor "getExpression" gives direct access to
6953     *              the value
6954     */
6955    public SetupActionAssertComponent setExpressionElement(StringType value) {
6956      this.expression = value;
6957      return this;
6958    }
6959
6960    /**
6961     * @return The FHIRPath expression to be evaluated against the request or
6962     *         response message contents - HTTP headers and payload.
6963     */
6964    public String getExpression() {
6965      return this.expression == null ? null : this.expression.getValue();
6966    }
6967
6968    /**
6969     * @param value The FHIRPath expression to be evaluated against the request or
6970     *              response message contents - HTTP headers and payload.
6971     */
6972    public SetupActionAssertComponent setExpression(String value) {
6973      if (Utilities.noString(value))
6974        this.expression = null;
6975      else {
6976        if (this.expression == null)
6977          this.expression = new StringType();
6978        this.expression.setValue(value);
6979      }
6980      return this;
6981    }
6982
6983    /**
6984     * @return {@link #headerField} (The HTTP header field name e.g. 'Location'.).
6985     *         This is the underlying object with id, value and extensions. The
6986     *         accessor "getHeaderField" gives direct access to the value
6987     */
6988    public StringType getHeaderFieldElement() {
6989      if (this.headerField == null)
6990        if (Configuration.errorOnAutoCreate())
6991          throw new Error("Attempt to auto-create SetupActionAssertComponent.headerField");
6992        else if (Configuration.doAutoCreate())
6993          this.headerField = new StringType(); // bb
6994      return this.headerField;
6995    }
6996
6997    public boolean hasHeaderFieldElement() {
6998      return this.headerField != null && !this.headerField.isEmpty();
6999    }
7000
7001    public boolean hasHeaderField() {
7002      return this.headerField != null && !this.headerField.isEmpty();
7003    }
7004
7005    /**
7006     * @param value {@link #headerField} (The HTTP header field name e.g.
7007     *              'Location'.). This is the underlying object with id, value and
7008     *              extensions. The accessor "getHeaderField" gives direct access to
7009     *              the value
7010     */
7011    public SetupActionAssertComponent setHeaderFieldElement(StringType value) {
7012      this.headerField = value;
7013      return this;
7014    }
7015
7016    /**
7017     * @return The HTTP header field name e.g. 'Location'.
7018     */
7019    public String getHeaderField() {
7020      return this.headerField == null ? null : this.headerField.getValue();
7021    }
7022
7023    /**
7024     * @param value The HTTP header field name e.g. 'Location'.
7025     */
7026    public SetupActionAssertComponent setHeaderField(String value) {
7027      if (Utilities.noString(value))
7028        this.headerField = null;
7029      else {
7030        if (this.headerField == null)
7031          this.headerField = new StringType();
7032        this.headerField.setValue(value);
7033      }
7034      return this;
7035    }
7036
7037    /**
7038     * @return {@link #minimumId} (The ID of a fixture. Asserts that the response
7039     *         contains at a minimum the fixture specified by minimumId.). This is
7040     *         the underlying object with id, value and extensions. The accessor
7041     *         "getMinimumId" gives direct access to the value
7042     */
7043    public StringType getMinimumIdElement() {
7044      if (this.minimumId == null)
7045        if (Configuration.errorOnAutoCreate())
7046          throw new Error("Attempt to auto-create SetupActionAssertComponent.minimumId");
7047        else if (Configuration.doAutoCreate())
7048          this.minimumId = new StringType(); // bb
7049      return this.minimumId;
7050    }
7051
7052    public boolean hasMinimumIdElement() {
7053      return this.minimumId != null && !this.minimumId.isEmpty();
7054    }
7055
7056    public boolean hasMinimumId() {
7057      return this.minimumId != null && !this.minimumId.isEmpty();
7058    }
7059
7060    /**
7061     * @param value {@link #minimumId} (The ID of a fixture. Asserts that the
7062     *              response contains at a minimum the fixture specified by
7063     *              minimumId.). This is the underlying object with id, value and
7064     *              extensions. The accessor "getMinimumId" gives direct access to
7065     *              the value
7066     */
7067    public SetupActionAssertComponent setMinimumIdElement(StringType value) {
7068      this.minimumId = value;
7069      return this;
7070    }
7071
7072    /**
7073     * @return The ID of a fixture. Asserts that the response contains at a minimum
7074     *         the fixture specified by minimumId.
7075     */
7076    public String getMinimumId() {
7077      return this.minimumId == null ? null : this.minimumId.getValue();
7078    }
7079
7080    /**
7081     * @param value The ID of a fixture. Asserts that the response contains at a
7082     *              minimum the fixture specified by minimumId.
7083     */
7084    public SetupActionAssertComponent setMinimumId(String value) {
7085      if (Utilities.noString(value))
7086        this.minimumId = null;
7087      else {
7088        if (this.minimumId == null)
7089          this.minimumId = new StringType();
7090        this.minimumId.setValue(value);
7091      }
7092      return this;
7093    }
7094
7095    /**
7096     * @return {@link #navigationLinks} (Whether or not the test execution performs
7097     *         validation on the bundle navigation links.). This is the underlying
7098     *         object with id, value and extensions. The accessor
7099     *         "getNavigationLinks" gives direct access to the value
7100     */
7101    public BooleanType getNavigationLinksElement() {
7102      if (this.navigationLinks == null)
7103        if (Configuration.errorOnAutoCreate())
7104          throw new Error("Attempt to auto-create SetupActionAssertComponent.navigationLinks");
7105        else if (Configuration.doAutoCreate())
7106          this.navigationLinks = new BooleanType(); // bb
7107      return this.navigationLinks;
7108    }
7109
7110    public boolean hasNavigationLinksElement() {
7111      return this.navigationLinks != null && !this.navigationLinks.isEmpty();
7112    }
7113
7114    public boolean hasNavigationLinks() {
7115      return this.navigationLinks != null && !this.navigationLinks.isEmpty();
7116    }
7117
7118    /**
7119     * @param value {@link #navigationLinks} (Whether or not the test execution
7120     *              performs validation on the bundle navigation links.). This is
7121     *              the underlying object with id, value and extensions. The
7122     *              accessor "getNavigationLinks" gives direct access to the value
7123     */
7124    public SetupActionAssertComponent setNavigationLinksElement(BooleanType value) {
7125      this.navigationLinks = value;
7126      return this;
7127    }
7128
7129    /**
7130     * @return Whether or not the test execution performs validation on the bundle
7131     *         navigation links.
7132     */
7133    public boolean getNavigationLinks() {
7134      return this.navigationLinks == null || this.navigationLinks.isEmpty() ? false : this.navigationLinks.getValue();
7135    }
7136
7137    /**
7138     * @param value Whether or not the test execution performs validation on the
7139     *              bundle navigation links.
7140     */
7141    public SetupActionAssertComponent setNavigationLinks(boolean value) {
7142      if (this.navigationLinks == null)
7143        this.navigationLinks = new BooleanType();
7144      this.navigationLinks.setValue(value);
7145      return this;
7146    }
7147
7148    /**
7149     * @return {@link #operator} (The operator type defines the conditional behavior
7150     *         of the assert. If not defined, the default is equals.). This is the
7151     *         underlying object with id, value and extensions. The accessor
7152     *         "getOperator" gives direct access to the value
7153     */
7154    public Enumeration<AssertionOperatorType> getOperatorElement() {
7155      if (this.operator == null)
7156        if (Configuration.errorOnAutoCreate())
7157          throw new Error("Attempt to auto-create SetupActionAssertComponent.operator");
7158        else if (Configuration.doAutoCreate())
7159          this.operator = new Enumeration<AssertionOperatorType>(new AssertionOperatorTypeEnumFactory()); // bb
7160      return this.operator;
7161    }
7162
7163    public boolean hasOperatorElement() {
7164      return this.operator != null && !this.operator.isEmpty();
7165    }
7166
7167    public boolean hasOperator() {
7168      return this.operator != null && !this.operator.isEmpty();
7169    }
7170
7171    /**
7172     * @param value {@link #operator} (The operator type defines the conditional
7173     *              behavior of the assert. If not defined, the default is equals.).
7174     *              This is the underlying object with id, value and extensions. The
7175     *              accessor "getOperator" gives direct access to the value
7176     */
7177    public SetupActionAssertComponent setOperatorElement(Enumeration<AssertionOperatorType> value) {
7178      this.operator = value;
7179      return this;
7180    }
7181
7182    /**
7183     * @return The operator type defines the conditional behavior of the assert. If
7184     *         not defined, the default is equals.
7185     */
7186    public AssertionOperatorType getOperator() {
7187      return this.operator == null ? null : this.operator.getValue();
7188    }
7189
7190    /**
7191     * @param value The operator type defines the conditional behavior of the
7192     *              assert. If not defined, the default is equals.
7193     */
7194    public SetupActionAssertComponent setOperator(AssertionOperatorType value) {
7195      if (value == null)
7196        this.operator = null;
7197      else {
7198        if (this.operator == null)
7199          this.operator = new Enumeration<AssertionOperatorType>(new AssertionOperatorTypeEnumFactory());
7200        this.operator.setValue(value);
7201      }
7202      return this;
7203    }
7204
7205    /**
7206     * @return {@link #path} (The XPath or JSONPath expression to be evaluated
7207     *         against the fixture representing the response received from server.).
7208     *         This is the underlying object with id, value and extensions. The
7209     *         accessor "getPath" gives direct access to the value
7210     */
7211    public StringType getPathElement() {
7212      if (this.path == null)
7213        if (Configuration.errorOnAutoCreate())
7214          throw new Error("Attempt to auto-create SetupActionAssertComponent.path");
7215        else if (Configuration.doAutoCreate())
7216          this.path = new StringType(); // bb
7217      return this.path;
7218    }
7219
7220    public boolean hasPathElement() {
7221      return this.path != null && !this.path.isEmpty();
7222    }
7223
7224    public boolean hasPath() {
7225      return this.path != null && !this.path.isEmpty();
7226    }
7227
7228    /**
7229     * @param value {@link #path} (The XPath or JSONPath expression to be evaluated
7230     *              against the fixture representing the response received from
7231     *              server.). This is the underlying object with id, value and
7232     *              extensions. The accessor "getPath" gives direct access to the
7233     *              value
7234     */
7235    public SetupActionAssertComponent setPathElement(StringType value) {
7236      this.path = value;
7237      return this;
7238    }
7239
7240    /**
7241     * @return The XPath or JSONPath expression to be evaluated against the fixture
7242     *         representing the response received from server.
7243     */
7244    public String getPath() {
7245      return this.path == null ? null : this.path.getValue();
7246    }
7247
7248    /**
7249     * @param value The XPath or JSONPath expression to be evaluated against the
7250     *              fixture representing the response received from server.
7251     */
7252    public SetupActionAssertComponent setPath(String value) {
7253      if (Utilities.noString(value))
7254        this.path = null;
7255      else {
7256        if (this.path == null)
7257          this.path = new StringType();
7258        this.path.setValue(value);
7259      }
7260      return this;
7261    }
7262
7263    /**
7264     * @return {@link #requestMethod} (The request method or HTTP operation code to
7265     *         compare against that used by the client system under test.). This is
7266     *         the underlying object with id, value and extensions. The accessor
7267     *         "getRequestMethod" gives direct access to the value
7268     */
7269    public Enumeration<TestScriptRequestMethodCode> getRequestMethodElement() {
7270      if (this.requestMethod == null)
7271        if (Configuration.errorOnAutoCreate())
7272          throw new Error("Attempt to auto-create SetupActionAssertComponent.requestMethod");
7273        else if (Configuration.doAutoCreate())
7274          this.requestMethod = new Enumeration<TestScriptRequestMethodCode>(
7275              new TestScriptRequestMethodCodeEnumFactory()); // bb
7276      return this.requestMethod;
7277    }
7278
7279    public boolean hasRequestMethodElement() {
7280      return this.requestMethod != null && !this.requestMethod.isEmpty();
7281    }
7282
7283    public boolean hasRequestMethod() {
7284      return this.requestMethod != null && !this.requestMethod.isEmpty();
7285    }
7286
7287    /**
7288     * @param value {@link #requestMethod} (The request method or HTTP operation
7289     *              code to compare against that used by the client system under
7290     *              test.). This is the underlying object with id, value and
7291     *              extensions. The accessor "getRequestMethod" gives direct access
7292     *              to the value
7293     */
7294    public SetupActionAssertComponent setRequestMethodElement(Enumeration<TestScriptRequestMethodCode> value) {
7295      this.requestMethod = value;
7296      return this;
7297    }
7298
7299    /**
7300     * @return The request method or HTTP operation code to compare against that
7301     *         used by the client system under test.
7302     */
7303    public TestScriptRequestMethodCode getRequestMethod() {
7304      return this.requestMethod == null ? null : this.requestMethod.getValue();
7305    }
7306
7307    /**
7308     * @param value The request method or HTTP operation code to compare against
7309     *              that used by the client system under test.
7310     */
7311    public SetupActionAssertComponent setRequestMethod(TestScriptRequestMethodCode value) {
7312      if (value == null)
7313        this.requestMethod = null;
7314      else {
7315        if (this.requestMethod == null)
7316          this.requestMethod = new Enumeration<TestScriptRequestMethodCode>(
7317              new TestScriptRequestMethodCodeEnumFactory());
7318        this.requestMethod.setValue(value);
7319      }
7320      return this;
7321    }
7322
7323    /**
7324     * @return {@link #requestURL} (The value to use in a comparison against the
7325     *         request URL path string.). This is the underlying object with id,
7326     *         value and extensions. The accessor "getRequestURL" gives direct
7327     *         access to the value
7328     */
7329    public StringType getRequestURLElement() {
7330      if (this.requestURL == null)
7331        if (Configuration.errorOnAutoCreate())
7332          throw new Error("Attempt to auto-create SetupActionAssertComponent.requestURL");
7333        else if (Configuration.doAutoCreate())
7334          this.requestURL = new StringType(); // bb
7335      return this.requestURL;
7336    }
7337
7338    public boolean hasRequestURLElement() {
7339      return this.requestURL != null && !this.requestURL.isEmpty();
7340    }
7341
7342    public boolean hasRequestURL() {
7343      return this.requestURL != null && !this.requestURL.isEmpty();
7344    }
7345
7346    /**
7347     * @param value {@link #requestURL} (The value to use in a comparison against
7348     *              the request URL path string.). This is the underlying object
7349     *              with id, value and extensions. The accessor "getRequestURL"
7350     *              gives direct access to the value
7351     */
7352    public SetupActionAssertComponent setRequestURLElement(StringType value) {
7353      this.requestURL = value;
7354      return this;
7355    }
7356
7357    /**
7358     * @return The value to use in a comparison against the request URL path string.
7359     */
7360    public String getRequestURL() {
7361      return this.requestURL == null ? null : this.requestURL.getValue();
7362    }
7363
7364    /**
7365     * @param value The value to use in a comparison against the request URL path
7366     *              string.
7367     */
7368    public SetupActionAssertComponent setRequestURL(String value) {
7369      if (Utilities.noString(value))
7370        this.requestURL = null;
7371      else {
7372        if (this.requestURL == null)
7373          this.requestURL = new StringType();
7374        this.requestURL.setValue(value);
7375      }
7376      return this;
7377    }
7378
7379    /**
7380     * @return {@link #resource} (The type of the resource. See
7381     *         http://build.fhir.org/resourcelist.html.). This is the underlying
7382     *         object with id, value and extensions. The accessor "getResource"
7383     *         gives direct access to the value
7384     */
7385    public CodeType getResourceElement() {
7386      if (this.resource == null)
7387        if (Configuration.errorOnAutoCreate())
7388          throw new Error("Attempt to auto-create SetupActionAssertComponent.resource");
7389        else if (Configuration.doAutoCreate())
7390          this.resource = new CodeType(); // bb
7391      return this.resource;
7392    }
7393
7394    public boolean hasResourceElement() {
7395      return this.resource != null && !this.resource.isEmpty();
7396    }
7397
7398    public boolean hasResource() {
7399      return this.resource != null && !this.resource.isEmpty();
7400    }
7401
7402    /**
7403     * @param value {@link #resource} (The type of the resource. See
7404     *              http://build.fhir.org/resourcelist.html.). This is the
7405     *              underlying object with id, value and extensions. The accessor
7406     *              "getResource" gives direct access to the value
7407     */
7408    public SetupActionAssertComponent setResourceElement(CodeType value) {
7409      this.resource = value;
7410      return this;
7411    }
7412
7413    /**
7414     * @return The type of the resource. See
7415     *         http://build.fhir.org/resourcelist.html.
7416     */
7417    public String getResource() {
7418      return this.resource == null ? null : this.resource.getValue();
7419    }
7420
7421    /**
7422     * @param value The type of the resource. See
7423     *              http://build.fhir.org/resourcelist.html.
7424     */
7425    public SetupActionAssertComponent setResource(String value) {
7426      if (Utilities.noString(value))
7427        this.resource = null;
7428      else {
7429        if (this.resource == null)
7430          this.resource = new CodeType();
7431        this.resource.setValue(value);
7432      }
7433      return this;
7434    }
7435
7436    /**
7437     * @return {@link #response} (okay | created | noContent | notModified | bad |
7438     *         forbidden | notFound | methodNotAllowed | conflict | gone |
7439     *         preconditionFailed | unprocessable.). This is the underlying object
7440     *         with id, value and extensions. The accessor "getResponse" gives
7441     *         direct access to the value
7442     */
7443    public Enumeration<AssertionResponseTypes> getResponseElement() {
7444      if (this.response == null)
7445        if (Configuration.errorOnAutoCreate())
7446          throw new Error("Attempt to auto-create SetupActionAssertComponent.response");
7447        else if (Configuration.doAutoCreate())
7448          this.response = new Enumeration<AssertionResponseTypes>(new AssertionResponseTypesEnumFactory()); // bb
7449      return this.response;
7450    }
7451
7452    public boolean hasResponseElement() {
7453      return this.response != null && !this.response.isEmpty();
7454    }
7455
7456    public boolean hasResponse() {
7457      return this.response != null && !this.response.isEmpty();
7458    }
7459
7460    /**
7461     * @param value {@link #response} (okay | created | noContent | notModified |
7462     *              bad | forbidden | notFound | methodNotAllowed | conflict | gone
7463     *              | preconditionFailed | unprocessable.). This is the underlying
7464     *              object with id, value and extensions. The accessor "getResponse"
7465     *              gives direct access to the value
7466     */
7467    public SetupActionAssertComponent setResponseElement(Enumeration<AssertionResponseTypes> value) {
7468      this.response = value;
7469      return this;
7470    }
7471
7472    /**
7473     * @return okay | created | noContent | notModified | bad | forbidden | notFound
7474     *         | methodNotAllowed | conflict | gone | preconditionFailed |
7475     *         unprocessable.
7476     */
7477    public AssertionResponseTypes getResponse() {
7478      return this.response == null ? null : this.response.getValue();
7479    }
7480
7481    /**
7482     * @param value okay | created | noContent | notModified | bad | forbidden |
7483     *              notFound | methodNotAllowed | conflict | gone |
7484     *              preconditionFailed | unprocessable.
7485     */
7486    public SetupActionAssertComponent setResponse(AssertionResponseTypes value) {
7487      if (value == null)
7488        this.response = null;
7489      else {
7490        if (this.response == null)
7491          this.response = new Enumeration<AssertionResponseTypes>(new AssertionResponseTypesEnumFactory());
7492        this.response.setValue(value);
7493      }
7494      return this;
7495    }
7496
7497    /**
7498     * @return {@link #responseCode} (The value of the HTTP response code to be
7499     *         tested.). This is the underlying object with id, value and
7500     *         extensions. The accessor "getResponseCode" gives direct access to the
7501     *         value
7502     */
7503    public StringType getResponseCodeElement() {
7504      if (this.responseCode == null)
7505        if (Configuration.errorOnAutoCreate())
7506          throw new Error("Attempt to auto-create SetupActionAssertComponent.responseCode");
7507        else if (Configuration.doAutoCreate())
7508          this.responseCode = new StringType(); // bb
7509      return this.responseCode;
7510    }
7511
7512    public boolean hasResponseCodeElement() {
7513      return this.responseCode != null && !this.responseCode.isEmpty();
7514    }
7515
7516    public boolean hasResponseCode() {
7517      return this.responseCode != null && !this.responseCode.isEmpty();
7518    }
7519
7520    /**
7521     * @param value {@link #responseCode} (The value of the HTTP response code to be
7522     *              tested.). This is the underlying object with id, value and
7523     *              extensions. The accessor "getResponseCode" gives direct access
7524     *              to the value
7525     */
7526    public SetupActionAssertComponent setResponseCodeElement(StringType value) {
7527      this.responseCode = value;
7528      return this;
7529    }
7530
7531    /**
7532     * @return The value of the HTTP response code to be tested.
7533     */
7534    public String getResponseCode() {
7535      return this.responseCode == null ? null : this.responseCode.getValue();
7536    }
7537
7538    /**
7539     * @param value The value of the HTTP response code to be tested.
7540     */
7541    public SetupActionAssertComponent setResponseCode(String value) {
7542      if (Utilities.noString(value))
7543        this.responseCode = null;
7544      else {
7545        if (this.responseCode == null)
7546          this.responseCode = new StringType();
7547        this.responseCode.setValue(value);
7548      }
7549      return this;
7550    }
7551
7552    /**
7553     * @return {@link #sourceId} (Fixture to evaluate the XPath/JSONPath expression
7554     *         or the headerField against.). This is the underlying object with id,
7555     *         value and extensions. The accessor "getSourceId" gives direct access
7556     *         to the value
7557     */
7558    public IdType getSourceIdElement() {
7559      if (this.sourceId == null)
7560        if (Configuration.errorOnAutoCreate())
7561          throw new Error("Attempt to auto-create SetupActionAssertComponent.sourceId");
7562        else if (Configuration.doAutoCreate())
7563          this.sourceId = new IdType(); // bb
7564      return this.sourceId;
7565    }
7566
7567    public boolean hasSourceIdElement() {
7568      return this.sourceId != null && !this.sourceId.isEmpty();
7569    }
7570
7571    public boolean hasSourceId() {
7572      return this.sourceId != null && !this.sourceId.isEmpty();
7573    }
7574
7575    /**
7576     * @param value {@link #sourceId} (Fixture to evaluate the XPath/JSONPath
7577     *              expression or the headerField against.). This is the underlying
7578     *              object with id, value and extensions. The accessor "getSourceId"
7579     *              gives direct access to the value
7580     */
7581    public SetupActionAssertComponent setSourceIdElement(IdType value) {
7582      this.sourceId = value;
7583      return this;
7584    }
7585
7586    /**
7587     * @return Fixture to evaluate the XPath/JSONPath expression or the headerField
7588     *         against.
7589     */
7590    public String getSourceId() {
7591      return this.sourceId == null ? null : this.sourceId.getValue();
7592    }
7593
7594    /**
7595     * @param value Fixture to evaluate the XPath/JSONPath expression or the
7596     *              headerField against.
7597     */
7598    public SetupActionAssertComponent setSourceId(String value) {
7599      if (Utilities.noString(value))
7600        this.sourceId = null;
7601      else {
7602        if (this.sourceId == null)
7603          this.sourceId = new IdType();
7604        this.sourceId.setValue(value);
7605      }
7606      return this;
7607    }
7608
7609    /**
7610     * @return {@link #validateProfileId} (The ID of the Profile to validate
7611     *         against.). This is the underlying object with id, value and
7612     *         extensions. The accessor "getValidateProfileId" gives direct access
7613     *         to the value
7614     */
7615    public IdType getValidateProfileIdElement() {
7616      if (this.validateProfileId == null)
7617        if (Configuration.errorOnAutoCreate())
7618          throw new Error("Attempt to auto-create SetupActionAssertComponent.validateProfileId");
7619        else if (Configuration.doAutoCreate())
7620          this.validateProfileId = new IdType(); // bb
7621      return this.validateProfileId;
7622    }
7623
7624    public boolean hasValidateProfileIdElement() {
7625      return this.validateProfileId != null && !this.validateProfileId.isEmpty();
7626    }
7627
7628    public boolean hasValidateProfileId() {
7629      return this.validateProfileId != null && !this.validateProfileId.isEmpty();
7630    }
7631
7632    /**
7633     * @param value {@link #validateProfileId} (The ID of the Profile to validate
7634     *              against.). This is the underlying object with id, value and
7635     *              extensions. The accessor "getValidateProfileId" gives direct
7636     *              access to the value
7637     */
7638    public SetupActionAssertComponent setValidateProfileIdElement(IdType value) {
7639      this.validateProfileId = value;
7640      return this;
7641    }
7642
7643    /**
7644     * @return The ID of the Profile to validate against.
7645     */
7646    public String getValidateProfileId() {
7647      return this.validateProfileId == null ? null : this.validateProfileId.getValue();
7648    }
7649
7650    /**
7651     * @param value The ID of the Profile to validate against.
7652     */
7653    public SetupActionAssertComponent setValidateProfileId(String value) {
7654      if (Utilities.noString(value))
7655        this.validateProfileId = null;
7656      else {
7657        if (this.validateProfileId == null)
7658          this.validateProfileId = new IdType();
7659        this.validateProfileId.setValue(value);
7660      }
7661      return this;
7662    }
7663
7664    /**
7665     * @return {@link #value} (The value to compare to.). This is the underlying
7666     *         object with id, value and extensions. The accessor "getValue" gives
7667     *         direct access to the value
7668     */
7669    public StringType getValueElement() {
7670      if (this.value == null)
7671        if (Configuration.errorOnAutoCreate())
7672          throw new Error("Attempt to auto-create SetupActionAssertComponent.value");
7673        else if (Configuration.doAutoCreate())
7674          this.value = new StringType(); // bb
7675      return this.value;
7676    }
7677
7678    public boolean hasValueElement() {
7679      return this.value != null && !this.value.isEmpty();
7680    }
7681
7682    public boolean hasValue() {
7683      return this.value != null && !this.value.isEmpty();
7684    }
7685
7686    /**
7687     * @param value {@link #value} (The value to compare to.). This is the
7688     *              underlying object with id, value and extensions. The accessor
7689     *              "getValue" gives direct access to the value
7690     */
7691    public SetupActionAssertComponent setValueElement(StringType value) {
7692      this.value = value;
7693      return this;
7694    }
7695
7696    /**
7697     * @return The value to compare to.
7698     */
7699    public String getValue() {
7700      return this.value == null ? null : this.value.getValue();
7701    }
7702
7703    /**
7704     * @param value The value to compare to.
7705     */
7706    public SetupActionAssertComponent setValue(String value) {
7707      if (Utilities.noString(value))
7708        this.value = null;
7709      else {
7710        if (this.value == null)
7711          this.value = new StringType();
7712        this.value.setValue(value);
7713      }
7714      return this;
7715    }
7716
7717    /**
7718     * @return {@link #warningOnly} (Whether or not the test execution will produce
7719     *         a warning only on error for this assert.). This is the underlying
7720     *         object with id, value and extensions. The accessor "getWarningOnly"
7721     *         gives direct access to the value
7722     */
7723    public BooleanType getWarningOnlyElement() {
7724      if (this.warningOnly == null)
7725        if (Configuration.errorOnAutoCreate())
7726          throw new Error("Attempt to auto-create SetupActionAssertComponent.warningOnly");
7727        else if (Configuration.doAutoCreate())
7728          this.warningOnly = new BooleanType(); // bb
7729      return this.warningOnly;
7730    }
7731
7732    public boolean hasWarningOnlyElement() {
7733      return this.warningOnly != null && !this.warningOnly.isEmpty();
7734    }
7735
7736    public boolean hasWarningOnly() {
7737      return this.warningOnly != null && !this.warningOnly.isEmpty();
7738    }
7739
7740    /**
7741     * @param value {@link #warningOnly} (Whether or not the test execution will
7742     *              produce a warning only on error for this assert.). This is the
7743     *              underlying object with id, value and extensions. The accessor
7744     *              "getWarningOnly" gives direct access to the value
7745     */
7746    public SetupActionAssertComponent setWarningOnlyElement(BooleanType value) {
7747      this.warningOnly = value;
7748      return this;
7749    }
7750
7751    /**
7752     * @return Whether or not the test execution will produce a warning only on
7753     *         error for this assert.
7754     */
7755    public boolean getWarningOnly() {
7756      return this.warningOnly == null || this.warningOnly.isEmpty() ? false : this.warningOnly.getValue();
7757    }
7758
7759    /**
7760     * @param value Whether or not the test execution will produce a warning only on
7761     *              error for this assert.
7762     */
7763    public SetupActionAssertComponent setWarningOnly(boolean value) {
7764      if (this.warningOnly == null)
7765        this.warningOnly = new BooleanType();
7766      this.warningOnly.setValue(value);
7767      return this;
7768    }
7769
7770    protected void listChildren(List<Property> children) {
7771      super.listChildren(children);
7772      children.add(new Property("label", "string",
7773          "The label would be used for tracking/logging purposes by test engines.", 0, 1, label));
7774      children.add(new Property("description", "string",
7775          "The description would be used by test engines for tracking and reporting purposes.", 0, 1, description));
7776      children.add(new Property("direction", "code", "The direction to use for the assertion.", 0, 1, direction));
7777      children.add(new Property("compareToSourceId", "string",
7778          "Id of the source fixture used as the contents to be evaluated by either the \"source/expression\" or \"sourceId/path\" definition.",
7779          0, 1, compareToSourceId));
7780      children.add(new Property("compareToSourceExpression", "string",
7781          "The FHIRPath expression to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.",
7782          0, 1, compareToSourceExpression));
7783      children.add(new Property("compareToSourcePath", "string",
7784          "XPath or JSONPath expression to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.",
7785          0, 1, compareToSourcePath));
7786      children.add(new Property("contentType", "code",
7787          "The mime-type contents to compare against the request or response message 'Content-Type' header.", 0, 1,
7788          contentType));
7789      children.add(new Property("expression", "string",
7790          "The FHIRPath expression to be evaluated against the request or response message contents - HTTP headers and payload.",
7791          0, 1, expression));
7792      children
7793          .add(new Property("headerField", "string", "The HTTP header field name e.g. 'Location'.", 0, 1, headerField));
7794      children.add(new Property("minimumId", "string",
7795          "The ID of a fixture.  Asserts that the response contains at a minimum the fixture specified by minimumId.",
7796          0, 1, minimumId));
7797      children.add(new Property("navigationLinks", "boolean",
7798          "Whether or not the test execution performs validation on the bundle navigation links.", 0, 1,
7799          navigationLinks));
7800      children.add(new Property("operator", "code",
7801          "The operator type defines the conditional behavior of the assert. If not defined, the default is equals.", 0,
7802          1, operator));
7803      children.add(new Property("path", "string",
7804          "The XPath or JSONPath expression to be evaluated against the fixture representing the response received from server.",
7805          0, 1, path));
7806      children.add(new Property("requestMethod", "code",
7807          "The request method or HTTP operation code to compare against that used by the client system under test.", 0,
7808          1, requestMethod));
7809      children.add(new Property("requestURL", "string",
7810          "The value to use in a comparison against the request URL path string.", 0, 1, requestURL));
7811      children.add(new Property("resource", "code",
7812          "The type of the resource.  See http://build.fhir.org/resourcelist.html.", 0, 1, resource));
7813      children.add(new Property("response", "code",
7814          "okay | created | noContent | notModified | bad | forbidden | notFound | methodNotAllowed | conflict | gone | preconditionFailed | unprocessable.",
7815          0, 1, response));
7816      children.add(new Property("responseCode", "string", "The value of the HTTP response code to be tested.", 0, 1,
7817          responseCode));
7818      children.add(new Property("sourceId", "id",
7819          "Fixture to evaluate the XPath/JSONPath expression or the headerField  against.", 0, 1, sourceId));
7820      children.add(new Property("validateProfileId", "id", "The ID of the Profile to validate against.", 0, 1,
7821          validateProfileId));
7822      children.add(new Property("value", "string", "The value to compare to.", 0, 1, value));
7823      children.add(new Property("warningOnly", "boolean",
7824          "Whether or not the test execution will produce a warning only on error for this assert.", 0, 1,
7825          warningOnly));
7826    }
7827
7828    @Override
7829    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
7830      switch (_hash) {
7831      case 102727412:
7832        /* label */ return new Property("label", "string",
7833            "The label would be used for tracking/logging purposes by test engines.", 0, 1, label);
7834      case -1724546052:
7835        /* description */ return new Property("description", "string",
7836            "The description would be used by test engines for tracking and reporting purposes.", 0, 1, description);
7837      case -962590849:
7838        /* direction */ return new Property("direction", "code", "The direction to use for the assertion.", 0, 1,
7839            direction);
7840      case 2081856758:
7841        /* compareToSourceId */ return new Property("compareToSourceId", "string",
7842            "Id of the source fixture used as the contents to be evaluated by either the \"source/expression\" or \"sourceId/path\" definition.",
7843            0, 1, compareToSourceId);
7844      case -1415702669:
7845        /* compareToSourceExpression */ return new Property("compareToSourceExpression", "string",
7846            "The FHIRPath expression to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.",
7847            0, 1, compareToSourceExpression);
7848      case -790206144:
7849        /* compareToSourcePath */ return new Property("compareToSourcePath", "string",
7850            "XPath or JSONPath expression to evaluate against the source fixture. When compareToSourceId is defined, either compareToSourceExpression or compareToSourcePath must be defined, but not both.",
7851            0, 1, compareToSourcePath);
7852      case -389131437:
7853        /* contentType */ return new Property("contentType", "code",
7854            "The mime-type contents to compare against the request or response message 'Content-Type' header.", 0, 1,
7855            contentType);
7856      case -1795452264:
7857        /* expression */ return new Property("expression", "string",
7858            "The FHIRPath expression to be evaluated against the request or response message contents - HTTP headers and payload.",
7859            0, 1, expression);
7860      case 1160732269:
7861        /* headerField */ return new Property("headerField", "string", "The HTTP header field name e.g. 'Location'.", 0,
7862            1, headerField);
7863      case 818925001:
7864        /* minimumId */ return new Property("minimumId", "string",
7865            "The ID of a fixture.  Asserts that the response contains at a minimum the fixture specified by minimumId.",
7866            0, 1, minimumId);
7867      case 1001488901:
7868        /* navigationLinks */ return new Property("navigationLinks", "boolean",
7869            "Whether or not the test execution performs validation on the bundle navigation links.", 0, 1,
7870            navigationLinks);
7871      case -500553564:
7872        /* operator */ return new Property("operator", "code",
7873            "The operator type defines the conditional behavior of the assert. If not defined, the default is equals.",
7874            0, 1, operator);
7875      case 3433509:
7876        /* path */ return new Property("path", "string",
7877            "The XPath or JSONPath expression to be evaluated against the fixture representing the response received from server.",
7878            0, 1, path);
7879      case 1217874000:
7880        /* requestMethod */ return new Property("requestMethod", "code",
7881            "The request method or HTTP operation code to compare against that used by the client system under test.",
7882            0, 1, requestMethod);
7883      case 37099616:
7884        /* requestURL */ return new Property("requestURL", "string",
7885            "The value to use in a comparison against the request URL path string.", 0, 1, requestURL);
7886      case -341064690:
7887        /* resource */ return new Property("resource", "code",
7888            "The type of the resource.  See http://build.fhir.org/resourcelist.html.", 0, 1, resource);
7889      case -340323263:
7890        /* response */ return new Property("response", "code",
7891            "okay | created | noContent | notModified | bad | forbidden | notFound | methodNotAllowed | conflict | gone | preconditionFailed | unprocessable.",
7892            0, 1, response);
7893      case 1438723534:
7894        /* responseCode */ return new Property("responseCode", "string",
7895            "The value of the HTTP response code to be tested.", 0, 1, responseCode);
7896      case 1746327190:
7897        /* sourceId */ return new Property("sourceId", "id",
7898            "Fixture to evaluate the XPath/JSONPath expression or the headerField  against.", 0, 1, sourceId);
7899      case 1555541038:
7900        /* validateProfileId */ return new Property("validateProfileId", "id",
7901            "The ID of the Profile to validate against.", 0, 1, validateProfileId);
7902      case 111972721:
7903        /* value */ return new Property("value", "string", "The value to compare to.", 0, 1, value);
7904      case -481159832:
7905        /* warningOnly */ return new Property("warningOnly", "boolean",
7906            "Whether or not the test execution will produce a warning only on error for this assert.", 0, 1,
7907            warningOnly);
7908      default:
7909        return super.getNamedProperty(_hash, _name, _checkValid);
7910      }
7911
7912    }
7913
7914    @Override
7915    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
7916      switch (hash) {
7917      case 102727412:
7918        /* label */ return this.label == null ? new Base[0] : new Base[] { this.label }; // StringType
7919      case -1724546052:
7920        /* description */ return this.description == null ? new Base[0] : new Base[] { this.description }; // StringType
7921      case -962590849:
7922        /* direction */ return this.direction == null ? new Base[0] : new Base[] { this.direction }; // Enumeration<AssertionDirectionType>
7923      case 2081856758:
7924        /* compareToSourceId */ return this.compareToSourceId == null ? new Base[0]
7925            : new Base[] { this.compareToSourceId }; // StringType
7926      case -1415702669:
7927        /* compareToSourceExpression */ return this.compareToSourceExpression == null ? new Base[0]
7928            : new Base[] { this.compareToSourceExpression }; // StringType
7929      case -790206144:
7930        /* compareToSourcePath */ return this.compareToSourcePath == null ? new Base[0]
7931            : new Base[] { this.compareToSourcePath }; // StringType
7932      case -389131437:
7933        /* contentType */ return this.contentType == null ? new Base[0] : new Base[] { this.contentType }; // CodeType
7934      case -1795452264:
7935        /* expression */ return this.expression == null ? new Base[0] : new Base[] { this.expression }; // StringType
7936      case 1160732269:
7937        /* headerField */ return this.headerField == null ? new Base[0] : new Base[] { this.headerField }; // StringType
7938      case 818925001:
7939        /* minimumId */ return this.minimumId == null ? new Base[0] : new Base[] { this.minimumId }; // StringType
7940      case 1001488901:
7941        /* navigationLinks */ return this.navigationLinks == null ? new Base[0] : new Base[] { this.navigationLinks }; // BooleanType
7942      case -500553564:
7943        /* operator */ return this.operator == null ? new Base[0] : new Base[] { this.operator }; // Enumeration<AssertionOperatorType>
7944      case 3433509:
7945        /* path */ return this.path == null ? new Base[0] : new Base[] { this.path }; // StringType
7946      case 1217874000:
7947        /* requestMethod */ return this.requestMethod == null ? new Base[0] : new Base[] { this.requestMethod }; // Enumeration<TestScriptRequestMethodCode>
7948      case 37099616:
7949        /* requestURL */ return this.requestURL == null ? new Base[0] : new Base[] { this.requestURL }; // StringType
7950      case -341064690:
7951        /* resource */ return this.resource == null ? new Base[0] : new Base[] { this.resource }; // CodeType
7952      case -340323263:
7953        /* response */ return this.response == null ? new Base[0] : new Base[] { this.response }; // Enumeration<AssertionResponseTypes>
7954      case 1438723534:
7955        /* responseCode */ return this.responseCode == null ? new Base[0] : new Base[] { this.responseCode }; // StringType
7956      case 1746327190:
7957        /* sourceId */ return this.sourceId == null ? new Base[0] : new Base[] { this.sourceId }; // IdType
7958      case 1555541038:
7959        /* validateProfileId */ return this.validateProfileId == null ? new Base[0]
7960            : new Base[] { this.validateProfileId }; // IdType
7961      case 111972721:
7962        /* value */ return this.value == null ? new Base[0] : new Base[] { this.value }; // StringType
7963      case -481159832:
7964        /* warningOnly */ return this.warningOnly == null ? new Base[0] : new Base[] { this.warningOnly }; // BooleanType
7965      default:
7966        return super.getProperty(hash, name, checkValid);
7967      }
7968
7969    }
7970
7971    @Override
7972    public Base setProperty(int hash, String name, Base value) throws FHIRException {
7973      switch (hash) {
7974      case 102727412: // label
7975        this.label = castToString(value); // StringType
7976        return value;
7977      case -1724546052: // description
7978        this.description = castToString(value); // StringType
7979        return value;
7980      case -962590849: // direction
7981        value = new AssertionDirectionTypeEnumFactory().fromType(castToCode(value));
7982        this.direction = (Enumeration) value; // Enumeration<AssertionDirectionType>
7983        return value;
7984      case 2081856758: // compareToSourceId
7985        this.compareToSourceId = castToString(value); // StringType
7986        return value;
7987      case -1415702669: // compareToSourceExpression
7988        this.compareToSourceExpression = castToString(value); // StringType
7989        return value;
7990      case -790206144: // compareToSourcePath
7991        this.compareToSourcePath = castToString(value); // StringType
7992        return value;
7993      case -389131437: // contentType
7994        this.contentType = castToCode(value); // CodeType
7995        return value;
7996      case -1795452264: // expression
7997        this.expression = castToString(value); // StringType
7998        return value;
7999      case 1160732269: // headerField
8000        this.headerField = castToString(value); // StringType
8001        return value;
8002      case 818925001: // minimumId
8003        this.minimumId = castToString(value); // StringType
8004        return value;
8005      case 1001488901: // navigationLinks
8006        this.navigationLinks = castToBoolean(value); // BooleanType
8007        return value;
8008      case -500553564: // operator
8009        value = new AssertionOperatorTypeEnumFactory().fromType(castToCode(value));
8010        this.operator = (Enumeration) value; // Enumeration<AssertionOperatorType>
8011        return value;
8012      case 3433509: // path
8013        this.path = castToString(value); // StringType
8014        return value;
8015      case 1217874000: // requestMethod
8016        value = new TestScriptRequestMethodCodeEnumFactory().fromType(castToCode(value));
8017        this.requestMethod = (Enumeration) value; // Enumeration<TestScriptRequestMethodCode>
8018        return value;
8019      case 37099616: // requestURL
8020        this.requestURL = castToString(value); // StringType
8021        return value;
8022      case -341064690: // resource
8023        this.resource = castToCode(value); // CodeType
8024        return value;
8025      case -340323263: // response
8026        value = new AssertionResponseTypesEnumFactory().fromType(castToCode(value));
8027        this.response = (Enumeration) value; // Enumeration<AssertionResponseTypes>
8028        return value;
8029      case 1438723534: // responseCode
8030        this.responseCode = castToString(value); // StringType
8031        return value;
8032      case 1746327190: // sourceId
8033        this.sourceId = castToId(value); // IdType
8034        return value;
8035      case 1555541038: // validateProfileId
8036        this.validateProfileId = castToId(value); // IdType
8037        return value;
8038      case 111972721: // value
8039        this.value = castToString(value); // StringType
8040        return value;
8041      case -481159832: // warningOnly
8042        this.warningOnly = castToBoolean(value); // BooleanType
8043        return value;
8044      default:
8045        return super.setProperty(hash, name, value);
8046      }
8047
8048    }
8049
8050    @Override
8051    public Base setProperty(String name, Base value) throws FHIRException {
8052      if (name.equals("label")) {
8053        this.label = castToString(value); // StringType
8054      } else if (name.equals("description")) {
8055        this.description = castToString(value); // StringType
8056      } else if (name.equals("direction")) {
8057        value = new AssertionDirectionTypeEnumFactory().fromType(castToCode(value));
8058        this.direction = (Enumeration) value; // Enumeration<AssertionDirectionType>
8059      } else if (name.equals("compareToSourceId")) {
8060        this.compareToSourceId = castToString(value); // StringType
8061      } else if (name.equals("compareToSourceExpression")) {
8062        this.compareToSourceExpression = castToString(value); // StringType
8063      } else if (name.equals("compareToSourcePath")) {
8064        this.compareToSourcePath = castToString(value); // StringType
8065      } else if (name.equals("contentType")) {
8066        this.contentType = castToCode(value); // CodeType
8067      } else if (name.equals("expression")) {
8068        this.expression = castToString(value); // StringType
8069      } else if (name.equals("headerField")) {
8070        this.headerField = castToString(value); // StringType
8071      } else if (name.equals("minimumId")) {
8072        this.minimumId = castToString(value); // StringType
8073      } else if (name.equals("navigationLinks")) {
8074        this.navigationLinks = castToBoolean(value); // BooleanType
8075      } else if (name.equals("operator")) {
8076        value = new AssertionOperatorTypeEnumFactory().fromType(castToCode(value));
8077        this.operator = (Enumeration) value; // Enumeration<AssertionOperatorType>
8078      } else if (name.equals("path")) {
8079        this.path = castToString(value); // StringType
8080      } else if (name.equals("requestMethod")) {
8081        value = new TestScriptRequestMethodCodeEnumFactory().fromType(castToCode(value));
8082        this.requestMethod = (Enumeration) value; // Enumeration<TestScriptRequestMethodCode>
8083      } else if (name.equals("requestURL")) {
8084        this.requestURL = castToString(value); // StringType
8085      } else if (name.equals("resource")) {
8086        this.resource = castToCode(value); // CodeType
8087      } else if (name.equals("response")) {
8088        value = new AssertionResponseTypesEnumFactory().fromType(castToCode(value));
8089        this.response = (Enumeration) value; // Enumeration<AssertionResponseTypes>
8090      } else if (name.equals("responseCode")) {
8091        this.responseCode = castToString(value); // StringType
8092      } else if (name.equals("sourceId")) {
8093        this.sourceId = castToId(value); // IdType
8094      } else if (name.equals("validateProfileId")) {
8095        this.validateProfileId = castToId(value); // IdType
8096      } else if (name.equals("value")) {
8097        this.value = castToString(value); // StringType
8098      } else if (name.equals("warningOnly")) {
8099        this.warningOnly = castToBoolean(value); // BooleanType
8100      } else
8101        return super.setProperty(name, value);
8102      return value;
8103    }
8104
8105    @Override
8106    public Base makeProperty(int hash, String name) throws FHIRException {
8107      switch (hash) {
8108      case 102727412:
8109        return getLabelElement();
8110      case -1724546052:
8111        return getDescriptionElement();
8112      case -962590849:
8113        return getDirectionElement();
8114      case 2081856758:
8115        return getCompareToSourceIdElement();
8116      case -1415702669:
8117        return getCompareToSourceExpressionElement();
8118      case -790206144:
8119        return getCompareToSourcePathElement();
8120      case -389131437:
8121        return getContentTypeElement();
8122      case -1795452264:
8123        return getExpressionElement();
8124      case 1160732269:
8125        return getHeaderFieldElement();
8126      case 818925001:
8127        return getMinimumIdElement();
8128      case 1001488901:
8129        return getNavigationLinksElement();
8130      case -500553564:
8131        return getOperatorElement();
8132      case 3433509:
8133        return getPathElement();
8134      case 1217874000:
8135        return getRequestMethodElement();
8136      case 37099616:
8137        return getRequestURLElement();
8138      case -341064690:
8139        return getResourceElement();
8140      case -340323263:
8141        return getResponseElement();
8142      case 1438723534:
8143        return getResponseCodeElement();
8144      case 1746327190:
8145        return getSourceIdElement();
8146      case 1555541038:
8147        return getValidateProfileIdElement();
8148      case 111972721:
8149        return getValueElement();
8150      case -481159832:
8151        return getWarningOnlyElement();
8152      default:
8153        return super.makeProperty(hash, name);
8154      }
8155
8156    }
8157
8158    @Override
8159    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
8160      switch (hash) {
8161      case 102727412:
8162        /* label */ return new String[] { "string" };
8163      case -1724546052:
8164        /* description */ return new String[] { "string" };
8165      case -962590849:
8166        /* direction */ return new String[] { "code" };
8167      case 2081856758:
8168        /* compareToSourceId */ return new String[] { "string" };
8169      case -1415702669:
8170        /* compareToSourceExpression */ return new String[] { "string" };
8171      case -790206144:
8172        /* compareToSourcePath */ return new String[] { "string" };
8173      case -389131437:
8174        /* contentType */ return new String[] { "code" };
8175      case -1795452264:
8176        /* expression */ return new String[] { "string" };
8177      case 1160732269:
8178        /* headerField */ return new String[] { "string" };
8179      case 818925001:
8180        /* minimumId */ return new String[] { "string" };
8181      case 1001488901:
8182        /* navigationLinks */ return new String[] { "boolean" };
8183      case -500553564:
8184        /* operator */ return new String[] { "code" };
8185      case 3433509:
8186        /* path */ return new String[] { "string" };
8187      case 1217874000:
8188        /* requestMethod */ return new String[] { "code" };
8189      case 37099616:
8190        /* requestURL */ return new String[] { "string" };
8191      case -341064690:
8192        /* resource */ return new String[] { "code" };
8193      case -340323263:
8194        /* response */ return new String[] { "code" };
8195      case 1438723534:
8196        /* responseCode */ return new String[] { "string" };
8197      case 1746327190:
8198        /* sourceId */ return new String[] { "id" };
8199      case 1555541038:
8200        /* validateProfileId */ return new String[] { "id" };
8201      case 111972721:
8202        /* value */ return new String[] { "string" };
8203      case -481159832:
8204        /* warningOnly */ return new String[] { "boolean" };
8205      default:
8206        return super.getTypesForProperty(hash, name);
8207      }
8208
8209    }
8210
8211    @Override
8212    public Base addChild(String name) throws FHIRException {
8213      if (name.equals("label")) {
8214        throw new FHIRException("Cannot call addChild on a singleton property TestScript.label");
8215      } else if (name.equals("description")) {
8216        throw new FHIRException("Cannot call addChild on a singleton property TestScript.description");
8217      } else if (name.equals("direction")) {
8218        throw new FHIRException("Cannot call addChild on a singleton property TestScript.direction");
8219      } else if (name.equals("compareToSourceId")) {
8220        throw new FHIRException("Cannot call addChild on a singleton property TestScript.compareToSourceId");
8221      } else if (name.equals("compareToSourceExpression")) {
8222        throw new FHIRException("Cannot call addChild on a singleton property TestScript.compareToSourceExpression");
8223      } else if (name.equals("compareToSourcePath")) {
8224        throw new FHIRException("Cannot call addChild on a singleton property TestScript.compareToSourcePath");
8225      } else if (name.equals("contentType")) {
8226        throw new FHIRException("Cannot call addChild on a singleton property TestScript.contentType");
8227      } else if (name.equals("expression")) {
8228        throw new FHIRException("Cannot call addChild on a singleton property TestScript.expression");
8229      } else if (name.equals("headerField")) {
8230        throw new FHIRException("Cannot call addChild on a singleton property TestScript.headerField");
8231      } else if (name.equals("minimumId")) {
8232        throw new FHIRException("Cannot call addChild on a singleton property TestScript.minimumId");
8233      } else if (name.equals("navigationLinks")) {
8234        throw new FHIRException("Cannot call addChild on a singleton property TestScript.navigationLinks");
8235      } else if (name.equals("operator")) {
8236        throw new FHIRException("Cannot call addChild on a singleton property TestScript.operator");
8237      } else if (name.equals("path")) {
8238        throw new FHIRException("Cannot call addChild on a singleton property TestScript.path");
8239      } else if (name.equals("requestMethod")) {
8240        throw new FHIRException("Cannot call addChild on a singleton property TestScript.requestMethod");
8241      } else if (name.equals("requestURL")) {
8242        throw new FHIRException("Cannot call addChild on a singleton property TestScript.requestURL");
8243      } else if (name.equals("resource")) {
8244        throw new FHIRException("Cannot call addChild on a singleton property TestScript.resource");
8245      } else if (name.equals("response")) {
8246        throw new FHIRException("Cannot call addChild on a singleton property TestScript.response");
8247      } else if (name.equals("responseCode")) {
8248        throw new FHIRException("Cannot call addChild on a singleton property TestScript.responseCode");
8249      } else if (name.equals("sourceId")) {
8250        throw new FHIRException("Cannot call addChild on a singleton property TestScript.sourceId");
8251      } else if (name.equals("validateProfileId")) {
8252        throw new FHIRException("Cannot call addChild on a singleton property TestScript.validateProfileId");
8253      } else if (name.equals("value")) {
8254        throw new FHIRException("Cannot call addChild on a singleton property TestScript.value");
8255      } else if (name.equals("warningOnly")) {
8256        throw new FHIRException("Cannot call addChild on a singleton property TestScript.warningOnly");
8257      } else
8258        return super.addChild(name);
8259    }
8260
8261    public SetupActionAssertComponent copy() {
8262      SetupActionAssertComponent dst = new SetupActionAssertComponent();
8263      copyValues(dst);
8264      return dst;
8265    }
8266
8267    public void copyValues(SetupActionAssertComponent dst) {
8268      super.copyValues(dst);
8269      dst.label = label == null ? null : label.copy();
8270      dst.description = description == null ? null : description.copy();
8271      dst.direction = direction == null ? null : direction.copy();
8272      dst.compareToSourceId = compareToSourceId == null ? null : compareToSourceId.copy();
8273      dst.compareToSourceExpression = compareToSourceExpression == null ? null : compareToSourceExpression.copy();
8274      dst.compareToSourcePath = compareToSourcePath == null ? null : compareToSourcePath.copy();
8275      dst.contentType = contentType == null ? null : contentType.copy();
8276      dst.expression = expression == null ? null : expression.copy();
8277      dst.headerField = headerField == null ? null : headerField.copy();
8278      dst.minimumId = minimumId == null ? null : minimumId.copy();
8279      dst.navigationLinks = navigationLinks == null ? null : navigationLinks.copy();
8280      dst.operator = operator == null ? null : operator.copy();
8281      dst.path = path == null ? null : path.copy();
8282      dst.requestMethod = requestMethod == null ? null : requestMethod.copy();
8283      dst.requestURL = requestURL == null ? null : requestURL.copy();
8284      dst.resource = resource == null ? null : resource.copy();
8285      dst.response = response == null ? null : response.copy();
8286      dst.responseCode = responseCode == null ? null : responseCode.copy();
8287      dst.sourceId = sourceId == null ? null : sourceId.copy();
8288      dst.validateProfileId = validateProfileId == null ? null : validateProfileId.copy();
8289      dst.value = value == null ? null : value.copy();
8290      dst.warningOnly = warningOnly == null ? null : warningOnly.copy();
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)
8301          && compareDeep(direction, o.direction, true) && compareDeep(compareToSourceId, o.compareToSourceId, true)
8302          && compareDeep(compareToSourceExpression, o.compareToSourceExpression, true)
8303          && compareDeep(compareToSourcePath, o.compareToSourcePath, true)
8304          && compareDeep(contentType, o.contentType, true) && compareDeep(expression, o.expression, true)
8305          && compareDeep(headerField, o.headerField, true) && compareDeep(minimumId, o.minimumId, true)
8306          && compareDeep(navigationLinks, o.navigationLinks, true) && compareDeep(operator, o.operator, true)
8307          && compareDeep(path, o.path, true) && compareDeep(requestMethod, o.requestMethod, true)
8308          && compareDeep(requestURL, o.requestURL, true) && compareDeep(resource, o.resource, true)
8309          && compareDeep(response, o.response, true) && compareDeep(responseCode, o.responseCode, true)
8310          && compareDeep(sourceId, o.sourceId, true) && compareDeep(validateProfileId, o.validateProfileId, true)
8311          && compareDeep(value, o.value, true) && compareDeep(warningOnly, o.warningOnly, true);
8312    }
8313
8314    @Override
8315    public boolean equalsShallow(Base other_) {
8316      if (!super.equalsShallow(other_))
8317        return false;
8318      if (!(other_ instanceof SetupActionAssertComponent))
8319        return false;
8320      SetupActionAssertComponent o = (SetupActionAssertComponent) other_;
8321      return compareValues(label, o.label, true) && compareValues(description, o.description, true)
8322          && compareValues(direction, o.direction, true) && compareValues(compareToSourceId, o.compareToSourceId, true)
8323          && compareValues(compareToSourceExpression, o.compareToSourceExpression, true)
8324          && compareValues(compareToSourcePath, o.compareToSourcePath, true)
8325          && compareValues(contentType, o.contentType, true) && compareValues(expression, o.expression, true)
8326          && compareValues(headerField, o.headerField, true) && compareValues(minimumId, o.minimumId, true)
8327          && compareValues(navigationLinks, o.navigationLinks, true) && compareValues(operator, o.operator, true)
8328          && compareValues(path, o.path, true) && compareValues(requestMethod, o.requestMethod, true)
8329          && compareValues(requestURL, o.requestURL, true) && compareValues(resource, o.resource, true)
8330          && compareValues(response, o.response, true) && compareValues(responseCode, o.responseCode, true)
8331          && compareValues(sourceId, o.sourceId, true) && compareValues(validateProfileId, o.validateProfileId, true)
8332          && compareValues(value, o.value, true) && compareValues(warningOnly, o.warningOnly, true);
8333    }
8334
8335    public boolean isEmpty() {
8336      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(label, description, direction, compareToSourceId,
8337          compareToSourceExpression, compareToSourcePath, contentType, expression, headerField, minimumId,
8338          navigationLinks, operator, path, requestMethod, requestURL, resource, response, responseCode, sourceId,
8339          validateProfileId, value, warningOnly);
8340    }
8341
8342    public String fhirType() {
8343      return "TestScript.setup.action.assert";
8344
8345    }
8346
8347  }
8348
8349  @Block()
8350  public static class TestScriptTestComponent extends BackboneElement implements IBaseBackboneElement {
8351    /**
8352     * The name of this test used for tracking/logging purposes by test engines.
8353     */
8354    @Child(name = "name", type = { StringType.class }, order = 1, min = 0, max = 1, modifier = false, summary = false)
8355    @Description(shortDefinition = "Tracking/logging name of this test", formalDefinition = "The name of this test used for tracking/logging purposes by test engines.")
8356    protected StringType name;
8357
8358    /**
8359     * A short description of the test used by test engines for tracking and
8360     * reporting purposes.
8361     */
8362    @Child(name = "description", type = {
8363        StringType.class }, order = 2, min = 0, max = 1, modifier = false, summary = false)
8364    @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.")
8365    protected StringType description;
8366
8367    /**
8368     * Action would contain either an operation or an assertion.
8369     */
8370    @Child(name = "action", type = {}, order = 3, min = 1, max = Child.MAX_UNLIMITED, modifier = false, summary = false)
8371    @Description(shortDefinition = "A test operation or assert to perform", formalDefinition = "Action would contain either an operation or an assertion.")
8372    protected List<TestActionComponent> action;
8373
8374    private static final long serialVersionUID = -865006110L;
8375
8376    /**
8377     * Constructor
8378     */
8379    public TestScriptTestComponent() {
8380      super();
8381    }
8382
8383    /**
8384     * @return {@link #name} (The name of this test used for tracking/logging
8385     *         purposes by test engines.). This is the underlying object with id,
8386     *         value and extensions. The accessor "getName" gives direct access to
8387     *         the value
8388     */
8389    public StringType getNameElement() {
8390      if (this.name == null)
8391        if (Configuration.errorOnAutoCreate())
8392          throw new Error("Attempt to auto-create TestScriptTestComponent.name");
8393        else if (Configuration.doAutoCreate())
8394          this.name = new StringType(); // bb
8395      return this.name;
8396    }
8397
8398    public boolean hasNameElement() {
8399      return this.name != null && !this.name.isEmpty();
8400    }
8401
8402    public boolean hasName() {
8403      return this.name != null && !this.name.isEmpty();
8404    }
8405
8406    /**
8407     * @param value {@link #name} (The name of this test used for tracking/logging
8408     *              purposes by test engines.). This is the underlying object with
8409     *              id, value and extensions. The accessor "getName" gives direct
8410     *              access to the value
8411     */
8412    public TestScriptTestComponent setNameElement(StringType value) {
8413      this.name = value;
8414      return this;
8415    }
8416
8417    /**
8418     * @return The name of this test used for tracking/logging purposes by test
8419     *         engines.
8420     */
8421    public String getName() {
8422      return this.name == null ? null : this.name.getValue();
8423    }
8424
8425    /**
8426     * @param value The name of this test used for tracking/logging purposes by test
8427     *              engines.
8428     */
8429    public TestScriptTestComponent setName(String value) {
8430      if (Utilities.noString(value))
8431        this.name = null;
8432      else {
8433        if (this.name == null)
8434          this.name = new StringType();
8435        this.name.setValue(value);
8436      }
8437      return this;
8438    }
8439
8440    /**
8441     * @return {@link #description} (A short description of the test used by test
8442     *         engines for tracking and reporting purposes.). This is the underlying
8443     *         object with id, value and extensions. The accessor "getDescription"
8444     *         gives direct access to the value
8445     */
8446    public StringType getDescriptionElement() {
8447      if (this.description == null)
8448        if (Configuration.errorOnAutoCreate())
8449          throw new Error("Attempt to auto-create TestScriptTestComponent.description");
8450        else if (Configuration.doAutoCreate())
8451          this.description = new StringType(); // bb
8452      return this.description;
8453    }
8454
8455    public boolean hasDescriptionElement() {
8456      return this.description != null && !this.description.isEmpty();
8457    }
8458
8459    public boolean hasDescription() {
8460      return this.description != null && !this.description.isEmpty();
8461    }
8462
8463    /**
8464     * @param value {@link #description} (A short description of the test used by
8465     *              test engines for tracking and reporting purposes.). This is the
8466     *              underlying object with id, value and extensions. The accessor
8467     *              "getDescription" gives direct access to the value
8468     */
8469    public TestScriptTestComponent setDescriptionElement(StringType value) {
8470      this.description = value;
8471      return this;
8472    }
8473
8474    /**
8475     * @return A short description of the test used by test engines for tracking and
8476     *         reporting purposes.
8477     */
8478    public String getDescription() {
8479      return this.description == null ? null : this.description.getValue();
8480    }
8481
8482    /**
8483     * @param value A short description of the test used by test engines for
8484     *              tracking and reporting purposes.
8485     */
8486    public TestScriptTestComponent setDescription(String value) {
8487      if (Utilities.noString(value))
8488        this.description = null;
8489      else {
8490        if (this.description == null)
8491          this.description = new StringType();
8492        this.description.setValue(value);
8493      }
8494      return this;
8495    }
8496
8497    /**
8498     * @return {@link #action} (Action would contain either an operation or an
8499     *         assertion.)
8500     */
8501    public List<TestActionComponent> getAction() {
8502      if (this.action == null)
8503        this.action = new ArrayList<TestActionComponent>();
8504      return this.action;
8505    }
8506
8507    /**
8508     * @return Returns a reference to <code>this</code> for easy method chaining
8509     */
8510    public TestScriptTestComponent setAction(List<TestActionComponent> theAction) {
8511      this.action = theAction;
8512      return this;
8513    }
8514
8515    public boolean hasAction() {
8516      if (this.action == null)
8517        return false;
8518      for (TestActionComponent item : this.action)
8519        if (!item.isEmpty())
8520          return true;
8521      return false;
8522    }
8523
8524    public TestActionComponent addAction() { // 3
8525      TestActionComponent t = new TestActionComponent();
8526      if (this.action == null)
8527        this.action = new ArrayList<TestActionComponent>();
8528      this.action.add(t);
8529      return t;
8530    }
8531
8532    public TestScriptTestComponent addAction(TestActionComponent t) { // 3
8533      if (t == null)
8534        return this;
8535      if (this.action == null)
8536        this.action = new ArrayList<TestActionComponent>();
8537      this.action.add(t);
8538      return this;
8539    }
8540
8541    /**
8542     * @return The first repetition of repeating field {@link #action}, creating it
8543     *         if it does not already exist
8544     */
8545    public TestActionComponent getActionFirstRep() {
8546      if (getAction().isEmpty()) {
8547        addAction();
8548      }
8549      return getAction().get(0);
8550    }
8551
8552    protected void listChildren(List<Property> children) {
8553      super.listChildren(children);
8554      children.add(new Property("name", "string",
8555          "The name of this test used for tracking/logging purposes by test engines.", 0, 1, name));
8556      children.add(new Property("description", "string",
8557          "A short description of the test used by test engines for tracking and reporting purposes.", 0, 1,
8558          description));
8559      children.add(new Property("action", "", "Action would contain either an operation or an assertion.", 0,
8560          java.lang.Integer.MAX_VALUE, action));
8561    }
8562
8563    @Override
8564    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
8565      switch (_hash) {
8566      case 3373707:
8567        /* name */ return new Property("name", "string",
8568            "The name of this test used for tracking/logging purposes by test engines.", 0, 1, name);
8569      case -1724546052:
8570        /* description */ return new Property("description", "string",
8571            "A short description of the test used by test engines for tracking and reporting purposes.", 0, 1,
8572            description);
8573      case -1422950858:
8574        /* action */ return new Property("action", "", "Action would contain either an operation or an assertion.", 0,
8575            java.lang.Integer.MAX_VALUE, action);
8576      default:
8577        return super.getNamedProperty(_hash, _name, _checkValid);
8578      }
8579
8580    }
8581
8582    @Override
8583    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
8584      switch (hash) {
8585      case 3373707:
8586        /* name */ return this.name == null ? new Base[0] : new Base[] { this.name }; // StringType
8587      case -1724546052:
8588        /* description */ return this.description == null ? new Base[0] : new Base[] { this.description }; // StringType
8589      case -1422950858:
8590        /* action */ return this.action == null ? new Base[0] : this.action.toArray(new Base[this.action.size()]); // TestActionComponent
8591      default:
8592        return super.getProperty(hash, name, checkValid);
8593      }
8594
8595    }
8596
8597    @Override
8598    public Base setProperty(int hash, String name, Base value) throws FHIRException {
8599      switch (hash) {
8600      case 3373707: // name
8601        this.name = castToString(value); // StringType
8602        return value;
8603      case -1724546052: // description
8604        this.description = castToString(value); // StringType
8605        return value;
8606      case -1422950858: // action
8607        this.getAction().add((TestActionComponent) value); // TestActionComponent
8608        return value;
8609      default:
8610        return super.setProperty(hash, name, value);
8611      }
8612
8613    }
8614
8615    @Override
8616    public Base setProperty(String name, Base value) throws FHIRException {
8617      if (name.equals("name")) {
8618        this.name = castToString(value); // StringType
8619      } else if (name.equals("description")) {
8620        this.description = castToString(value); // StringType
8621      } else if (name.equals("action")) {
8622        this.getAction().add((TestActionComponent) value);
8623      } else
8624        return super.setProperty(name, value);
8625      return value;
8626    }
8627
8628    @Override
8629    public Base makeProperty(int hash, String name) throws FHIRException {
8630      switch (hash) {
8631      case 3373707:
8632        return getNameElement();
8633      case -1724546052:
8634        return getDescriptionElement();
8635      case -1422950858:
8636        return addAction();
8637      default:
8638        return super.makeProperty(hash, name);
8639      }
8640
8641    }
8642
8643    @Override
8644    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
8645      switch (hash) {
8646      case 3373707:
8647        /* name */ return new String[] { "string" };
8648      case -1724546052:
8649        /* description */ return new String[] { "string" };
8650      case -1422950858:
8651        /* action */ return new String[] {};
8652      default:
8653        return super.getTypesForProperty(hash, name);
8654      }
8655
8656    }
8657
8658    @Override
8659    public Base addChild(String name) throws FHIRException {
8660      if (name.equals("name")) {
8661        throw new FHIRException("Cannot call addChild on a singleton property TestScript.name");
8662      } else if (name.equals("description")) {
8663        throw new FHIRException("Cannot call addChild on a singleton property TestScript.description");
8664      } else if (name.equals("action")) {
8665        return addAction();
8666      } else
8667        return super.addChild(name);
8668    }
8669
8670    public TestScriptTestComponent copy() {
8671      TestScriptTestComponent dst = new TestScriptTestComponent();
8672      copyValues(dst);
8673      return dst;
8674    }
8675
8676    public void copyValues(TestScriptTestComponent dst) {
8677      super.copyValues(dst);
8678      dst.name = name == null ? null : name.copy();
8679      dst.description = description == null ? null : description.copy();
8680      if (action != null) {
8681        dst.action = new ArrayList<TestActionComponent>();
8682        for (TestActionComponent i : action)
8683          dst.action.add(i.copy());
8684      }
8685      ;
8686    }
8687
8688    @Override
8689    public boolean equalsDeep(Base other_) {
8690      if (!super.equalsDeep(other_))
8691        return false;
8692      if (!(other_ instanceof TestScriptTestComponent))
8693        return false;
8694      TestScriptTestComponent o = (TestScriptTestComponent) other_;
8695      return compareDeep(name, o.name, true) && compareDeep(description, o.description, true)
8696          && compareDeep(action, o.action, true);
8697    }
8698
8699    @Override
8700    public boolean equalsShallow(Base other_) {
8701      if (!super.equalsShallow(other_))
8702        return false;
8703      if (!(other_ instanceof TestScriptTestComponent))
8704        return false;
8705      TestScriptTestComponent o = (TestScriptTestComponent) other_;
8706      return compareValues(name, o.name, true) && compareValues(description, o.description, true);
8707    }
8708
8709    public boolean isEmpty() {
8710      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(name, description, action);
8711    }
8712
8713    public String fhirType() {
8714      return "TestScript.test";
8715
8716    }
8717
8718  }
8719
8720  @Block()
8721  public static class TestActionComponent extends BackboneElement implements IBaseBackboneElement {
8722    /**
8723     * An operation would involve a REST request to a server.
8724     */
8725    @Child(name = "operation", type = {
8726        SetupActionOperationComponent.class }, order = 1, min = 0, max = 1, modifier = false, summary = false)
8727    @Description(shortDefinition = "The setup operation to perform", formalDefinition = "An operation would involve a REST request to a server.")
8728    protected SetupActionOperationComponent operation;
8729
8730    /**
8731     * Evaluates the results of previous operations to determine if the server under
8732     * test behaves appropriately.
8733     */
8734    @Child(name = "assert", type = {
8735        SetupActionAssertComponent.class }, order = 2, min = 0, max = 1, modifier = false, summary = false)
8736    @Description(shortDefinition = "The setup assertion to perform", formalDefinition = "Evaluates the results of previous operations to determine if the server under test behaves appropriately.")
8737    protected SetupActionAssertComponent assert_;
8738
8739    private static final long serialVersionUID = -252088305L;
8740
8741    /**
8742     * Constructor
8743     */
8744    public TestActionComponent() {
8745      super();
8746    }
8747
8748    /**
8749     * @return {@link #operation} (An operation would involve a REST request to a
8750     *         server.)
8751     */
8752    public SetupActionOperationComponent getOperation() {
8753      if (this.operation == null)
8754        if (Configuration.errorOnAutoCreate())
8755          throw new Error("Attempt to auto-create TestActionComponent.operation");
8756        else if (Configuration.doAutoCreate())
8757          this.operation = new SetupActionOperationComponent(); // cc
8758      return this.operation;
8759    }
8760
8761    public boolean hasOperation() {
8762      return this.operation != null && !this.operation.isEmpty();
8763    }
8764
8765    /**
8766     * @param value {@link #operation} (An operation would involve a REST request to
8767     *              a server.)
8768     */
8769    public TestActionComponent setOperation(SetupActionOperationComponent value) {
8770      this.operation = value;
8771      return this;
8772    }
8773
8774    /**
8775     * @return {@link #assert_} (Evaluates the results of previous operations to
8776     *         determine if the server under test behaves appropriately.)
8777     */
8778    public SetupActionAssertComponent getAssert() {
8779      if (this.assert_ == null)
8780        if (Configuration.errorOnAutoCreate())
8781          throw new Error("Attempt to auto-create TestActionComponent.assert_");
8782        else if (Configuration.doAutoCreate())
8783          this.assert_ = new SetupActionAssertComponent(); // cc
8784      return this.assert_;
8785    }
8786
8787    public boolean hasAssert() {
8788      return this.assert_ != null && !this.assert_.isEmpty();
8789    }
8790
8791    /**
8792     * @param value {@link #assert_} (Evaluates the results of previous operations
8793     *              to determine if the server under test behaves appropriately.)
8794     */
8795    public TestActionComponent setAssert(SetupActionAssertComponent value) {
8796      this.assert_ = value;
8797      return this;
8798    }
8799
8800    protected void listChildren(List<Property> children) {
8801      super.listChildren(children);
8802      children.add(new Property("operation", "@TestScript.setup.action.operation",
8803          "An operation would involve a REST request to a server.", 0, 1, operation));
8804      children.add(new Property("assert", "@TestScript.setup.action.assert",
8805          "Evaluates the results of previous operations to determine if the server under test behaves appropriately.",
8806          0, 1, assert_));
8807    }
8808
8809    @Override
8810    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
8811      switch (_hash) {
8812      case 1662702951:
8813        /* operation */ return new Property("operation", "@TestScript.setup.action.operation",
8814            "An operation would involve a REST request to a server.", 0, 1, operation);
8815      case -1408208058:
8816        /* assert */ return new Property("assert", "@TestScript.setup.action.assert",
8817            "Evaluates the results of previous operations to determine if the server under test behaves appropriately.",
8818            0, 1, assert_);
8819      default:
8820        return super.getNamedProperty(_hash, _name, _checkValid);
8821      }
8822
8823    }
8824
8825    @Override
8826    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
8827      switch (hash) {
8828      case 1662702951:
8829        /* operation */ return this.operation == null ? new Base[0] : new Base[] { this.operation }; // SetupActionOperationComponent
8830      case -1408208058:
8831        /* assert */ return this.assert_ == null ? new Base[0] : new Base[] { this.assert_ }; // SetupActionAssertComponent
8832      default:
8833        return super.getProperty(hash, name, checkValid);
8834      }
8835
8836    }
8837
8838    @Override
8839    public Base setProperty(int hash, String name, Base value) throws FHIRException {
8840      switch (hash) {
8841      case 1662702951: // operation
8842        this.operation = (SetupActionOperationComponent) value; // SetupActionOperationComponent
8843        return value;
8844      case -1408208058: // assert
8845        this.assert_ = (SetupActionAssertComponent) value; // SetupActionAssertComponent
8846        return value;
8847      default:
8848        return super.setProperty(hash, name, value);
8849      }
8850
8851    }
8852
8853    @Override
8854    public Base setProperty(String name, Base value) throws FHIRException {
8855      if (name.equals("operation")) {
8856        this.operation = (SetupActionOperationComponent) value; // SetupActionOperationComponent
8857      } else if (name.equals("assert")) {
8858        this.assert_ = (SetupActionAssertComponent) value; // SetupActionAssertComponent
8859      } else
8860        return super.setProperty(name, value);
8861      return value;
8862    }
8863
8864    @Override
8865    public Base makeProperty(int hash, String name) throws FHIRException {
8866      switch (hash) {
8867      case 1662702951:
8868        return getOperation();
8869      case -1408208058:
8870        return getAssert();
8871      default:
8872        return super.makeProperty(hash, name);
8873      }
8874
8875    }
8876
8877    @Override
8878    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
8879      switch (hash) {
8880      case 1662702951:
8881        /* operation */ return new String[] { "@TestScript.setup.action.operation" };
8882      case -1408208058:
8883        /* assert */ return new String[] { "@TestScript.setup.action.assert" };
8884      default:
8885        return super.getTypesForProperty(hash, name);
8886      }
8887
8888    }
8889
8890    @Override
8891    public Base addChild(String name) throws FHIRException {
8892      if (name.equals("operation")) {
8893        this.operation = new SetupActionOperationComponent();
8894        return this.operation;
8895      } else if (name.equals("assert")) {
8896        this.assert_ = new SetupActionAssertComponent();
8897        return this.assert_;
8898      } else
8899        return super.addChild(name);
8900    }
8901
8902    public TestActionComponent copy() {
8903      TestActionComponent dst = new TestActionComponent();
8904      copyValues(dst);
8905      return dst;
8906    }
8907
8908    public void copyValues(TestActionComponent dst) {
8909      super.copyValues(dst);
8910      dst.operation = operation == null ? null : operation.copy();
8911      dst.assert_ = assert_ == null ? null : assert_.copy();
8912    }
8913
8914    @Override
8915    public boolean equalsDeep(Base other_) {
8916      if (!super.equalsDeep(other_))
8917        return false;
8918      if (!(other_ instanceof TestActionComponent))
8919        return false;
8920      TestActionComponent o = (TestActionComponent) other_;
8921      return compareDeep(operation, o.operation, true) && compareDeep(assert_, o.assert_, true);
8922    }
8923
8924    @Override
8925    public boolean equalsShallow(Base other_) {
8926      if (!super.equalsShallow(other_))
8927        return false;
8928      if (!(other_ instanceof TestActionComponent))
8929        return false;
8930      TestActionComponent o = (TestActionComponent) other_;
8931      return true;
8932    }
8933
8934    public boolean isEmpty() {
8935      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(operation, assert_);
8936    }
8937
8938    public String fhirType() {
8939      return "TestScript.test.action";
8940
8941    }
8942
8943  }
8944
8945  @Block()
8946  public static class TestScriptTeardownComponent extends BackboneElement implements IBaseBackboneElement {
8947    /**
8948     * The teardown action will only contain an operation.
8949     */
8950    @Child(name = "action", type = {}, order = 1, min = 1, max = Child.MAX_UNLIMITED, modifier = false, summary = false)
8951    @Description(shortDefinition = "One or more teardown operations to perform", formalDefinition = "The teardown action will only contain an operation.")
8952    protected List<TeardownActionComponent> action;
8953
8954    private static final long serialVersionUID = 1168638089L;
8955
8956    /**
8957     * Constructor
8958     */
8959    public TestScriptTeardownComponent() {
8960      super();
8961    }
8962
8963    /**
8964     * @return {@link #action} (The teardown action will only contain an operation.)
8965     */
8966    public List<TeardownActionComponent> getAction() {
8967      if (this.action == null)
8968        this.action = new ArrayList<TeardownActionComponent>();
8969      return this.action;
8970    }
8971
8972    /**
8973     * @return Returns a reference to <code>this</code> for easy method chaining
8974     */
8975    public TestScriptTeardownComponent setAction(List<TeardownActionComponent> theAction) {
8976      this.action = theAction;
8977      return this;
8978    }
8979
8980    public boolean hasAction() {
8981      if (this.action == null)
8982        return false;
8983      for (TeardownActionComponent item : this.action)
8984        if (!item.isEmpty())
8985          return true;
8986      return false;
8987    }
8988
8989    public TeardownActionComponent addAction() { // 3
8990      TeardownActionComponent t = new TeardownActionComponent();
8991      if (this.action == null)
8992        this.action = new ArrayList<TeardownActionComponent>();
8993      this.action.add(t);
8994      return t;
8995    }
8996
8997    public TestScriptTeardownComponent addAction(TeardownActionComponent t) { // 3
8998      if (t == null)
8999        return this;
9000      if (this.action == null)
9001        this.action = new ArrayList<TeardownActionComponent>();
9002      this.action.add(t);
9003      return this;
9004    }
9005
9006    /**
9007     * @return The first repetition of repeating field {@link #action}, creating it
9008     *         if it does not already exist
9009     */
9010    public TeardownActionComponent getActionFirstRep() {
9011      if (getAction().isEmpty()) {
9012        addAction();
9013      }
9014      return getAction().get(0);
9015    }
9016
9017    protected void listChildren(List<Property> children) {
9018      super.listChildren(children);
9019      children.add(new Property("action", "", "The teardown action will only contain an operation.", 0,
9020          java.lang.Integer.MAX_VALUE, action));
9021    }
9022
9023    @Override
9024    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
9025      switch (_hash) {
9026      case -1422950858:
9027        /* action */ return new Property("action", "", "The teardown action will only contain an operation.", 0,
9028            java.lang.Integer.MAX_VALUE, action);
9029      default:
9030        return super.getNamedProperty(_hash, _name, _checkValid);
9031      }
9032
9033    }
9034
9035    @Override
9036    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
9037      switch (hash) {
9038      case -1422950858:
9039        /* action */ return this.action == null ? new Base[0] : this.action.toArray(new Base[this.action.size()]); // TeardownActionComponent
9040      default:
9041        return super.getProperty(hash, name, checkValid);
9042      }
9043
9044    }
9045
9046    @Override
9047    public Base setProperty(int hash, String name, Base value) throws FHIRException {
9048      switch (hash) {
9049      case -1422950858: // action
9050        this.getAction().add((TeardownActionComponent) value); // TeardownActionComponent
9051        return value;
9052      default:
9053        return super.setProperty(hash, name, value);
9054      }
9055
9056    }
9057
9058    @Override
9059    public Base setProperty(String name, Base value) throws FHIRException {
9060      if (name.equals("action")) {
9061        this.getAction().add((TeardownActionComponent) value);
9062      } else
9063        return super.setProperty(name, value);
9064      return value;
9065    }
9066
9067    @Override
9068    public Base makeProperty(int hash, String name) throws FHIRException {
9069      switch (hash) {
9070      case -1422950858:
9071        return addAction();
9072      default:
9073        return super.makeProperty(hash, name);
9074      }
9075
9076    }
9077
9078    @Override
9079    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
9080      switch (hash) {
9081      case -1422950858:
9082        /* action */ return new String[] {};
9083      default:
9084        return super.getTypesForProperty(hash, name);
9085      }
9086
9087    }
9088
9089    @Override
9090    public Base addChild(String name) throws FHIRException {
9091      if (name.equals("action")) {
9092        return addAction();
9093      } else
9094        return super.addChild(name);
9095    }
9096
9097    public TestScriptTeardownComponent copy() {
9098      TestScriptTeardownComponent dst = new TestScriptTeardownComponent();
9099      copyValues(dst);
9100      return dst;
9101    }
9102
9103    public void copyValues(TestScriptTeardownComponent dst) {
9104      super.copyValues(dst);
9105      if (action != null) {
9106        dst.action = new ArrayList<TeardownActionComponent>();
9107        for (TeardownActionComponent i : action)
9108          dst.action.add(i.copy());
9109      }
9110      ;
9111    }
9112
9113    @Override
9114    public boolean equalsDeep(Base other_) {
9115      if (!super.equalsDeep(other_))
9116        return false;
9117      if (!(other_ instanceof TestScriptTeardownComponent))
9118        return false;
9119      TestScriptTeardownComponent o = (TestScriptTeardownComponent) other_;
9120      return compareDeep(action, o.action, true);
9121    }
9122
9123    @Override
9124    public boolean equalsShallow(Base other_) {
9125      if (!super.equalsShallow(other_))
9126        return false;
9127      if (!(other_ instanceof TestScriptTeardownComponent))
9128        return false;
9129      TestScriptTeardownComponent o = (TestScriptTeardownComponent) other_;
9130      return true;
9131    }
9132
9133    public boolean isEmpty() {
9134      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(action);
9135    }
9136
9137    public String fhirType() {
9138      return "TestScript.teardown";
9139
9140    }
9141
9142  }
9143
9144  @Block()
9145  public static class TeardownActionComponent extends BackboneElement implements IBaseBackboneElement {
9146    /**
9147     * An operation would involve a REST request to a server.
9148     */
9149    @Child(name = "operation", type = {
9150        SetupActionOperationComponent.class }, order = 1, min = 1, max = 1, modifier = false, summary = false)
9151    @Description(shortDefinition = "The teardown operation to perform", formalDefinition = "An operation would involve a REST request to a server.")
9152    protected SetupActionOperationComponent operation;
9153
9154    private static final long serialVersionUID = -1099598054L;
9155
9156    /**
9157     * Constructor
9158     */
9159    public TeardownActionComponent() {
9160      super();
9161    }
9162
9163    /**
9164     * Constructor
9165     */
9166    public TeardownActionComponent(SetupActionOperationComponent operation) {
9167      super();
9168      this.operation = operation;
9169    }
9170
9171    /**
9172     * @return {@link #operation} (An operation would involve a REST request to a
9173     *         server.)
9174     */
9175    public SetupActionOperationComponent getOperation() {
9176      if (this.operation == null)
9177        if (Configuration.errorOnAutoCreate())
9178          throw new Error("Attempt to auto-create TeardownActionComponent.operation");
9179        else if (Configuration.doAutoCreate())
9180          this.operation = new SetupActionOperationComponent(); // cc
9181      return this.operation;
9182    }
9183
9184    public boolean hasOperation() {
9185      return this.operation != null && !this.operation.isEmpty();
9186    }
9187
9188    /**
9189     * @param value {@link #operation} (An operation would involve a REST request to
9190     *              a server.)
9191     */
9192    public TeardownActionComponent setOperation(SetupActionOperationComponent value) {
9193      this.operation = value;
9194      return this;
9195    }
9196
9197    protected void listChildren(List<Property> children) {
9198      super.listChildren(children);
9199      children.add(new Property("operation", "@TestScript.setup.action.operation",
9200          "An operation would involve a REST request to a server.", 0, 1, operation));
9201    }
9202
9203    @Override
9204    public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
9205      switch (_hash) {
9206      case 1662702951:
9207        /* operation */ return new Property("operation", "@TestScript.setup.action.operation",
9208            "An operation would involve a REST request to a server.", 0, 1, operation);
9209      default:
9210        return super.getNamedProperty(_hash, _name, _checkValid);
9211      }
9212
9213    }
9214
9215    @Override
9216    public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
9217      switch (hash) {
9218      case 1662702951:
9219        /* operation */ return this.operation == null ? new Base[0] : new Base[] { this.operation }; // SetupActionOperationComponent
9220      default:
9221        return super.getProperty(hash, name, checkValid);
9222      }
9223
9224    }
9225
9226    @Override
9227    public Base setProperty(int hash, String name, Base value) throws FHIRException {
9228      switch (hash) {
9229      case 1662702951: // operation
9230        this.operation = (SetupActionOperationComponent) value; // SetupActionOperationComponent
9231        return value;
9232      default:
9233        return super.setProperty(hash, name, value);
9234      }
9235
9236    }
9237
9238    @Override
9239    public Base setProperty(String name, Base value) throws FHIRException {
9240      if (name.equals("operation")) {
9241        this.operation = (SetupActionOperationComponent) value; // SetupActionOperationComponent
9242      } else
9243        return super.setProperty(name, value);
9244      return value;
9245    }
9246
9247    @Override
9248    public Base makeProperty(int hash, String name) throws FHIRException {
9249      switch (hash) {
9250      case 1662702951:
9251        return getOperation();
9252      default:
9253        return super.makeProperty(hash, name);
9254      }
9255
9256    }
9257
9258    @Override
9259    public String[] getTypesForProperty(int hash, String name) throws FHIRException {
9260      switch (hash) {
9261      case 1662702951:
9262        /* operation */ return new String[] { "@TestScript.setup.action.operation" };
9263      default:
9264        return super.getTypesForProperty(hash, name);
9265      }
9266
9267    }
9268
9269    @Override
9270    public Base addChild(String name) throws FHIRException {
9271      if (name.equals("operation")) {
9272        this.operation = new SetupActionOperationComponent();
9273        return this.operation;
9274      } else
9275        return super.addChild(name);
9276    }
9277
9278    public TeardownActionComponent copy() {
9279      TeardownActionComponent dst = new TeardownActionComponent();
9280      copyValues(dst);
9281      return dst;
9282    }
9283
9284    public void copyValues(TeardownActionComponent dst) {
9285      super.copyValues(dst);
9286      dst.operation = operation == null ? null : operation.copy();
9287    }
9288
9289    @Override
9290    public boolean equalsDeep(Base other_) {
9291      if (!super.equalsDeep(other_))
9292        return false;
9293      if (!(other_ instanceof TeardownActionComponent))
9294        return false;
9295      TeardownActionComponent o = (TeardownActionComponent) other_;
9296      return compareDeep(operation, o.operation, true);
9297    }
9298
9299    @Override
9300    public boolean equalsShallow(Base other_) {
9301      if (!super.equalsShallow(other_))
9302        return false;
9303      if (!(other_ instanceof TeardownActionComponent))
9304        return false;
9305      TeardownActionComponent o = (TeardownActionComponent) other_;
9306      return true;
9307    }
9308
9309    public boolean isEmpty() {
9310      return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(operation);
9311    }
9312
9313    public String fhirType() {
9314      return "TestScript.teardown.action";
9315
9316    }
9317
9318  }
9319
9320  /**
9321   * A formal identifier that is used to identify this test script when it is
9322   * represented in other formats, or referenced in a specification, model, design
9323   * or an instance.
9324   */
9325  @Child(name = "identifier", type = {
9326      Identifier.class }, order = 0, min = 0, max = 1, modifier = false, summary = true)
9327  @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.")
9328  protected Identifier identifier;
9329
9330  /**
9331   * Explanation of why this test script is needed and why it has been designed as
9332   * it has.
9333   */
9334  @Child(name = "purpose", type = {
9335      MarkdownType.class }, order = 1, min = 0, max = 1, modifier = false, summary = false)
9336  @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.")
9337  protected MarkdownType purpose;
9338
9339  /**
9340   * A copyright statement relating to the test script and/or its contents.
9341   * Copyright statements are generally legal restrictions on the use and
9342   * publishing of the test script.
9343   */
9344  @Child(name = "copyright", type = {
9345      MarkdownType.class }, order = 2, min = 0, max = 1, modifier = false, summary = false)
9346  @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.")
9347  protected MarkdownType copyright;
9348
9349  /**
9350   * An abstract server used in operations within this test script in the origin
9351   * element.
9352   */
9353  @Child(name = "origin", type = {}, order = 3, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false)
9354  @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.")
9355  protected List<TestScriptOriginComponent> origin;
9356
9357  /**
9358   * An abstract server used in operations within this test script in the
9359   * destination element.
9360   */
9361  @Child(name = "destination", type = {}, order = 4, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false)
9362  @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.")
9363  protected List<TestScriptDestinationComponent> destination;
9364
9365  /**
9366   * The required capability must exist and are assumed to function correctly on
9367   * the FHIR server being tested.
9368   */
9369  @Child(name = "metadata", type = {}, order = 5, min = 0, max = 1, modifier = false, summary = false)
9370  @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.")
9371  protected TestScriptMetadataComponent metadata;
9372
9373  /**
9374   * Fixture in the test script - by reference (uri). All fixtures are required
9375   * for the test script to execute.
9376   */
9377  @Child(name = "fixture", type = {}, order = 6, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false)
9378  @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.")
9379  protected List<TestScriptFixtureComponent> fixture;
9380
9381  /**
9382   * Reference to the profile to be used for validation.
9383   */
9384  @Child(name = "profile", type = {
9385      Reference.class }, order = 7, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false)
9386  @Description(shortDefinition = "Reference of the validation profile", formalDefinition = "Reference to the profile to be used for validation.")
9387  protected List<Reference> profile;
9388  /**
9389   * The actual objects that are the target of the reference (Reference to the
9390   * profile to be used for validation.)
9391   */
9392  protected List<Resource> profileTarget;
9393
9394  /**
9395   * Variable is set based either on element value in response body or on header
9396   * field value in the response headers.
9397   */
9398  @Child(name = "variable", type = {}, order = 8, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false)
9399  @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.")
9400  protected List<TestScriptVariableComponent> variable;
9401
9402  /**
9403   * A series of required setup operations before tests are executed.
9404   */
9405  @Child(name = "setup", type = {}, order = 9, min = 0, max = 1, modifier = false, summary = false)
9406  @Description(shortDefinition = "A series of required setup operations before tests are executed", formalDefinition = "A series of required setup operations before tests are executed.")
9407  protected TestScriptSetupComponent setup;
9408
9409  /**
9410   * A test in this script.
9411   */
9412  @Child(name = "test", type = {}, order = 10, min = 0, max = Child.MAX_UNLIMITED, modifier = false, summary = false)
9413  @Description(shortDefinition = "A test in this script", formalDefinition = "A test in this script.")
9414  protected List<TestScriptTestComponent> test;
9415
9416  /**
9417   * A series of operations required to clean up after all the tests are executed
9418   * (successfully or otherwise).
9419   */
9420  @Child(name = "teardown", type = {}, order = 11, min = 0, max = 1, modifier = false, summary = false)
9421  @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).")
9422  protected TestScriptTeardownComponent teardown;
9423
9424  private static final long serialVersionUID = -1433230137L;
9425
9426  /**
9427   * Constructor
9428   */
9429  public TestScript() {
9430    super();
9431  }
9432
9433  /**
9434   * Constructor
9435   */
9436  public TestScript(UriType url, StringType name, Enumeration<PublicationStatus> status) {
9437    super();
9438    this.url = url;
9439    this.name = name;
9440    this.status = status;
9441  }
9442
9443  /**
9444   * @return {@link #url} (An absolute URI that is used to identify this test
9445   *         script when it is referenced in a specification, model, design or an
9446   *         instance; also called its canonical identifier. This SHOULD be
9447   *         globally unique and SHOULD be a literal address at which at which an
9448   *         authoritative instance of this test script is (or will be) published.
9449   *         This URL can be the target of a canonical reference. It SHALL remain
9450   *         the same when the test script is stored on different servers.). This
9451   *         is the underlying object with id, value and extensions. The accessor
9452   *         "getUrl" gives direct access to the value
9453   */
9454  public UriType getUrlElement() {
9455    if (this.url == null)
9456      if (Configuration.errorOnAutoCreate())
9457        throw new Error("Attempt to auto-create TestScript.url");
9458      else if (Configuration.doAutoCreate())
9459        this.url = new UriType(); // bb
9460    return this.url;
9461  }
9462
9463  public boolean hasUrlElement() {
9464    return this.url != null && !this.url.isEmpty();
9465  }
9466
9467  public boolean hasUrl() {
9468    return this.url != null && !this.url.isEmpty();
9469  }
9470
9471  /**
9472   * @param value {@link #url} (An absolute URI that is used to identify this test
9473   *              script when it is referenced in a specification, model, design
9474   *              or an instance; also called its canonical identifier. This
9475   *              SHOULD be globally unique and SHOULD be a literal address at
9476   *              which at which an authoritative instance of this test script is
9477   *              (or will be) published. This URL can be the target of a
9478   *              canonical reference. It SHALL remain the same when the test
9479   *              script is stored on different servers.). This is the underlying
9480   *              object with id, value and extensions. The accessor "getUrl"
9481   *              gives direct access to the value
9482   */
9483  public TestScript setUrlElement(UriType value) {
9484    this.url = value;
9485    return this;
9486  }
9487
9488  /**
9489   * @return An absolute URI that is used to identify this test script when it is
9490   *         referenced in a specification, model, design or an instance; also
9491   *         called its canonical identifier. This SHOULD be globally unique and
9492   *         SHOULD be a literal address at which at which an authoritative
9493   *         instance of this test script is (or will be) published. This URL can
9494   *         be the target of a canonical reference. It SHALL remain the same when
9495   *         the test script is stored on different servers.
9496   */
9497  public String getUrl() {
9498    return this.url == null ? null : this.url.getValue();
9499  }
9500
9501  /**
9502   * @param value An absolute URI that is used to identify this test script when
9503   *              it is referenced in a specification, model, design or an
9504   *              instance; also called its canonical identifier. This SHOULD be
9505   *              globally unique and SHOULD be a literal address at which at
9506   *              which an authoritative instance of this test script is (or will
9507   *              be) published. This URL can be the target of a canonical
9508   *              reference. It SHALL remain the same when the test script is
9509   *              stored on different servers.
9510   */
9511  public TestScript setUrl(String value) {
9512    if (this.url == null)
9513      this.url = new UriType();
9514    this.url.setValue(value);
9515    return this;
9516  }
9517
9518  /**
9519   * @return {@link #identifier} (A formal identifier that is used to identify
9520   *         this test script when it is represented in other formats, or
9521   *         referenced in a specification, model, design or an instance.)
9522   */
9523  public Identifier getIdentifier() {
9524    if (this.identifier == null)
9525      if (Configuration.errorOnAutoCreate())
9526        throw new Error("Attempt to auto-create TestScript.identifier");
9527      else if (Configuration.doAutoCreate())
9528        this.identifier = new Identifier(); // cc
9529    return this.identifier;
9530  }
9531
9532  public boolean hasIdentifier() {
9533    return this.identifier != null && !this.identifier.isEmpty();
9534  }
9535
9536  /**
9537   * @param value {@link #identifier} (A formal identifier that is used to
9538   *              identify this test script when it is represented in other
9539   *              formats, or referenced in a specification, model, design or an
9540   *              instance.)
9541   */
9542  public TestScript setIdentifier(Identifier value) {
9543    this.identifier = value;
9544    return this;
9545  }
9546
9547  /**
9548   * @return {@link #version} (The identifier that is used to identify this
9549   *         version of the test script when it is referenced in a specification,
9550   *         model, design or instance. This is an arbitrary value managed by the
9551   *         test script author and is not expected to be globally unique. For
9552   *         example, it might be a timestamp (e.g. yyyymmdd) if a managed version
9553   *         is not available. There is also no expectation that versions can be
9554   *         placed in a lexicographical sequence.). This is the underlying object
9555   *         with id, value and extensions. The accessor "getVersion" gives direct
9556   *         access to the value
9557   */
9558  public StringType getVersionElement() {
9559    if (this.version == null)
9560      if (Configuration.errorOnAutoCreate())
9561        throw new Error("Attempt to auto-create TestScript.version");
9562      else if (Configuration.doAutoCreate())
9563        this.version = new StringType(); // bb
9564    return this.version;
9565  }
9566
9567  public boolean hasVersionElement() {
9568    return this.version != null && !this.version.isEmpty();
9569  }
9570
9571  public boolean hasVersion() {
9572    return this.version != null && !this.version.isEmpty();
9573  }
9574
9575  /**
9576   * @param value {@link #version} (The identifier that is used to identify this
9577   *              version of the test script when it is referenced in a
9578   *              specification, model, design or instance. This is an arbitrary
9579   *              value managed by the test script author and is not expected to
9580   *              be globally unique. For example, it might be a timestamp (e.g.
9581   *              yyyymmdd) if a managed version is not available. There is also
9582   *              no expectation that versions can be placed in a lexicographical
9583   *              sequence.). This is the underlying object with id, value and
9584   *              extensions. The accessor "getVersion" gives direct access to the
9585   *              value
9586   */
9587  public TestScript setVersionElement(StringType value) {
9588    this.version = value;
9589    return this;
9590  }
9591
9592  /**
9593   * @return The identifier that is used to identify this version of the test
9594   *         script when it is referenced in a specification, model, design or
9595   *         instance. This is an arbitrary value managed by the test script
9596   *         author and is not expected to be globally unique. For example, it
9597   *         might be a timestamp (e.g. yyyymmdd) if a managed version is not
9598   *         available. There is also no expectation that versions can be placed
9599   *         in a lexicographical sequence.
9600   */
9601  public String getVersion() {
9602    return this.version == null ? null : this.version.getValue();
9603  }
9604
9605  /**
9606   * @param value The identifier that is used to identify this version of the test
9607   *              script when it is referenced in a specification, model, design
9608   *              or instance. This is an arbitrary value managed by the test
9609   *              script author and is not expected to be globally unique. For
9610   *              example, it might be a timestamp (e.g. yyyymmdd) if a managed
9611   *              version is not available. There is also no expectation that
9612   *              versions can be placed in a lexicographical sequence.
9613   */
9614  public TestScript setVersion(String value) {
9615    if (Utilities.noString(value))
9616      this.version = null;
9617    else {
9618      if (this.version == null)
9619        this.version = new StringType();
9620      this.version.setValue(value);
9621    }
9622    return this;
9623  }
9624
9625  /**
9626   * @return {@link #name} (A natural language name identifying the test script.
9627   *         This name should be usable as an identifier for the module by machine
9628   *         processing applications such as code generation.). This is the
9629   *         underlying object with id, value and extensions. The accessor
9630   *         "getName" gives direct access to the value
9631   */
9632  public StringType getNameElement() {
9633    if (this.name == null)
9634      if (Configuration.errorOnAutoCreate())
9635        throw new Error("Attempt to auto-create TestScript.name");
9636      else if (Configuration.doAutoCreate())
9637        this.name = new StringType(); // bb
9638    return this.name;
9639  }
9640
9641  public boolean hasNameElement() {
9642    return this.name != null && !this.name.isEmpty();
9643  }
9644
9645  public boolean hasName() {
9646    return this.name != null && !this.name.isEmpty();
9647  }
9648
9649  /**
9650   * @param value {@link #name} (A natural language name identifying the test
9651   *              script. This name should be usable as an identifier for the
9652   *              module by machine processing applications such as code
9653   *              generation.). This is the underlying object with id, value and
9654   *              extensions. The accessor "getName" gives direct access to the
9655   *              value
9656   */
9657  public TestScript setNameElement(StringType value) {
9658    this.name = value;
9659    return this;
9660  }
9661
9662  /**
9663   * @return A natural language name identifying the test script. This name should
9664   *         be usable as an identifier for the module by machine processing
9665   *         applications such as code generation.
9666   */
9667  public String getName() {
9668    return this.name == null ? null : this.name.getValue();
9669  }
9670
9671  /**
9672   * @param value A natural language name identifying the test script. This name
9673   *              should be usable as an identifier for the module by machine
9674   *              processing applications such as code generation.
9675   */
9676  public TestScript setName(String value) {
9677    if (this.name == null)
9678      this.name = new StringType();
9679    this.name.setValue(value);
9680    return this;
9681  }
9682
9683  /**
9684   * @return {@link #title} (A short, descriptive, user-friendly title for the
9685   *         test script.). This is the underlying object with id, value and
9686   *         extensions. The accessor "getTitle" gives direct access to the value
9687   */
9688  public StringType getTitleElement() {
9689    if (this.title == null)
9690      if (Configuration.errorOnAutoCreate())
9691        throw new Error("Attempt to auto-create TestScript.title");
9692      else if (Configuration.doAutoCreate())
9693        this.title = new StringType(); // bb
9694    return this.title;
9695  }
9696
9697  public boolean hasTitleElement() {
9698    return this.title != null && !this.title.isEmpty();
9699  }
9700
9701  public boolean hasTitle() {
9702    return this.title != null && !this.title.isEmpty();
9703  }
9704
9705  /**
9706   * @param value {@link #title} (A short, descriptive, user-friendly title for
9707   *              the test script.). This is the underlying object with id, value
9708   *              and extensions. The accessor "getTitle" gives direct access to
9709   *              the value
9710   */
9711  public TestScript setTitleElement(StringType value) {
9712    this.title = value;
9713    return this;
9714  }
9715
9716  /**
9717   * @return A short, descriptive, user-friendly title for the test script.
9718   */
9719  public String getTitle() {
9720    return this.title == null ? null : this.title.getValue();
9721  }
9722
9723  /**
9724   * @param value A short, descriptive, user-friendly title for the test script.
9725   */
9726  public TestScript setTitle(String value) {
9727    if (Utilities.noString(value))
9728      this.title = null;
9729    else {
9730      if (this.title == null)
9731        this.title = new StringType();
9732      this.title.setValue(value);
9733    }
9734    return this;
9735  }
9736
9737  /**
9738   * @return {@link #status} (The status of this test script. Enables tracking the
9739   *         life-cycle of the content.). This is the underlying object with id,
9740   *         value and extensions. The accessor "getStatus" gives direct access to
9741   *         the value
9742   */
9743  public Enumeration<PublicationStatus> getStatusElement() {
9744    if (this.status == null)
9745      if (Configuration.errorOnAutoCreate())
9746        throw new Error("Attempt to auto-create TestScript.status");
9747      else if (Configuration.doAutoCreate())
9748        this.status = new Enumeration<PublicationStatus>(new PublicationStatusEnumFactory()); // bb
9749    return this.status;
9750  }
9751
9752  public boolean hasStatusElement() {
9753    return this.status != null && !this.status.isEmpty();
9754  }
9755
9756  public boolean hasStatus() {
9757    return this.status != null && !this.status.isEmpty();
9758  }
9759
9760  /**
9761   * @param value {@link #status} (The status of this test script. Enables
9762   *              tracking the life-cycle of the content.). This is the underlying
9763   *              object with id, value and extensions. The accessor "getStatus"
9764   *              gives direct access to the value
9765   */