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