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