001package org.hl7.fhir.dstu3.model;
002
003
004
005
006/*
007  Copyright (c) 2011+, HL7, Inc.
008  All rights reserved.
009  
010  Redistribution and use in source and binary forms, with or without modification, 
011  are permitted provided that the following conditions are met:
012  
013   * Redistributions of source code must retain the above copyright notice, this 
014     list of conditions and the following disclaimer.
015   * Redistributions in binary form must reproduce the above copyright notice, 
016     this list of conditions and the following disclaimer in the documentation 
017     and/or other materials provided with the distribution.
018   * Neither the name of HL7 nor the names of its contributors may be used to 
019     endorse or promote products derived from this software without specific 
020     prior written permission.
021  
022  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
023  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
024  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
025  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
026  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
027  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
028  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
029  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
030  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
031  POSSIBILITY OF SUCH DAMAGE.
032  
033*/
034
035// Generated on Fri, Mar 16, 2018 15:21+1100 for FHIR v3.0.x
036import java.util.ArrayList;
037import java.util.Date;
038import java.util.List;
039
040import org.hl7.fhir.exceptions.FHIRException;
041import org.hl7.fhir.exceptions.FHIRFormatError;
042import org.hl7.fhir.instance.model.api.IBaseBackboneElement;
043import org.hl7.fhir.utilities.Utilities;
044
045import ca.uhn.fhir.model.api.annotation.Block;
046import ca.uhn.fhir.model.api.annotation.Child;
047import ca.uhn.fhir.model.api.annotation.Description;
048import ca.uhn.fhir.model.api.annotation.ResourceDef;
049import ca.uhn.fhir.model.api.annotation.SearchParamDefinition;
050/**
051 * A group of related requests that can be used to capture intended activities that have inter-dependencies such as "give this medication after that one".
052 */
053@ResourceDef(name="RequestGroup", profile="http://hl7.org/fhir/Profile/RequestGroup")
054public class RequestGroup extends DomainResource {
055
056    public enum RequestStatus {
057        /**
058         * The request has been created but is not yet complete or ready for action
059         */
060        DRAFT, 
061        /**
062         * The request is ready to be acted upon
063         */
064        ACTIVE, 
065        /**
066         * The authorization/request to act has been temporarily withdrawn but is expected to resume in the future
067         */
068        SUSPENDED, 
069        /**
070         * The authorization/request to act has been terminated prior to the full completion of the intended actions.  No further activity should occur.
071         */
072        CANCELLED, 
073        /**
074         * Activity against the request has been sufficiently completed to the satisfaction of the requester
075         */
076        COMPLETED, 
077        /**
078         * This electronic record should never have existed, though it is possible that real-world decisions were based on it.  (If real-world activity has occurred, the status should be "cancelled" rather than "entered-in-error".)
079         */
080        ENTEREDINERROR, 
081        /**
082         * The authoring system does not know which of the status values currently applies for this request.  Note: This concept is not to be used for "other" . One of the listed statuses is presumed to apply,  but the system creating the request doesn't know.
083         */
084        UNKNOWN, 
085        /**
086         * added to help the parsers with the generic types
087         */
088        NULL;
089        public static RequestStatus fromCode(String codeString) throws FHIRException {
090            if (codeString == null || "".equals(codeString))
091                return null;
092        if ("draft".equals(codeString))
093          return DRAFT;
094        if ("active".equals(codeString))
095          return ACTIVE;
096        if ("suspended".equals(codeString))
097          return SUSPENDED;
098        if ("cancelled".equals(codeString))
099          return CANCELLED;
100        if ("completed".equals(codeString))
101          return COMPLETED;
102        if ("entered-in-error".equals(codeString))
103          return ENTEREDINERROR;
104        if ("unknown".equals(codeString))
105          return UNKNOWN;
106        if (Configuration.isAcceptInvalidEnums())
107          return null;
108        else
109          throw new FHIRException("Unknown RequestStatus code '"+codeString+"'");
110        }
111        public String toCode() {
112          switch (this) {
113            case DRAFT: return "draft";
114            case ACTIVE: return "active";
115            case SUSPENDED: return "suspended";
116            case CANCELLED: return "cancelled";
117            case COMPLETED: return "completed";
118            case ENTEREDINERROR: return "entered-in-error";
119            case UNKNOWN: return "unknown";
120            case NULL: return null;
121            default: return "?";
122          }
123        }
124        public String getSystem() {
125          switch (this) {
126            case DRAFT: return "http://hl7.org/fhir/request-status";
127            case ACTIVE: return "http://hl7.org/fhir/request-status";
128            case SUSPENDED: return "http://hl7.org/fhir/request-status";
129            case CANCELLED: return "http://hl7.org/fhir/request-status";
130            case COMPLETED: return "http://hl7.org/fhir/request-status";
131            case ENTEREDINERROR: return "http://hl7.org/fhir/request-status";
132            case UNKNOWN: return "http://hl7.org/fhir/request-status";
133            case NULL: return null;
134            default: return "?";
135          }
136        }
137        public String getDefinition() {
138          switch (this) {
139            case DRAFT: return "The request has been created but is not yet complete or ready for action";
140            case ACTIVE: return "The request is ready to be acted upon";
141            case SUSPENDED: return "The authorization/request to act has been temporarily withdrawn but is expected to resume in the future";
142            case CANCELLED: return "The authorization/request to act has been terminated prior to the full completion of the intended actions.  No further activity should occur.";
143            case COMPLETED: return "Activity against the request has been sufficiently completed to the satisfaction of the requester";
144            case ENTEREDINERROR: return "This electronic record should never have existed, though it is possible that real-world decisions were based on it.  (If real-world activity has occurred, the status should be \"cancelled\" rather than \"entered-in-error\".)";
145            case UNKNOWN: return "The authoring system does not know which of the status values currently applies for this request.  Note: This concept is not to be used for \"other\" . One of the listed statuses is presumed to apply,  but the system creating the request doesn't know.";
146            case NULL: return null;
147            default: return "?";
148          }
149        }
150        public String getDisplay() {
151          switch (this) {
152            case DRAFT: return "Draft";
153            case ACTIVE: return "Active";
154            case SUSPENDED: return "Suspended";
155            case CANCELLED: return "Cancelled";
156            case COMPLETED: return "Completed";
157            case ENTEREDINERROR: return "Entered in Error";
158            case UNKNOWN: return "Unknown";
159            case NULL: return null;
160            default: return "?";
161          }
162        }
163    }
164
165  public static class RequestStatusEnumFactory implements EnumFactory<RequestStatus> {
166    public RequestStatus fromCode(String codeString) throws IllegalArgumentException {
167      if (codeString == null || "".equals(codeString))
168            if (codeString == null || "".equals(codeString))
169                return null;
170        if ("draft".equals(codeString))
171          return RequestStatus.DRAFT;
172        if ("active".equals(codeString))
173          return RequestStatus.ACTIVE;
174        if ("suspended".equals(codeString))
175          return RequestStatus.SUSPENDED;
176        if ("cancelled".equals(codeString))
177          return RequestStatus.CANCELLED;
178        if ("completed".equals(codeString))
179          return RequestStatus.COMPLETED;
180        if ("entered-in-error".equals(codeString))
181          return RequestStatus.ENTEREDINERROR;
182        if ("unknown".equals(codeString))
183          return RequestStatus.UNKNOWN;
184        throw new IllegalArgumentException("Unknown RequestStatus code '"+codeString+"'");
185        }
186        public Enumeration<RequestStatus> fromType(Base code) throws FHIRException {
187          if (code == null)
188            return null;
189          if (code.isEmpty())
190            return new Enumeration<RequestStatus>(this);
191          String codeString = ((PrimitiveType) code).asStringValue();
192          if (codeString == null || "".equals(codeString))
193            return null;
194        if ("draft".equals(codeString))
195          return new Enumeration<RequestStatus>(this, RequestStatus.DRAFT);
196        if ("active".equals(codeString))
197          return new Enumeration<RequestStatus>(this, RequestStatus.ACTIVE);
198        if ("suspended".equals(codeString))
199          return new Enumeration<RequestStatus>(this, RequestStatus.SUSPENDED);
200        if ("cancelled".equals(codeString))
201          return new Enumeration<RequestStatus>(this, RequestStatus.CANCELLED);
202        if ("completed".equals(codeString))
203          return new Enumeration<RequestStatus>(this, RequestStatus.COMPLETED);
204        if ("entered-in-error".equals(codeString))
205          return new Enumeration<RequestStatus>(this, RequestStatus.ENTEREDINERROR);
206        if ("unknown".equals(codeString))
207          return new Enumeration<RequestStatus>(this, RequestStatus.UNKNOWN);
208        throw new FHIRException("Unknown RequestStatus code '"+codeString+"'");
209        }
210    public String toCode(RequestStatus code) {
211      if (code == RequestStatus.DRAFT)
212        return "draft";
213      if (code == RequestStatus.ACTIVE)
214        return "active";
215      if (code == RequestStatus.SUSPENDED)
216        return "suspended";
217      if (code == RequestStatus.CANCELLED)
218        return "cancelled";
219      if (code == RequestStatus.COMPLETED)
220        return "completed";
221      if (code == RequestStatus.ENTEREDINERROR)
222        return "entered-in-error";
223      if (code == RequestStatus.UNKNOWN)
224        return "unknown";
225      return "?";
226      }
227    public String toSystem(RequestStatus code) {
228      return code.getSystem();
229      }
230    }
231
232    public enum RequestIntent {
233        /**
234         * The request is a suggestion made by someone/something that doesn't have an intention to ensure it occurs and without providing an authorization to act
235         */
236        PROPOSAL, 
237        /**
238         * The request represents an intension to ensure something occurs without providing an authorization for others to act
239         */
240        PLAN, 
241        /**
242         * The request represents a request/demand and authorization for action
243         */
244        ORDER, 
245        /**
246         * The request represents an original authorization for action
247         */
248        ORIGINALORDER, 
249        /**
250         * The request represents an automatically generated supplemental authorization for action based on a parent authorization together with initial results of the action taken against that parent authorization
251         */
252        REFLEXORDER, 
253        /**
254         * The request represents the view of an authorization instantiated by a fulfilling system representing the details of the fulfiller's intention to act upon a submitted order
255         */
256        FILLERORDER, 
257        /**
258         * An order created in fulfillment of a broader order that represents the authorization for a single activity occurrence.  E.g. The administration of a single dose of a drug.
259         */
260        INSTANCEORDER, 
261        /**
262         * The request represents a component or option for a RequestGroup that establishes timing, conditionality and/or other constraints among a set of requests.
263
264Refer to [[[RequestGroup]]] for additional information on how this status is used
265         */
266        OPTION, 
267        /**
268         * added to help the parsers with the generic types
269         */
270        NULL;
271        public static RequestIntent fromCode(String codeString) throws FHIRException {
272            if (codeString == null || "".equals(codeString))
273                return null;
274        if ("proposal".equals(codeString))
275          return PROPOSAL;
276        if ("plan".equals(codeString))
277          return PLAN;
278        if ("order".equals(codeString))
279          return ORDER;
280        if ("original-order".equals(codeString))
281          return ORIGINALORDER;
282        if ("reflex-order".equals(codeString))
283          return REFLEXORDER;
284        if ("filler-order".equals(codeString))
285          return FILLERORDER;
286        if ("instance-order".equals(codeString))
287          return INSTANCEORDER;
288        if ("option".equals(codeString))
289          return OPTION;
290        if (Configuration.isAcceptInvalidEnums())
291          return null;
292        else
293          throw new FHIRException("Unknown RequestIntent code '"+codeString+"'");
294        }
295        public String toCode() {
296          switch (this) {
297            case PROPOSAL: return "proposal";
298            case PLAN: return "plan";
299            case ORDER: return "order";
300            case ORIGINALORDER: return "original-order";
301            case REFLEXORDER: return "reflex-order";
302            case FILLERORDER: return "filler-order";
303            case INSTANCEORDER: return "instance-order";
304            case OPTION: return "option";
305            case NULL: return null;
306            default: return "?";
307          }
308        }
309        public String getSystem() {
310          switch (this) {
311            case PROPOSAL: return "http://hl7.org/fhir/request-intent";
312            case PLAN: return "http://hl7.org/fhir/request-intent";
313            case ORDER: return "http://hl7.org/fhir/request-intent";
314            case ORIGINALORDER: return "http://hl7.org/fhir/request-intent";
315            case REFLEXORDER: return "http://hl7.org/fhir/request-intent";
316            case FILLERORDER: return "http://hl7.org/fhir/request-intent";
317            case INSTANCEORDER: return "http://hl7.org/fhir/request-intent";
318            case OPTION: return "http://hl7.org/fhir/request-intent";
319            case NULL: return null;
320            default: return "?";
321          }
322        }
323        public String getDefinition() {
324          switch (this) {
325            case PROPOSAL: return "The request is a suggestion made by someone/something that doesn't have an intention to ensure it occurs and without providing an authorization to act";
326            case PLAN: return "The request represents an intension to ensure something occurs without providing an authorization for others to act";
327            case ORDER: return "The request represents a request/demand and authorization for action";
328            case ORIGINALORDER: return "The request represents an original authorization for action";
329            case REFLEXORDER: return "The request represents an automatically generated supplemental authorization for action based on a parent authorization together with initial results of the action taken against that parent authorization";
330            case FILLERORDER: return "The request represents the view of an authorization instantiated by a fulfilling system representing the details of the fulfiller's intention to act upon a submitted order";
331            case INSTANCEORDER: return "An order created in fulfillment of a broader order that represents the authorization for a single activity occurrence.  E.g. The administration of a single dose of a drug.";
332            case OPTION: return "The request represents a component or option for a RequestGroup that establishes timing, conditionality and/or other constraints among a set of requests.\n\nRefer to [[[RequestGroup]]] for additional information on how this status is used";
333            case NULL: return null;
334            default: return "?";
335          }
336        }
337        public String getDisplay() {
338          switch (this) {
339            case PROPOSAL: return "Proposal";
340            case PLAN: return "Plan";
341            case ORDER: return "Order";
342            case ORIGINALORDER: return "Original Order";
343            case REFLEXORDER: return "Reflex Order";
344            case FILLERORDER: return "Filler Order";
345            case INSTANCEORDER: return "Instance Order";
346            case OPTION: return "Option";
347            case NULL: return null;
348            default: return "?";
349          }
350        }
351    }
352
353  public static class RequestIntentEnumFactory implements EnumFactory<RequestIntent> {
354    public RequestIntent fromCode(String codeString) throws IllegalArgumentException {
355      if (codeString == null || "".equals(codeString))
356            if (codeString == null || "".equals(codeString))
357                return null;
358        if ("proposal".equals(codeString))
359          return RequestIntent.PROPOSAL;
360        if ("plan".equals(codeString))
361          return RequestIntent.PLAN;
362        if ("order".equals(codeString))
363          return RequestIntent.ORDER;
364        if ("original-order".equals(codeString))
365          return RequestIntent.ORIGINALORDER;
366        if ("reflex-order".equals(codeString))
367          return RequestIntent.REFLEXORDER;
368        if ("filler-order".equals(codeString))
369          return RequestIntent.FILLERORDER;
370        if ("instance-order".equals(codeString))
371          return RequestIntent.INSTANCEORDER;
372        if ("option".equals(codeString))
373          return RequestIntent.OPTION;
374        throw new IllegalArgumentException("Unknown RequestIntent code '"+codeString+"'");
375        }
376        public Enumeration<RequestIntent> fromType(Base code) throws FHIRException {
377          if (code == null)
378            return null;
379          if (code.isEmpty())
380            return new Enumeration<RequestIntent>(this);
381          String codeString = ((PrimitiveType) code).asStringValue();
382          if (codeString == null || "".equals(codeString))
383            return null;
384        if ("proposal".equals(codeString))
385          return new Enumeration<RequestIntent>(this, RequestIntent.PROPOSAL);
386        if ("plan".equals(codeString))
387          return new Enumeration<RequestIntent>(this, RequestIntent.PLAN);
388        if ("order".equals(codeString))
389          return new Enumeration<RequestIntent>(this, RequestIntent.ORDER);
390        if ("original-order".equals(codeString))
391          return new Enumeration<RequestIntent>(this, RequestIntent.ORIGINALORDER);
392        if ("reflex-order".equals(codeString))
393          return new Enumeration<RequestIntent>(this, RequestIntent.REFLEXORDER);
394        if ("filler-order".equals(codeString))
395          return new Enumeration<RequestIntent>(this, RequestIntent.FILLERORDER);
396        if ("instance-order".equals(codeString))
397          return new Enumeration<RequestIntent>(this, RequestIntent.INSTANCEORDER);
398        if ("option".equals(codeString))
399          return new Enumeration<RequestIntent>(this, RequestIntent.OPTION);
400        throw new FHIRException("Unknown RequestIntent code '"+codeString+"'");
401        }
402    public String toCode(RequestIntent code) {
403      if (code == RequestIntent.PROPOSAL)
404        return "proposal";
405      if (code == RequestIntent.PLAN)
406        return "plan";
407      if (code == RequestIntent.ORDER)
408        return "order";
409      if (code == RequestIntent.ORIGINALORDER)
410        return "original-order";
411      if (code == RequestIntent.REFLEXORDER)
412        return "reflex-order";
413      if (code == RequestIntent.FILLERORDER)
414        return "filler-order";
415      if (code == RequestIntent.INSTANCEORDER)
416        return "instance-order";
417      if (code == RequestIntent.OPTION)
418        return "option";
419      return "?";
420      }
421    public String toSystem(RequestIntent code) {
422      return code.getSystem();
423      }
424    }
425
426    public enum RequestPriority {
427        /**
428         * The request has normal priority
429         */
430        ROUTINE, 
431        /**
432         * The request should be actioned promptly - higher priority than routine
433         */
434        URGENT, 
435        /**
436         * The request should be actioned as soon as possible - higher priority than urgent
437         */
438        ASAP, 
439        /**
440         * The request should be actioned immediately - highest possible priority.  E.g. an emergency
441         */
442        STAT, 
443        /**
444         * added to help the parsers with the generic types
445         */
446        NULL;
447        public static RequestPriority fromCode(String codeString) throws FHIRException {
448            if (codeString == null || "".equals(codeString))
449                return null;
450        if ("routine".equals(codeString))
451          return ROUTINE;
452        if ("urgent".equals(codeString))
453          return URGENT;
454        if ("asap".equals(codeString))
455          return ASAP;
456        if ("stat".equals(codeString))
457          return STAT;
458        if (Configuration.isAcceptInvalidEnums())
459          return null;
460        else
461          throw new FHIRException("Unknown RequestPriority code '"+codeString+"'");
462        }
463        public String toCode() {
464          switch (this) {
465            case ROUTINE: return "routine";
466            case URGENT: return "urgent";
467            case ASAP: return "asap";
468            case STAT: return "stat";
469            case NULL: return null;
470            default: return "?";
471          }
472        }
473        public String getSystem() {
474          switch (this) {
475            case ROUTINE: return "http://hl7.org/fhir/request-priority";
476            case URGENT: return "http://hl7.org/fhir/request-priority";
477            case ASAP: return "http://hl7.org/fhir/request-priority";
478            case STAT: return "http://hl7.org/fhir/request-priority";
479            case NULL: return null;
480            default: return "?";
481          }
482        }
483        public String getDefinition() {
484          switch (this) {
485            case ROUTINE: return "The request has normal priority";
486            case URGENT: return "The request should be actioned promptly - higher priority than routine";
487            case ASAP: return "The request should be actioned as soon as possible - higher priority than urgent";
488            case STAT: return "The request should be actioned immediately - highest possible priority.  E.g. an emergency";
489            case NULL: return null;
490            default: return "?";
491          }
492        }
493        public String getDisplay() {
494          switch (this) {
495            case ROUTINE: return "Routine";
496            case URGENT: return "Urgent";
497            case ASAP: return "ASAP";
498            case STAT: return "STAT";
499            case NULL: return null;
500            default: return "?";
501          }
502        }
503    }
504
505  public static class RequestPriorityEnumFactory implements EnumFactory<RequestPriority> {
506    public RequestPriority fromCode(String codeString) throws IllegalArgumentException {
507      if (codeString == null || "".equals(codeString))
508            if (codeString == null || "".equals(codeString))
509                return null;
510        if ("routine".equals(codeString))
511          return RequestPriority.ROUTINE;
512        if ("urgent".equals(codeString))
513          return RequestPriority.URGENT;
514        if ("asap".equals(codeString))
515          return RequestPriority.ASAP;
516        if ("stat".equals(codeString))
517          return RequestPriority.STAT;
518        throw new IllegalArgumentException("Unknown RequestPriority code '"+codeString+"'");
519        }
520        public Enumeration<RequestPriority> fromType(Base code) throws FHIRException {
521          if (code == null)
522            return null;
523          if (code.isEmpty())
524            return new Enumeration<RequestPriority>(this);
525          String codeString = ((PrimitiveType) code).asStringValue();
526          if (codeString == null || "".equals(codeString))
527            return null;
528        if ("routine".equals(codeString))
529          return new Enumeration<RequestPriority>(this, RequestPriority.ROUTINE);
530        if ("urgent".equals(codeString))
531          return new Enumeration<RequestPriority>(this, RequestPriority.URGENT);
532        if ("asap".equals(codeString))
533          return new Enumeration<RequestPriority>(this, RequestPriority.ASAP);
534        if ("stat".equals(codeString))
535          return new Enumeration<RequestPriority>(this, RequestPriority.STAT);
536        throw new FHIRException("Unknown RequestPriority code '"+codeString+"'");
537        }
538    public String toCode(RequestPriority code) {
539      if (code == RequestPriority.ROUTINE)
540        return "routine";
541      if (code == RequestPriority.URGENT)
542        return "urgent";
543      if (code == RequestPriority.ASAP)
544        return "asap";
545      if (code == RequestPriority.STAT)
546        return "stat";
547      return "?";
548      }
549    public String toSystem(RequestPriority code) {
550      return code.getSystem();
551      }
552    }
553
554    public enum ActionConditionKind {
555        /**
556         * The condition describes whether or not a given action is applicable
557         */
558        APPLICABILITY, 
559        /**
560         * The condition is a starting condition for the action
561         */
562        START, 
563        /**
564         * The condition is a stop, or exit condition for the action
565         */
566        STOP, 
567        /**
568         * added to help the parsers with the generic types
569         */
570        NULL;
571        public static ActionConditionKind fromCode(String codeString) throws FHIRException {
572            if (codeString == null || "".equals(codeString))
573                return null;
574        if ("applicability".equals(codeString))
575          return APPLICABILITY;
576        if ("start".equals(codeString))
577          return START;
578        if ("stop".equals(codeString))
579          return STOP;
580        if (Configuration.isAcceptInvalidEnums())
581          return null;
582        else
583          throw new FHIRException("Unknown ActionConditionKind code '"+codeString+"'");
584        }
585        public String toCode() {
586          switch (this) {
587            case APPLICABILITY: return "applicability";
588            case START: return "start";
589            case STOP: return "stop";
590            case NULL: return null;
591            default: return "?";
592          }
593        }
594        public String getSystem() {
595          switch (this) {
596            case APPLICABILITY: return "http://hl7.org/fhir/action-condition-kind";
597            case START: return "http://hl7.org/fhir/action-condition-kind";
598            case STOP: return "http://hl7.org/fhir/action-condition-kind";
599            case NULL: return null;
600            default: return "?";
601          }
602        }
603        public String getDefinition() {
604          switch (this) {
605            case APPLICABILITY: return "The condition describes whether or not a given action is applicable";
606            case START: return "The condition is a starting condition for the action";
607            case STOP: return "The condition is a stop, or exit condition for the action";
608            case NULL: return null;
609            default: return "?";
610          }
611        }
612        public String getDisplay() {
613          switch (this) {
614            case APPLICABILITY: return "Applicability";
615            case START: return "Start";
616            case STOP: return "Stop";
617            case NULL: return null;
618            default: return "?";
619          }
620        }
621    }
622
623  public static class ActionConditionKindEnumFactory implements EnumFactory<ActionConditionKind> {
624    public ActionConditionKind fromCode(String codeString) throws IllegalArgumentException {
625      if (codeString == null || "".equals(codeString))
626            if (codeString == null || "".equals(codeString))
627                return null;
628        if ("applicability".equals(codeString))
629          return ActionConditionKind.APPLICABILITY;
630        if ("start".equals(codeString))
631          return ActionConditionKind.START;
632        if ("stop".equals(codeString))
633          return ActionConditionKind.STOP;
634        throw new IllegalArgumentException("Unknown ActionConditionKind code '"+codeString+"'");
635        }
636        public Enumeration<ActionConditionKind> fromType(Base code) throws FHIRException {
637          if (code == null)
638            return null;
639          if (code.isEmpty())
640            return new Enumeration<ActionConditionKind>(this);
641          String codeString = ((PrimitiveType) code).asStringValue();
642          if (codeString == null || "".equals(codeString))
643            return null;
644        if ("applicability".equals(codeString))
645          return new Enumeration<ActionConditionKind>(this, ActionConditionKind.APPLICABILITY);
646        if ("start".equals(codeString))
647          return new Enumeration<ActionConditionKind>(this, ActionConditionKind.START);
648        if ("stop".equals(codeString))
649          return new Enumeration<ActionConditionKind>(this, ActionConditionKind.STOP);
650        throw new FHIRException("Unknown ActionConditionKind code '"+codeString+"'");
651        }
652    public String toCode(ActionConditionKind code) {
653      if (code == ActionConditionKind.APPLICABILITY)
654        return "applicability";
655      if (code == ActionConditionKind.START)
656        return "start";
657      if (code == ActionConditionKind.STOP)
658        return "stop";
659      return "?";
660      }
661    public String toSystem(ActionConditionKind code) {
662      return code.getSystem();
663      }
664    }
665
666    public enum ActionRelationshipType {
667        /**
668         * The action must be performed before the start of the related action
669         */
670        BEFORESTART, 
671        /**
672         * The action must be performed before the related action
673         */
674        BEFORE, 
675        /**
676         * The action must be performed before the end of the related action
677         */
678        BEFOREEND, 
679        /**
680         * The action must be performed concurrent with the start of the related action
681         */
682        CONCURRENTWITHSTART, 
683        /**
684         * The action must be performed concurrent with the related action
685         */
686        CONCURRENT, 
687        /**
688         * The action must be performed concurrent with the end of the related action
689         */
690        CONCURRENTWITHEND, 
691        /**
692         * The action must be performed after the start of the related action
693         */
694        AFTERSTART, 
695        /**
696         * The action must be performed after the related action
697         */
698        AFTER, 
699        /**
700         * The action must be performed after the end of the related action
701         */
702        AFTEREND, 
703        /**
704         * added to help the parsers with the generic types
705         */
706        NULL;
707        public static ActionRelationshipType fromCode(String codeString) throws FHIRException {
708            if (codeString == null || "".equals(codeString))
709                return null;
710        if ("before-start".equals(codeString))
711          return BEFORESTART;
712        if ("before".equals(codeString))
713          return BEFORE;
714        if ("before-end".equals(codeString))
715          return BEFOREEND;
716        if ("concurrent-with-start".equals(codeString))
717          return CONCURRENTWITHSTART;
718        if ("concurrent".equals(codeString))
719          return CONCURRENT;
720        if ("concurrent-with-end".equals(codeString))
721          return CONCURRENTWITHEND;
722        if ("after-start".equals(codeString))
723          return AFTERSTART;
724        if ("after".equals(codeString))
725          return AFTER;
726        if ("after-end".equals(codeString))
727          return AFTEREND;
728        if (Configuration.isAcceptInvalidEnums())
729          return null;
730        else
731          throw new FHIRException("Unknown ActionRelationshipType code '"+codeString+"'");
732        }
733        public String toCode() {
734          switch (this) {
735            case BEFORESTART: return "before-start";
736            case BEFORE: return "before";
737            case BEFOREEND: return "before-end";
738            case CONCURRENTWITHSTART: return "concurrent-with-start";
739            case CONCURRENT: return "concurrent";
740            case CONCURRENTWITHEND: return "concurrent-with-end";
741            case AFTERSTART: return "after-start";
742            case AFTER: return "after";
743            case AFTEREND: return "after-end";
744            case NULL: return null;
745            default: return "?";
746          }
747        }
748        public String getSystem() {
749          switch (this) {
750            case BEFORESTART: return "http://hl7.org/fhir/action-relationship-type";
751            case BEFORE: return "http://hl7.org/fhir/action-relationship-type";
752            case BEFOREEND: return "http://hl7.org/fhir/action-relationship-type";
753            case CONCURRENTWITHSTART: return "http://hl7.org/fhir/action-relationship-type";
754            case CONCURRENT: return "http://hl7.org/fhir/action-relationship-type";
755            case CONCURRENTWITHEND: return "http://hl7.org/fhir/action-relationship-type";
756            case AFTERSTART: return "http://hl7.org/fhir/action-relationship-type";
757            case AFTER: return "http://hl7.org/fhir/action-relationship-type";
758            case AFTEREND: return "http://hl7.org/fhir/action-relationship-type";
759            case NULL: return null;
760            default: return "?";
761          }
762        }
763        public String getDefinition() {
764          switch (this) {
765            case BEFORESTART: return "The action must be performed before the start of the related action";
766            case BEFORE: return "The action must be performed before the related action";
767            case BEFOREEND: return "The action must be performed before the end of the related action";
768            case CONCURRENTWITHSTART: return "The action must be performed concurrent with the start of the related action";
769            case CONCURRENT: return "The action must be performed concurrent with the related action";
770            case CONCURRENTWITHEND: return "The action must be performed concurrent with the end of the related action";
771            case AFTERSTART: return "The action must be performed after the start of the related action";
772            case AFTER: return "The action must be performed after the related action";
773            case AFTEREND: return "The action must be performed after the end of the related action";
774            case NULL: return null;
775            default: return "?";
776          }
777        }
778        public String getDisplay() {
779          switch (this) {
780            case BEFORESTART: return "Before Start";
781            case BEFORE: return "Before";
782            case BEFOREEND: return "Before End";
783            case CONCURRENTWITHSTART: return "Concurrent With Start";
784            case CONCURRENT: return "Concurrent";
785            case CONCURRENTWITHEND: return "Concurrent With End";
786            case AFTERSTART: return "After Start";
787            case AFTER: return "After";
788            case AFTEREND: return "After End";
789            case NULL: return null;
790            default: return "?";
791          }
792        }
793    }
794
795  public static class ActionRelationshipTypeEnumFactory implements EnumFactory<ActionRelationshipType> {
796    public ActionRelationshipType fromCode(String codeString) throws IllegalArgumentException {
797      if (codeString == null || "".equals(codeString))
798            if (codeString == null || "".equals(codeString))
799                return null;
800        if ("before-start".equals(codeString))
801          return ActionRelationshipType.BEFORESTART;
802        if ("before".equals(codeString))
803          return ActionRelationshipType.BEFORE;
804        if ("before-end".equals(codeString))
805          return ActionRelationshipType.BEFOREEND;
806        if ("concurrent-with-start".equals(codeString))
807          return ActionRelationshipType.CONCURRENTWITHSTART;
808        if ("concurrent".equals(codeString))
809          return ActionRelationshipType.CONCURRENT;
810        if ("concurrent-with-end".equals(codeString))
811          return ActionRelationshipType.CONCURRENTWITHEND;
812        if ("after-start".equals(codeString))
813          return ActionRelationshipType.AFTERSTART;
814        if ("after".equals(codeString))
815          return ActionRelationshipType.AFTER;
816        if ("after-end".equals(codeString))
817          return ActionRelationshipType.AFTEREND;
818        throw new IllegalArgumentException("Unknown ActionRelationshipType code '"+codeString+"'");
819        }
820        public Enumeration<ActionRelationshipType> fromType(Base code) throws FHIRException {
821          if (code == null)
822            return null;
823          if (code.isEmpty())
824            return new Enumeration<ActionRelationshipType>(this);
825          String codeString = ((PrimitiveType) code).asStringValue();
826          if (codeString == null || "".equals(codeString))
827            return null;
828        if ("before-start".equals(codeString))
829          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORESTART);
830        if ("before".equals(codeString))
831          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFORE);
832        if ("before-end".equals(codeString))
833          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.BEFOREEND);
834        if ("concurrent-with-start".equals(codeString))
835          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHSTART);
836        if ("concurrent".equals(codeString))
837          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENT);
838        if ("concurrent-with-end".equals(codeString))
839          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.CONCURRENTWITHEND);
840        if ("after-start".equals(codeString))
841          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTERSTART);
842        if ("after".equals(codeString))
843          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTER);
844        if ("after-end".equals(codeString))
845          return new Enumeration<ActionRelationshipType>(this, ActionRelationshipType.AFTEREND);
846        throw new FHIRException("Unknown ActionRelationshipType code '"+codeString+"'");
847        }
848    public String toCode(ActionRelationshipType code) {
849      if (code == ActionRelationshipType.BEFORESTART)
850        return "before-start";
851      if (code == ActionRelationshipType.BEFORE)
852        return "before";
853      if (code == ActionRelationshipType.BEFOREEND)
854        return "before-end";
855      if (code == ActionRelationshipType.CONCURRENTWITHSTART)
856        return "concurrent-with-start";
857      if (code == ActionRelationshipType.CONCURRENT)
858        return "concurrent";
859      if (code == ActionRelationshipType.CONCURRENTWITHEND)
860        return "concurrent-with-end";
861      if (code == ActionRelationshipType.AFTERSTART)
862        return "after-start";
863      if (code == ActionRelationshipType.AFTER)
864        return "after";
865      if (code == ActionRelationshipType.AFTEREND)
866        return "after-end";
867      return "?";
868      }
869    public String toSystem(ActionRelationshipType code) {
870      return code.getSystem();
871      }
872    }
873
874    public enum ActionGroupingBehavior {
875        /**
876         * Any group marked with this behavior should be displayed as a visual group to the end user
877         */
878        VISUALGROUP, 
879        /**
880         * A group with this behavior logically groups its sub-elements, and may be shown as a visual group to the end user, but it is not required to do so
881         */
882        LOGICALGROUP, 
883        /**
884         * A group of related alternative actions is a sentence group if the target referenced by the action is the same in all the actions and each action simply constitutes a different variation on how to specify the details for the target. For example, two actions that could be in a SentenceGroup are "aspirin, 500 mg, 2 times per day" and "aspirin, 300 mg, 3 times per day". In both cases, aspirin is the target referenced by the action, and the two actions represent different options for how aspirin might be ordered for the patient. Note that a SentenceGroup would almost always have an associated selection behavior of "AtMostOne", unless it's a required action, in which case, it would be "ExactlyOne"
885         */
886        SENTENCEGROUP, 
887        /**
888         * added to help the parsers with the generic types
889         */
890        NULL;
891        public static ActionGroupingBehavior fromCode(String codeString) throws FHIRException {
892            if (codeString == null || "".equals(codeString))
893                return null;
894        if ("visual-group".equals(codeString))
895          return VISUALGROUP;
896        if ("logical-group".equals(codeString))
897          return LOGICALGROUP;
898        if ("sentence-group".equals(codeString))
899          return SENTENCEGROUP;
900        if (Configuration.isAcceptInvalidEnums())
901          return null;
902        else
903          throw new FHIRException("Unknown ActionGroupingBehavior code '"+codeString+"'");
904        }
905        public String toCode() {
906          switch (this) {
907            case VISUALGROUP: return "visual-group";
908            case LOGICALGROUP: return "logical-group";
909            case SENTENCEGROUP: return "sentence-group";
910            case NULL: return null;
911            default: return "?";
912          }
913        }
914        public String getSystem() {
915          switch (this) {
916            case VISUALGROUP: return "http://hl7.org/fhir/action-grouping-behavior";
917            case LOGICALGROUP: return "http://hl7.org/fhir/action-grouping-behavior";
918            case SENTENCEGROUP: return "http://hl7.org/fhir/action-grouping-behavior";
919            case NULL: return null;
920            default: return "?";
921          }
922        }
923        public String getDefinition() {
924          switch (this) {
925            case VISUALGROUP: return "Any group marked with this behavior should be displayed as a visual group to the end user";
926            case LOGICALGROUP: return "A group with this behavior logically groups its sub-elements, and may be shown as a visual group to the end user, but it is not required to do so";
927            case SENTENCEGROUP: return "A group of related alternative actions is a sentence group if the target referenced by the action is the same in all the actions and each action simply constitutes a different variation on how to specify the details for the target. For example, two actions that could be in a SentenceGroup are \"aspirin, 500 mg, 2 times per day\" and \"aspirin, 300 mg, 3 times per day\". In both cases, aspirin is the target referenced by the action, and the two actions represent different options for how aspirin might be ordered for the patient. Note that a SentenceGroup would almost always have an associated selection behavior of \"AtMostOne\", unless it's a required action, in which case, it would be \"ExactlyOne\"";
928            case NULL: return null;
929            default: return "?";
930          }
931        }
932        public String getDisplay() {
933          switch (this) {
934            case VISUALGROUP: return "Visual Group";
935            case LOGICALGROUP: return "Logical Group";
936            case SENTENCEGROUP: return "Sentence Group";
937            case NULL: return null;
938            default: return "?";
939          }
940        }
941    }
942
943  public static class ActionGroupingBehaviorEnumFactory implements EnumFactory<ActionGroupingBehavior> {
944    public ActionGroupingBehavior fromCode(String codeString) throws IllegalArgumentException {
945      if (codeString == null || "".equals(codeString))
946            if (codeString == null || "".equals(codeString))
947                return null;
948        if ("visual-group".equals(codeString))
949          return ActionGroupingBehavior.VISUALGROUP;
950        if ("logical-group".equals(codeString))
951          return ActionGroupingBehavior.LOGICALGROUP;
952        if ("sentence-group".equals(codeString))
953          return ActionGroupingBehavior.SENTENCEGROUP;
954        throw new IllegalArgumentException("Unknown ActionGroupingBehavior code '"+codeString+"'");
955        }
956        public Enumeration<ActionGroupingBehavior> fromType(Base code) throws FHIRException {
957          if (code == null)
958            return null;
959          if (code.isEmpty())
960            return new Enumeration<ActionGroupingBehavior>(this);
961          String codeString = ((PrimitiveType) code).asStringValue();
962          if (codeString == null || "".equals(codeString))
963            return null;
964        if ("visual-group".equals(codeString))
965          return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.VISUALGROUP);
966        if ("logical-group".equals(codeString))
967          return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.LOGICALGROUP);
968        if ("sentence-group".equals(codeString))
969          return new Enumeration<ActionGroupingBehavior>(this, ActionGroupingBehavior.SENTENCEGROUP);
970        throw new FHIRException("Unknown ActionGroupingBehavior code '"+codeString+"'");
971        }
972    public String toCode(ActionGroupingBehavior code) {
973      if (code == ActionGroupingBehavior.VISUALGROUP)
974        return "visual-group";
975      if (code == ActionGroupingBehavior.LOGICALGROUP)
976        return "logical-group";
977      if (code == ActionGroupingBehavior.SENTENCEGROUP)
978        return "sentence-group";
979      return "?";
980      }
981    public String toSystem(ActionGroupingBehavior code) {
982      return code.getSystem();
983      }
984    }
985
986    public enum ActionSelectionBehavior {
987        /**
988         * Any number of the actions in the group may be chosen, from zero to all
989         */
990        ANY, 
991        /**
992         * All the actions in the group must be selected as a single unit
993         */
994        ALL, 
995        /**
996         * All the actions in the group are meant to be chosen as a single unit: either all must be selected by the end user, or none may be selected
997         */
998        ALLORNONE, 
999        /**
1000         * The end user must choose one and only one of the selectable actions in the group. The user may not choose none of the actions in the group
1001         */
1002        EXACTLYONE, 
1003        /**
1004         * The end user may choose zero or at most one of the actions in the group
1005         */
1006        ATMOSTONE, 
1007        /**
1008         * The end user must choose a minimum of one, and as many additional as desired
1009         */
1010        ONEORMORE, 
1011        /**
1012         * added to help the parsers with the generic types
1013         */
1014        NULL;
1015        public static ActionSelectionBehavior fromCode(String codeString) throws FHIRException {
1016            if (codeString == null || "".equals(codeString))
1017                return null;
1018        if ("any".equals(codeString))
1019          return ANY;
1020        if ("all".equals(codeString))
1021          return ALL;
1022        if ("all-or-none".equals(codeString))
1023          return ALLORNONE;
1024        if ("exactly-one".equals(codeString))
1025          return EXACTLYONE;
1026        if ("at-most-one".equals(codeString))
1027          return ATMOSTONE;
1028        if ("one-or-more".equals(codeString))
1029          return ONEORMORE;
1030        if (Configuration.isAcceptInvalidEnums())
1031          return null;
1032        else
1033          throw new FHIRException("Unknown ActionSelectionBehavior code '"+codeString+"'");
1034        }
1035        public String toCode() {
1036          switch (this) {
1037            case ANY: return "any";
1038            case ALL: return "all";
1039            case ALLORNONE: return "all-or-none";
1040            case EXACTLYONE: return "exactly-one";
1041            case ATMOSTONE: return "at-most-one";
1042            case ONEORMORE: return "one-or-more";
1043            case NULL: return null;
1044            default: return "?";
1045          }
1046        }
1047        public String getSystem() {
1048          switch (this) {
1049            case ANY: return "http://hl7.org/fhir/action-selection-behavior";
1050            case ALL: return "http://hl7.org/fhir/action-selection-behavior";
1051            case ALLORNONE: return "http://hl7.org/fhir/action-selection-behavior";
1052            case EXACTLYONE: return "http://hl7.org/fhir/action-selection-behavior";
1053            case ATMOSTONE: return "http://hl7.org/fhir/action-selection-behavior";
1054            case ONEORMORE: return "http://hl7.org/fhir/action-selection-behavior";
1055            case NULL: return null;
1056            default: return "?";
1057          }
1058        }
1059        public String getDefinition() {
1060          switch (this) {
1061            case ANY: return "Any number of the actions in the group may be chosen, from zero to all";
1062            case ALL: return "All the actions in the group must be selected as a single unit";
1063            case ALLORNONE: return "All the actions in the group are meant to be chosen as a single unit: either all must be selected by the end user, or none may be selected";
1064            case EXACTLYONE: return "The end user must choose one and only one of the selectable actions in the group. The user may not choose none of the actions in the group";
1065            case ATMOSTONE: return "The end user may choose zero or at most one of the actions in the group";
1066            case ONEORMORE: return "The end user must choose a minimum of one, and as many additional as desired";
1067            case NULL: return null;
1068            default: return "?";
1069          }
1070        }
1071        public String getDisplay() {
1072          switch (this) {
1073            case ANY: return "Any";
1074            case ALL: return "All";
1075            case ALLORNONE: return "All Or None";
1076            case EXACTLYONE: return "Exactly One";
1077            case ATMOSTONE: return "At Most One";
1078            case ONEORMORE: return "One Or More";
1079            case NULL: return null;
1080            default: return "?";
1081          }
1082        }
1083    }
1084
1085  public static class ActionSelectionBehaviorEnumFactory implements EnumFactory<ActionSelectionBehavior> {
1086    public ActionSelectionBehavior fromCode(String codeString) throws IllegalArgumentException {
1087      if (codeString == null || "".equals(codeString))
1088            if (codeString == null || "".equals(codeString))
1089                return null;
1090        if ("any".equals(codeString))
1091          return ActionSelectionBehavior.ANY;
1092        if ("all".equals(codeString))
1093          return ActionSelectionBehavior.ALL;
1094        if ("all-or-none".equals(codeString))
1095          return ActionSelectionBehavior.ALLORNONE;
1096        if ("exactly-one".equals(codeString))
1097          return ActionSelectionBehavior.EXACTLYONE;
1098        if ("at-most-one".equals(codeString))
1099          return ActionSelectionBehavior.ATMOSTONE;
1100        if ("one-or-more".equals(codeString))
1101          return ActionSelectionBehavior.ONEORMORE;
1102        throw new IllegalArgumentException("Unknown ActionSelectionBehavior code '"+codeString+"'");
1103        }
1104        public Enumeration<ActionSelectionBehavior> fromType(Base code) throws FHIRException {
1105          if (code == null)
1106            return null;
1107          if (code.isEmpty())
1108            return new Enumeration<ActionSelectionBehavior>(this);
1109          String codeString = ((PrimitiveType) code).asStringValue();
1110          if (codeString == null || "".equals(codeString))
1111            return null;
1112        if ("any".equals(codeString))
1113          return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ANY);
1114        if ("all".equals(codeString))
1115          return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALL);
1116        if ("all-or-none".equals(codeString))
1117          return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ALLORNONE);
1118        if ("exactly-one".equals(codeString))
1119          return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.EXACTLYONE);
1120        if ("at-most-one".equals(codeString))
1121          return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ATMOSTONE);
1122        if ("one-or-more".equals(codeString))
1123          return new Enumeration<ActionSelectionBehavior>(this, ActionSelectionBehavior.ONEORMORE);
1124        throw new FHIRException("Unknown ActionSelectionBehavior code '"+codeString+"'");
1125        }
1126    public String toCode(ActionSelectionBehavior code) {
1127      if (code == ActionSelectionBehavior.ANY)
1128        return "any";
1129      if (code == ActionSelectionBehavior.ALL)
1130        return "all";
1131      if (code == ActionSelectionBehavior.ALLORNONE)
1132        return "all-or-none";
1133      if (code == ActionSelectionBehavior.EXACTLYONE)
1134        return "exactly-one";
1135      if (code == ActionSelectionBehavior.ATMOSTONE)
1136        return "at-most-one";
1137      if (code == ActionSelectionBehavior.ONEORMORE)
1138        return "one-or-more";
1139      return "?";
1140      }
1141    public String toSystem(ActionSelectionBehavior code) {
1142      return code.getSystem();
1143      }
1144    }
1145
1146    public enum ActionRequiredBehavior {
1147        /**
1148         * An action with this behavior must be included in the actions processed by the end user; the end user may not choose not to include this action
1149         */
1150        MUST, 
1151        /**
1152         * An action with this behavior may be included in the set of actions processed by the end user
1153         */
1154        COULD, 
1155        /**
1156         * An action with this behavior must be included in the set of actions processed by the end user, unless the end user provides documentation as to why the action was not included
1157         */
1158        MUSTUNLESSDOCUMENTED, 
1159        /**
1160         * added to help the parsers with the generic types
1161         */
1162        NULL;
1163        public static ActionRequiredBehavior fromCode(String codeString) throws FHIRException {
1164            if (codeString == null || "".equals(codeString))
1165                return null;
1166        if ("must".equals(codeString))
1167          return MUST;
1168        if ("could".equals(codeString))
1169          return COULD;
1170        if ("must-unless-documented".equals(codeString))
1171          return MUSTUNLESSDOCUMENTED;
1172        if (Configuration.isAcceptInvalidEnums())
1173          return null;
1174        else
1175          throw new FHIRException("Unknown ActionRequiredBehavior code '"+codeString+"'");
1176        }
1177        public String toCode() {
1178          switch (this) {
1179            case MUST: return "must";
1180            case COULD: return "could";
1181            case MUSTUNLESSDOCUMENTED: return "must-unless-documented";
1182            case NULL: return null;
1183            default: return "?";
1184          }
1185        }
1186        public String getSystem() {
1187          switch (this) {
1188            case MUST: return "http://hl7.org/fhir/action-required-behavior";
1189            case COULD: return "http://hl7.org/fhir/action-required-behavior";
1190            case MUSTUNLESSDOCUMENTED: return "http://hl7.org/fhir/action-required-behavior";
1191            case NULL: return null;
1192            default: return "?";
1193          }
1194        }
1195        public String getDefinition() {
1196          switch (this) {
1197            case MUST: return "An action with this behavior must be included in the actions processed by the end user; the end user may not choose not to include this action";
1198            case COULD: return "An action with this behavior may be included in the set of actions processed by the end user";
1199            case MUSTUNLESSDOCUMENTED: return "An action with this behavior must be included in the set of actions processed by the end user, unless the end user provides documentation as to why the action was not included";
1200            case NULL: return null;
1201            default: return "?";
1202          }
1203        }
1204        public String getDisplay() {
1205          switch (this) {
1206            case MUST: return "Must";
1207            case COULD: return "Could";
1208            case MUSTUNLESSDOCUMENTED: return "Must Unless Documented";
1209            case NULL: return null;
1210            default: return "?";
1211          }
1212        }
1213    }
1214
1215  public static class ActionRequiredBehaviorEnumFactory implements EnumFactory<ActionRequiredBehavior> {
1216    public ActionRequiredBehavior fromCode(String codeString) throws IllegalArgumentException {
1217      if (codeString == null || "".equals(codeString))
1218            if (codeString == null || "".equals(codeString))
1219                return null;
1220        if ("must".equals(codeString))
1221          return ActionRequiredBehavior.MUST;
1222        if ("could".equals(codeString))
1223          return ActionRequiredBehavior.COULD;
1224        if ("must-unless-documented".equals(codeString))
1225          return ActionRequiredBehavior.MUSTUNLESSDOCUMENTED;
1226        throw new IllegalArgumentException("Unknown ActionRequiredBehavior code '"+codeString+"'");
1227        }
1228        public Enumeration<ActionRequiredBehavior> fromType(Base code) throws FHIRException {
1229          if (code == null)
1230            return null;
1231          if (code.isEmpty())
1232            return new Enumeration<ActionRequiredBehavior>(this);
1233          String codeString = ((PrimitiveType) code).asStringValue();
1234          if (codeString == null || "".equals(codeString))
1235            return null;
1236        if ("must".equals(codeString))
1237          return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUST);
1238        if ("could".equals(codeString))
1239          return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.COULD);
1240        if ("must-unless-documented".equals(codeString))
1241          return new Enumeration<ActionRequiredBehavior>(this, ActionRequiredBehavior.MUSTUNLESSDOCUMENTED);
1242        throw new FHIRException("Unknown ActionRequiredBehavior code '"+codeString+"'");
1243        }
1244    public String toCode(ActionRequiredBehavior code) {
1245      if (code == ActionRequiredBehavior.MUST)
1246        return "must";
1247      if (code == ActionRequiredBehavior.COULD)
1248        return "could";
1249      if (code == ActionRequiredBehavior.MUSTUNLESSDOCUMENTED)
1250        return "must-unless-documented";
1251      return "?";
1252      }
1253    public String toSystem(ActionRequiredBehavior code) {
1254      return code.getSystem();
1255      }
1256    }
1257
1258    public enum ActionPrecheckBehavior {
1259        /**
1260         * An action with this behavior is one of the most frequent action that is, or should be, included by an end user, for the particular context in which the action occurs. The system displaying the action to the end user should consider "pre-checking" such an action as a convenience for the user
1261         */
1262        YES, 
1263        /**
1264         * An action with this behavior is one of the less frequent actions included by the end user, for the particular context in which the action occurs. The system displaying the actions to the end user would typically not "pre-check" such an action
1265         */
1266        NO, 
1267        /**
1268         * added to help the parsers with the generic types
1269         */
1270        NULL;
1271        public static ActionPrecheckBehavior fromCode(String codeString) throws FHIRException {
1272            if (codeString == null || "".equals(codeString))
1273                return null;
1274        if ("yes".equals(codeString))
1275          return YES;
1276        if ("no".equals(codeString))
1277          return NO;
1278        if (Configuration.isAcceptInvalidEnums())
1279          return null;
1280        else
1281          throw new FHIRException("Unknown ActionPrecheckBehavior code '"+codeString+"'");
1282        }
1283        public String toCode() {
1284          switch (this) {
1285            case YES: return "yes";
1286            case NO: return "no";
1287            case NULL: return null;
1288            default: return "?";
1289          }
1290        }
1291        public String getSystem() {
1292          switch (this) {
1293            case YES: return "http://hl7.org/fhir/action-precheck-behavior";
1294            case NO: return "http://hl7.org/fhir/action-precheck-behavior";
1295            case NULL: return null;
1296            default: return "?";
1297          }
1298        }
1299        public String getDefinition() {
1300          switch (this) {
1301            case YES: return "An action with this behavior is one of the most frequent action that is, or should be, included by an end user, for the particular context in which the action occurs. The system displaying the action to the end user should consider \"pre-checking\" such an action as a convenience for the user";
1302            case NO: return "An action with this behavior is one of the less frequent actions included by the end user, for the particular context in which the action occurs. The system displaying the actions to the end user would typically not \"pre-check\" such an action";
1303            case NULL: return null;
1304            default: return "?";
1305          }
1306        }
1307        public String getDisplay() {
1308          switch (this) {
1309            case YES: return "Yes";
1310            case NO: return "No";
1311            case NULL: return null;
1312            default: return "?";
1313          }
1314        }
1315    }
1316
1317  public static class ActionPrecheckBehaviorEnumFactory implements EnumFactory<ActionPrecheckBehavior> {
1318    public ActionPrecheckBehavior fromCode(String codeString) throws IllegalArgumentException {
1319      if (codeString == null || "".equals(codeString))
1320            if (codeString == null || "".equals(codeString))
1321                return null;
1322        if ("yes".equals(codeString))
1323          return ActionPrecheckBehavior.YES;
1324        if ("no".equals(codeString))
1325          return ActionPrecheckBehavior.NO;
1326        throw new IllegalArgumentException("Unknown ActionPrecheckBehavior code '"+codeString+"'");
1327        }
1328        public Enumeration<ActionPrecheckBehavior> fromType(Base code) throws FHIRException {
1329          if (code == null)
1330            return null;
1331          if (code.isEmpty())
1332            return new Enumeration<ActionPrecheckBehavior>(this);
1333          String codeString = ((PrimitiveType) code).asStringValue();
1334          if (codeString == null || "".equals(codeString))
1335            return null;
1336        if ("yes".equals(codeString))
1337          return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.YES);
1338        if ("no".equals(codeString))
1339          return new Enumeration<ActionPrecheckBehavior>(this, ActionPrecheckBehavior.NO);
1340        throw new FHIRException("Unknown ActionPrecheckBehavior code '"+codeString+"'");
1341        }
1342    public String toCode(ActionPrecheckBehavior code) {
1343      if (code == ActionPrecheckBehavior.YES)
1344        return "yes";
1345      if (code == ActionPrecheckBehavior.NO)
1346        return "no";
1347      return "?";
1348      }
1349    public String toSystem(ActionPrecheckBehavior code) {
1350      return code.getSystem();
1351      }
1352    }
1353
1354    public enum ActionCardinalityBehavior {
1355        /**
1356         * The action may only be selected one time
1357         */
1358        SINGLE, 
1359        /**
1360         * The action may be selected multiple times
1361         */
1362        MULTIPLE, 
1363        /**
1364         * added to help the parsers with the generic types
1365         */
1366        NULL;
1367        public static ActionCardinalityBehavior fromCode(String codeString) throws FHIRException {
1368            if (codeString == null || "".equals(codeString))
1369                return null;
1370        if ("single".equals(codeString))
1371          return SINGLE;
1372        if ("multiple".equals(codeString))
1373          return MULTIPLE;
1374        if (Configuration.isAcceptInvalidEnums())
1375          return null;
1376        else
1377          throw new FHIRException("Unknown ActionCardinalityBehavior code '"+codeString+"'");
1378        }
1379        public String toCode() {
1380          switch (this) {
1381            case SINGLE: return "single";
1382            case MULTIPLE: return "multiple";
1383            case NULL: return null;
1384            default: return "?";
1385          }
1386        }
1387        public String getSystem() {
1388          switch (this) {
1389            case SINGLE: return "http://hl7.org/fhir/action-cardinality-behavior";
1390            case MULTIPLE: return "http://hl7.org/fhir/action-cardinality-behavior";
1391            case NULL: return null;
1392            default: return "?";
1393          }
1394        }
1395        public String getDefinition() {
1396          switch (this) {
1397            case SINGLE: return "The action may only be selected one time";
1398            case MULTIPLE: return "The action may be selected multiple times";
1399            case NULL: return null;
1400            default: return "?";
1401          }
1402        }
1403        public String getDisplay() {
1404          switch (this) {
1405            case SINGLE: return "Single";
1406            case MULTIPLE: return "Multiple";
1407            case NULL: return null;
1408            default: return "?";
1409          }
1410        }
1411    }
1412
1413  public static class ActionCardinalityBehaviorEnumFactory implements EnumFactory<ActionCardinalityBehavior> {
1414    public ActionCardinalityBehavior fromCode(String codeString) throws IllegalArgumentException {
1415      if (codeString == null || "".equals(codeString))
1416            if (codeString == null || "".equals(codeString))
1417                return null;
1418        if ("single".equals(codeString))
1419          return ActionCardinalityBehavior.SINGLE;
1420        if ("multiple".equals(codeString))
1421          return ActionCardinalityBehavior.MULTIPLE;
1422        throw new IllegalArgumentException("Unknown ActionCardinalityBehavior code '"+codeString+"'");
1423        }
1424        public Enumeration<ActionCardinalityBehavior> fromType(Base code) throws FHIRException {
1425          if (code == null)
1426            return null;
1427          if (code.isEmpty())
1428            return new Enumeration<ActionCardinalityBehavior>(this);
1429          String codeString = ((PrimitiveType) code).asStringValue();
1430          if (codeString == null || "".equals(codeString))
1431            return null;
1432        if ("single".equals(codeString))
1433          return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.SINGLE);
1434        if ("multiple".equals(codeString))
1435          return new Enumeration<ActionCardinalityBehavior>(this, ActionCardinalityBehavior.MULTIPLE);
1436        throw new FHIRException("Unknown ActionCardinalityBehavior code '"+codeString+"'");
1437        }
1438    public String toCode(ActionCardinalityBehavior code) {
1439      if (code == ActionCardinalityBehavior.SINGLE)
1440        return "single";
1441      if (code == ActionCardinalityBehavior.MULTIPLE)
1442        return "multiple";
1443      return "?";
1444      }
1445    public String toSystem(ActionCardinalityBehavior code) {
1446      return code.getSystem();
1447      }
1448    }
1449
1450    @Block()
1451    public static class RequestGroupActionComponent extends BackboneElement implements IBaseBackboneElement {
1452        /**
1453         * A user-visible label for the action.
1454         */
1455        @Child(name = "label", type = {StringType.class}, order=1, min=0, max=1, modifier=false, summary=false)
1456        @Description(shortDefinition="User-visible label for the action (e.g. 1. or A.)", formalDefinition="A user-visible label for the action." )
1457        protected StringType label;
1458
1459        /**
1460         * The title of the action displayed to a user.
1461         */
1462        @Child(name = "title", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=false)
1463        @Description(shortDefinition="User-visible title", formalDefinition="The title of the action displayed to a user." )
1464        protected StringType title;
1465
1466        /**
1467         * A short description of the action used to provide a summary to display to the user.
1468         */
1469        @Child(name = "description", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=true)
1470        @Description(shortDefinition="Short description of the action", formalDefinition="A short description of the action used to provide a summary to display to the user." )
1471        protected StringType description;
1472
1473        /**
1474         * A text equivalent of the action to be performed. This provides a human-interpretable description of the action when the definition is consumed by a system that may not be capable of interpreting it dynamically.
1475         */
1476        @Child(name = "textEquivalent", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=true)
1477        @Description(shortDefinition="Static text equivalent of the action, used if the dynamic aspects cannot be interpreted by the receiving system", formalDefinition="A text equivalent of the action to be performed. This provides a human-interpretable description of the action when the definition is consumed by a system that may not be capable of interpreting it dynamically." )
1478        protected StringType textEquivalent;
1479
1480        /**
1481         * A code that provides meaning for the action or action group. For example, a section may have a LOINC code for a the section of a documentation template.
1482         */
1483        @Child(name = "code", type = {CodeableConcept.class}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1484        @Description(shortDefinition="Code representing the meaning of the action or sub-actions", formalDefinition="A code that provides meaning for the action or action group. For example, a section may have a LOINC code for a the section of a documentation template." )
1485        protected List<CodeableConcept> code;
1486
1487        /**
1488         * Didactic or other informational resources associated with the action that can be provided to the CDS recipient. Information resources can include inline text commentary and links to web resources.
1489         */
1490        @Child(name = "documentation", type = {RelatedArtifact.class}, order=6, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1491        @Description(shortDefinition="Supporting documentation for the intended performer of the action", formalDefinition="Didactic or other informational resources associated with the action that can be provided to the CDS recipient. Information resources can include inline text commentary and links to web resources." )
1492        protected List<RelatedArtifact> documentation;
1493
1494        /**
1495         * An expression that describes applicability criteria, or start/stop conditions for the action.
1496         */
1497        @Child(name = "condition", type = {}, order=7, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1498        @Description(shortDefinition="Whether or not the action is applicable", formalDefinition="An expression that describes applicability criteria, or start/stop conditions for the action." )
1499        protected List<RequestGroupActionConditionComponent> condition;
1500
1501        /**
1502         * A relationship to another action such as "before" or "30-60 minutes after start of".
1503         */
1504        @Child(name = "relatedAction", type = {}, order=8, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1505        @Description(shortDefinition="Relationship to another action", formalDefinition="A relationship to another action such as \"before\" or \"30-60 minutes after start of\"." )
1506        protected List<RequestGroupActionRelatedActionComponent> relatedAction;
1507
1508        /**
1509         * An optional value describing when the action should be performed.
1510         */
1511        @Child(name = "timing", type = {DateTimeType.class, Period.class, Duration.class, Range.class, Timing.class}, order=9, min=0, max=1, modifier=false, summary=false)
1512        @Description(shortDefinition="When the action should take place", formalDefinition="An optional value describing when the action should be performed." )
1513        protected Type timing;
1514
1515        /**
1516         * The participant that should perform or be responsible for this action.
1517         */
1518        @Child(name = "participant", type = {Patient.class, Person.class, Practitioner.class, RelatedPerson.class}, order=10, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1519        @Description(shortDefinition="Who should perform the action", formalDefinition="The participant that should perform or be responsible for this action." )
1520        protected List<Reference> participant;
1521        /**
1522         * The actual objects that are the target of the reference (The participant that should perform or be responsible for this action.)
1523         */
1524        protected List<Resource> participantTarget;
1525
1526
1527        /**
1528         * The type of action to perform (create, update, remove).
1529         */
1530        @Child(name = "type", type = {Coding.class}, order=11, min=0, max=1, modifier=false, summary=false)
1531        @Description(shortDefinition="create | update | remove | fire-event", formalDefinition="The type of action to perform (create, update, remove)." )
1532        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/action-type")
1533        protected Coding type;
1534
1535        /**
1536         * Defines the grouping behavior for the action and its children.
1537         */
1538        @Child(name = "groupingBehavior", type = {CodeType.class}, order=12, min=0, max=1, modifier=false, summary=false)
1539        @Description(shortDefinition="visual-group | logical-group | sentence-group", formalDefinition="Defines the grouping behavior for the action and its children." )
1540        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/action-grouping-behavior")
1541        protected Enumeration<ActionGroupingBehavior> groupingBehavior;
1542
1543        /**
1544         * Defines the selection behavior for the action and its children.
1545         */
1546        @Child(name = "selectionBehavior", type = {CodeType.class}, order=13, min=0, max=1, modifier=false, summary=false)
1547        @Description(shortDefinition="any | all | all-or-none | exactly-one | at-most-one | one-or-more", formalDefinition="Defines the selection behavior for the action and its children." )
1548        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/action-selection-behavior")
1549        protected Enumeration<ActionSelectionBehavior> selectionBehavior;
1550
1551        /**
1552         * Defines the requiredness behavior for the action.
1553         */
1554        @Child(name = "requiredBehavior", type = {CodeType.class}, order=14, min=0, max=1, modifier=false, summary=false)
1555        @Description(shortDefinition="must | could | must-unless-documented", formalDefinition="Defines the requiredness behavior for the action." )
1556        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/action-required-behavior")
1557        protected Enumeration<ActionRequiredBehavior> requiredBehavior;
1558
1559        /**
1560         * Defines whether the action should usually be preselected.
1561         */
1562        @Child(name = "precheckBehavior", type = {CodeType.class}, order=15, min=0, max=1, modifier=false, summary=false)
1563        @Description(shortDefinition="yes | no", formalDefinition="Defines whether the action should usually be preselected." )
1564        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/action-precheck-behavior")
1565        protected Enumeration<ActionPrecheckBehavior> precheckBehavior;
1566
1567        /**
1568         * Defines whether the action can be selected multiple times.
1569         */
1570        @Child(name = "cardinalityBehavior", type = {CodeType.class}, order=16, min=0, max=1, modifier=false, summary=false)
1571        @Description(shortDefinition="single | multiple", formalDefinition="Defines whether the action can be selected multiple times." )
1572        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/action-cardinality-behavior")
1573        protected Enumeration<ActionCardinalityBehavior> cardinalityBehavior;
1574
1575        /**
1576         * The resource that is the target of the action (e.g. CommunicationRequest).
1577         */
1578        @Child(name = "resource", type = {Reference.class}, order=17, min=0, max=1, modifier=false, summary=false)
1579        @Description(shortDefinition="The target of the action", formalDefinition="The resource that is the target of the action (e.g. CommunicationRequest)." )
1580        protected Reference resource;
1581
1582        /**
1583         * The actual object that is the target of the reference (The resource that is the target of the action (e.g. CommunicationRequest).)
1584         */
1585        protected Resource resourceTarget;
1586
1587        /**
1588         * Sub actions.
1589         */
1590        @Child(name = "action", type = {RequestGroupActionComponent.class}, order=18, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
1591        @Description(shortDefinition="Sub action", formalDefinition="Sub actions." )
1592        protected List<RequestGroupActionComponent> action;
1593
1594        private static final long serialVersionUID = 362859874L;
1595
1596    /**
1597     * Constructor
1598     */
1599      public RequestGroupActionComponent() {
1600        super();
1601      }
1602
1603        /**
1604         * @return {@link #label} (A user-visible label for the action.). This is the underlying object with id, value and extensions. The accessor "getLabel" gives direct access to the value
1605         */
1606        public StringType getLabelElement() { 
1607          if (this.label == null)
1608            if (Configuration.errorOnAutoCreate())
1609              throw new Error("Attempt to auto-create RequestGroupActionComponent.label");
1610            else if (Configuration.doAutoCreate())
1611              this.label = new StringType(); // bb
1612          return this.label;
1613        }
1614
1615        public boolean hasLabelElement() { 
1616          return this.label != null && !this.label.isEmpty();
1617        }
1618
1619        public boolean hasLabel() { 
1620          return this.label != null && !this.label.isEmpty();
1621        }
1622
1623        /**
1624         * @param value {@link #label} (A user-visible label for the action.). This is the underlying object with id, value and extensions. The accessor "getLabel" gives direct access to the value
1625         */
1626        public RequestGroupActionComponent setLabelElement(StringType value) { 
1627          this.label = value;
1628          return this;
1629        }
1630
1631        /**
1632         * @return A user-visible label for the action.
1633         */
1634        public String getLabel() { 
1635          return this.label == null ? null : this.label.getValue();
1636        }
1637
1638        /**
1639         * @param value A user-visible label for the action.
1640         */
1641        public RequestGroupActionComponent setLabel(String value) { 
1642          if (Utilities.noString(value))
1643            this.label = null;
1644          else {
1645            if (this.label == null)
1646              this.label = new StringType();
1647            this.label.setValue(value);
1648          }
1649          return this;
1650        }
1651
1652        /**
1653         * @return {@link #title} (The title of the action displayed to a user.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
1654         */
1655        public StringType getTitleElement() { 
1656          if (this.title == null)
1657            if (Configuration.errorOnAutoCreate())
1658              throw new Error("Attempt to auto-create RequestGroupActionComponent.title");
1659            else if (Configuration.doAutoCreate())
1660              this.title = new StringType(); // bb
1661          return this.title;
1662        }
1663
1664        public boolean hasTitleElement() { 
1665          return this.title != null && !this.title.isEmpty();
1666        }
1667
1668        public boolean hasTitle() { 
1669          return this.title != null && !this.title.isEmpty();
1670        }
1671
1672        /**
1673         * @param value {@link #title} (The title of the action displayed to a user.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
1674         */
1675        public RequestGroupActionComponent setTitleElement(StringType value) { 
1676          this.title = value;
1677          return this;
1678        }
1679
1680        /**
1681         * @return The title of the action displayed to a user.
1682         */
1683        public String getTitle() { 
1684          return this.title == null ? null : this.title.getValue();
1685        }
1686
1687        /**
1688         * @param value The title of the action displayed to a user.
1689         */
1690        public RequestGroupActionComponent setTitle(String value) { 
1691          if (Utilities.noString(value))
1692            this.title = null;
1693          else {
1694            if (this.title == null)
1695              this.title = new StringType();
1696            this.title.setValue(value);
1697          }
1698          return this;
1699        }
1700
1701        /**
1702         * @return {@link #description} (A short description of the action used to provide a summary to display to the user.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
1703         */
1704        public StringType getDescriptionElement() { 
1705          if (this.description == null)
1706            if (Configuration.errorOnAutoCreate())
1707              throw new Error("Attempt to auto-create RequestGroupActionComponent.description");
1708            else if (Configuration.doAutoCreate())
1709              this.description = new StringType(); // bb
1710          return this.description;
1711        }
1712
1713        public boolean hasDescriptionElement() { 
1714          return this.description != null && !this.description.isEmpty();
1715        }
1716
1717        public boolean hasDescription() { 
1718          return this.description != null && !this.description.isEmpty();
1719        }
1720
1721        /**
1722         * @param value {@link #description} (A short description of the action used to provide a summary to display to the user.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
1723         */
1724        public RequestGroupActionComponent setDescriptionElement(StringType value) { 
1725          this.description = value;
1726          return this;
1727        }
1728
1729        /**
1730         * @return A short description of the action used to provide a summary to display to the user.
1731         */
1732        public String getDescription() { 
1733          return this.description == null ? null : this.description.getValue();
1734        }
1735
1736        /**
1737         * @param value A short description of the action used to provide a summary to display to the user.
1738         */
1739        public RequestGroupActionComponent setDescription(String value) { 
1740          if (Utilities.noString(value))
1741            this.description = null;
1742          else {
1743            if (this.description == null)
1744              this.description = new StringType();
1745            this.description.setValue(value);
1746          }
1747          return this;
1748        }
1749
1750        /**
1751         * @return {@link #textEquivalent} (A text equivalent of the action to be performed. This provides a human-interpretable description of the action when the definition is consumed by a system that may not be capable of interpreting it dynamically.). This is the underlying object with id, value and extensions. The accessor "getTextEquivalent" gives direct access to the value
1752         */
1753        public StringType getTextEquivalentElement() { 
1754          if (this.textEquivalent == null)
1755            if (Configuration.errorOnAutoCreate())
1756              throw new Error("Attempt to auto-create RequestGroupActionComponent.textEquivalent");
1757            else if (Configuration.doAutoCreate())
1758              this.textEquivalent = new StringType(); // bb
1759          return this.textEquivalent;
1760        }
1761
1762        public boolean hasTextEquivalentElement() { 
1763          return this.textEquivalent != null && !this.textEquivalent.isEmpty();
1764        }
1765
1766        public boolean hasTextEquivalent() { 
1767          return this.textEquivalent != null && !this.textEquivalent.isEmpty();
1768        }
1769
1770        /**
1771         * @param value {@link #textEquivalent} (A text equivalent of the action to be performed. This provides a human-interpretable description of the action when the definition is consumed by a system that may not be capable of interpreting it dynamically.). This is the underlying object with id, value and extensions. The accessor "getTextEquivalent" gives direct access to the value
1772         */
1773        public RequestGroupActionComponent setTextEquivalentElement(StringType value) { 
1774          this.textEquivalent = value;
1775          return this;
1776        }
1777
1778        /**
1779         * @return A text equivalent of the action to be performed. This provides a human-interpretable description of the action when the definition is consumed by a system that may not be capable of interpreting it dynamically.
1780         */
1781        public String getTextEquivalent() { 
1782          return this.textEquivalent == null ? null : this.textEquivalent.getValue();
1783        }
1784
1785        /**
1786         * @param value A text equivalent of the action to be performed. This provides a human-interpretable description of the action when the definition is consumed by a system that may not be capable of interpreting it dynamically.
1787         */
1788        public RequestGroupActionComponent setTextEquivalent(String value) { 
1789          if (Utilities.noString(value))
1790            this.textEquivalent = null;
1791          else {
1792            if (this.textEquivalent == null)
1793              this.textEquivalent = new StringType();
1794            this.textEquivalent.setValue(value);
1795          }
1796          return this;
1797        }
1798
1799        /**
1800         * @return {@link #code} (A code that provides meaning for the action or action group. For example, a section may have a LOINC code for a the section of a documentation template.)
1801         */
1802        public List<CodeableConcept> getCode() { 
1803          if (this.code == null)
1804            this.code = new ArrayList<CodeableConcept>();
1805          return this.code;
1806        }
1807
1808        /**
1809         * @return Returns a reference to <code>this</code> for easy method chaining
1810         */
1811        public RequestGroupActionComponent setCode(List<CodeableConcept> theCode) { 
1812          this.code = theCode;
1813          return this;
1814        }
1815
1816        public boolean hasCode() { 
1817          if (this.code == null)
1818            return false;
1819          for (CodeableConcept item : this.code)
1820            if (!item.isEmpty())
1821              return true;
1822          return false;
1823        }
1824
1825        public CodeableConcept addCode() { //3
1826          CodeableConcept t = new CodeableConcept();
1827          if (this.code == null)
1828            this.code = new ArrayList<CodeableConcept>();
1829          this.code.add(t);
1830          return t;
1831        }
1832
1833        public RequestGroupActionComponent addCode(CodeableConcept t) { //3
1834          if (t == null)
1835            return this;
1836          if (this.code == null)
1837            this.code = new ArrayList<CodeableConcept>();
1838          this.code.add(t);
1839          return this;
1840        }
1841
1842        /**
1843         * @return The first repetition of repeating field {@link #code}, creating it if it does not already exist
1844         */
1845        public CodeableConcept getCodeFirstRep() { 
1846          if (getCode().isEmpty()) {
1847            addCode();
1848          }
1849          return getCode().get(0);
1850        }
1851
1852        /**
1853         * @return {@link #documentation} (Didactic or other informational resources associated with the action that can be provided to the CDS recipient. Information resources can include inline text commentary and links to web resources.)
1854         */
1855        public List<RelatedArtifact> getDocumentation() { 
1856          if (this.documentation == null)
1857            this.documentation = new ArrayList<RelatedArtifact>();
1858          return this.documentation;
1859        }
1860
1861        /**
1862         * @return Returns a reference to <code>this</code> for easy method chaining
1863         */
1864        public RequestGroupActionComponent setDocumentation(List<RelatedArtifact> theDocumentation) { 
1865          this.documentation = theDocumentation;
1866          return this;
1867        }
1868
1869        public boolean hasDocumentation() { 
1870          if (this.documentation == null)
1871            return false;
1872          for (RelatedArtifact item : this.documentation)
1873            if (!item.isEmpty())
1874              return true;
1875          return false;
1876        }
1877
1878        public RelatedArtifact addDocumentation() { //3
1879          RelatedArtifact t = new RelatedArtifact();
1880          if (this.documentation == null)
1881            this.documentation = new ArrayList<RelatedArtifact>();
1882          this.documentation.add(t);
1883          return t;
1884        }
1885
1886        public RequestGroupActionComponent addDocumentation(RelatedArtifact t) { //3
1887          if (t == null)
1888            return this;
1889          if (this.documentation == null)
1890            this.documentation = new ArrayList<RelatedArtifact>();
1891          this.documentation.add(t);
1892          return this;
1893        }
1894
1895        /**
1896         * @return The first repetition of repeating field {@link #documentation}, creating it if it does not already exist
1897         */
1898        public RelatedArtifact getDocumentationFirstRep() { 
1899          if (getDocumentation().isEmpty()) {
1900            addDocumentation();
1901          }
1902          return getDocumentation().get(0);
1903        }
1904
1905        /**
1906         * @return {@link #condition} (An expression that describes applicability criteria, or start/stop conditions for the action.)
1907         */
1908        public List<RequestGroupActionConditionComponent> getCondition() { 
1909          if (this.condition == null)
1910            this.condition = new ArrayList<RequestGroupActionConditionComponent>();
1911          return this.condition;
1912        }
1913
1914        /**
1915         * @return Returns a reference to <code>this</code> for easy method chaining
1916         */
1917        public RequestGroupActionComponent setCondition(List<RequestGroupActionConditionComponent> theCondition) { 
1918          this.condition = theCondition;
1919          return this;
1920        }
1921
1922        public boolean hasCondition() { 
1923          if (this.condition == null)
1924            return false;
1925          for (RequestGroupActionConditionComponent item : this.condition)
1926            if (!item.isEmpty())
1927              return true;
1928          return false;
1929        }
1930
1931        public RequestGroupActionConditionComponent addCondition() { //3
1932          RequestGroupActionConditionComponent t = new RequestGroupActionConditionComponent();
1933          if (this.condition == null)
1934            this.condition = new ArrayList<RequestGroupActionConditionComponent>();
1935          this.condition.add(t);
1936          return t;
1937        }
1938
1939        public RequestGroupActionComponent addCondition(RequestGroupActionConditionComponent t) { //3
1940          if (t == null)
1941            return this;
1942          if (this.condition == null)
1943            this.condition = new ArrayList<RequestGroupActionConditionComponent>();
1944          this.condition.add(t);
1945          return this;
1946        }
1947
1948        /**
1949         * @return The first repetition of repeating field {@link #condition}, creating it if it does not already exist
1950         */
1951        public RequestGroupActionConditionComponent getConditionFirstRep() { 
1952          if (getCondition().isEmpty()) {
1953            addCondition();
1954          }
1955          return getCondition().get(0);
1956        }
1957
1958        /**
1959         * @return {@link #relatedAction} (A relationship to another action such as "before" or "30-60 minutes after start of".)
1960         */
1961        public List<RequestGroupActionRelatedActionComponent> getRelatedAction() { 
1962          if (this.relatedAction == null)
1963            this.relatedAction = new ArrayList<RequestGroupActionRelatedActionComponent>();
1964          return this.relatedAction;
1965        }
1966
1967        /**
1968         * @return Returns a reference to <code>this</code> for easy method chaining
1969         */
1970        public RequestGroupActionComponent setRelatedAction(List<RequestGroupActionRelatedActionComponent> theRelatedAction) { 
1971          this.relatedAction = theRelatedAction;
1972          return this;
1973        }
1974
1975        public boolean hasRelatedAction() { 
1976          if (this.relatedAction == null)
1977            return false;
1978          for (RequestGroupActionRelatedActionComponent item : this.relatedAction)
1979            if (!item.isEmpty())
1980              return true;
1981          return false;
1982        }
1983
1984        public RequestGroupActionRelatedActionComponent addRelatedAction() { //3
1985          RequestGroupActionRelatedActionComponent t = new RequestGroupActionRelatedActionComponent();
1986          if (this.relatedAction == null)
1987            this.relatedAction = new ArrayList<RequestGroupActionRelatedActionComponent>();
1988          this.relatedAction.add(t);
1989          return t;
1990        }
1991
1992        public RequestGroupActionComponent addRelatedAction(RequestGroupActionRelatedActionComponent t) { //3
1993          if (t == null)
1994            return this;
1995          if (this.relatedAction == null)
1996            this.relatedAction = new ArrayList<RequestGroupActionRelatedActionComponent>();
1997          this.relatedAction.add(t);
1998          return this;
1999        }
2000
2001        /**
2002         * @return The first repetition of repeating field {@link #relatedAction}, creating it if it does not already exist
2003         */
2004        public RequestGroupActionRelatedActionComponent getRelatedActionFirstRep() { 
2005          if (getRelatedAction().isEmpty()) {
2006            addRelatedAction();
2007          }
2008          return getRelatedAction().get(0);
2009        }
2010
2011        /**
2012         * @return {@link #timing} (An optional value describing when the action should be performed.)
2013         */
2014        public Type getTiming() { 
2015          return this.timing;
2016        }
2017
2018        /**
2019         * @return {@link #timing} (An optional value describing when the action should be performed.)
2020         */
2021        public DateTimeType getTimingDateTimeType() throws FHIRException { 
2022          if (this.timing == null)
2023            return null;
2024          if (!(this.timing instanceof DateTimeType))
2025            throw new FHIRException("Type mismatch: the type DateTimeType was expected, but "+this.timing.getClass().getName()+" was encountered");
2026          return (DateTimeType) this.timing;
2027        }
2028
2029        public boolean hasTimingDateTimeType() { 
2030          return this != null && this.timing instanceof DateTimeType;
2031        }
2032
2033        /**
2034         * @return {@link #timing} (An optional value describing when the action should be performed.)
2035         */
2036        public Period getTimingPeriod() throws FHIRException { 
2037          if (this.timing == null)
2038            return null;
2039          if (!(this.timing instanceof Period))
2040            throw new FHIRException("Type mismatch: the type Period was expected, but "+this.timing.getClass().getName()+" was encountered");
2041          return (Period) this.timing;
2042        }
2043
2044        public boolean hasTimingPeriod() { 
2045          return this != null && this.timing instanceof Period;
2046        }
2047
2048        /**
2049         * @return {@link #timing} (An optional value describing when the action should be performed.)
2050         */
2051        public Duration getTimingDuration() throws FHIRException { 
2052          if (this.timing == null)
2053            return null;
2054          if (!(this.timing instanceof Duration))
2055            throw new FHIRException("Type mismatch: the type Duration was expected, but "+this.timing.getClass().getName()+" was encountered");
2056          return (Duration) this.timing;
2057        }
2058
2059        public boolean hasTimingDuration() { 
2060          return this != null && this.timing instanceof Duration;
2061        }
2062
2063        /**
2064         * @return {@link #timing} (An optional value describing when the action should be performed.)
2065         */
2066        public Range getTimingRange() throws FHIRException { 
2067          if (this.timing == null)
2068            return null;
2069          if (!(this.timing instanceof Range))
2070            throw new FHIRException("Type mismatch: the type Range was expected, but "+this.timing.getClass().getName()+" was encountered");
2071          return (Range) this.timing;
2072        }
2073
2074        public boolean hasTimingRange() { 
2075          return this != null && this.timing instanceof Range;
2076        }
2077
2078        /**
2079         * @return {@link #timing} (An optional value describing when the action should be performed.)
2080         */
2081        public Timing getTimingTiming() throws FHIRException { 
2082          if (this.timing == null)
2083            return null;
2084          if (!(this.timing instanceof Timing))
2085            throw new FHIRException("Type mismatch: the type Timing was expected, but "+this.timing.getClass().getName()+" was encountered");
2086          return (Timing) this.timing;
2087        }
2088
2089        public boolean hasTimingTiming() { 
2090          return this != null && this.timing instanceof Timing;
2091        }
2092
2093        public boolean hasTiming() { 
2094          return this.timing != null && !this.timing.isEmpty();
2095        }
2096
2097        /**
2098         * @param value {@link #timing} (An optional value describing when the action should be performed.)
2099         */
2100        public RequestGroupActionComponent setTiming(Type value) throws FHIRFormatError { 
2101          if (value != null && !(value instanceof DateTimeType || value instanceof Period || value instanceof Duration || value instanceof Range || value instanceof Timing))
2102            throw new FHIRFormatError("Not the right type for RequestGroup.action.timing[x]: "+value.fhirType());
2103          this.timing = value;
2104          return this;
2105        }
2106
2107        /**
2108         * @return {@link #participant} (The participant that should perform or be responsible for this action.)
2109         */
2110        public List<Reference> getParticipant() { 
2111          if (this.participant == null)
2112            this.participant = new ArrayList<Reference>();
2113          return this.participant;
2114        }
2115
2116        /**
2117         * @return Returns a reference to <code>this</code> for easy method chaining
2118         */
2119        public RequestGroupActionComponent setParticipant(List<Reference> theParticipant) { 
2120          this.participant = theParticipant;
2121          return this;
2122        }
2123
2124        public boolean hasParticipant() { 
2125          if (this.participant == null)
2126            return false;
2127          for (Reference item : this.participant)
2128            if (!item.isEmpty())
2129              return true;
2130          return false;
2131        }
2132
2133        public Reference addParticipant() { //3
2134          Reference t = new Reference();
2135          if (this.participant == null)
2136            this.participant = new ArrayList<Reference>();
2137          this.participant.add(t);
2138          return t;
2139        }
2140
2141        public RequestGroupActionComponent addParticipant(Reference t) { //3
2142          if (t == null)
2143            return this;
2144          if (this.participant == null)
2145            this.participant = new ArrayList<Reference>();
2146          this.participant.add(t);
2147          return this;
2148        }
2149
2150        /**
2151         * @return The first repetition of repeating field {@link #participant}, creating it if it does not already exist
2152         */
2153        public Reference getParticipantFirstRep() { 
2154          if (getParticipant().isEmpty()) {
2155            addParticipant();
2156          }
2157          return getParticipant().get(0);
2158        }
2159
2160        /**
2161         * @deprecated Use Reference#setResource(IBaseResource) instead
2162         */
2163        @Deprecated
2164        public List<Resource> getParticipantTarget() { 
2165          if (this.participantTarget == null)
2166            this.participantTarget = new ArrayList<Resource>();
2167          return this.participantTarget;
2168        }
2169
2170        /**
2171         * @return {@link #type} (The type of action to perform (create, update, remove).)
2172         */
2173        public Coding getType() { 
2174          if (this.type == null)
2175            if (Configuration.errorOnAutoCreate())
2176              throw new Error("Attempt to auto-create RequestGroupActionComponent.type");
2177            else if (Configuration.doAutoCreate())
2178              this.type = new Coding(); // cc
2179          return this.type;
2180        }
2181
2182        public boolean hasType() { 
2183          return this.type != null && !this.type.isEmpty();
2184        }
2185
2186        /**
2187         * @param value {@link #type} (The type of action to perform (create, update, remove).)
2188         */
2189        public RequestGroupActionComponent setType(Coding value)  { 
2190          this.type = value;
2191          return this;
2192        }
2193
2194        /**
2195         * @return {@link #groupingBehavior} (Defines the grouping behavior for the action and its children.). This is the underlying object with id, value and extensions. The accessor "getGroupingBehavior" gives direct access to the value
2196         */
2197        public Enumeration<ActionGroupingBehavior> getGroupingBehaviorElement() { 
2198          if (this.groupingBehavior == null)
2199            if (Configuration.errorOnAutoCreate())
2200              throw new Error("Attempt to auto-create RequestGroupActionComponent.groupingBehavior");
2201            else if (Configuration.doAutoCreate())
2202              this.groupingBehavior = new Enumeration<ActionGroupingBehavior>(new ActionGroupingBehaviorEnumFactory()); // bb
2203          return this.groupingBehavior;
2204        }
2205
2206        public boolean hasGroupingBehaviorElement() { 
2207          return this.groupingBehavior != null && !this.groupingBehavior.isEmpty();
2208        }
2209
2210        public boolean hasGroupingBehavior() { 
2211          return this.groupingBehavior != null && !this.groupingBehavior.isEmpty();
2212        }
2213
2214        /**
2215         * @param value {@link #groupingBehavior} (Defines the grouping behavior for the action and its children.). This is the underlying object with id, value and extensions. The accessor "getGroupingBehavior" gives direct access to the value
2216         */
2217        public RequestGroupActionComponent setGroupingBehaviorElement(Enumeration<ActionGroupingBehavior> value) { 
2218          this.groupingBehavior = value;
2219          return this;
2220        }
2221
2222        /**
2223         * @return Defines the grouping behavior for the action and its children.
2224         */
2225        public ActionGroupingBehavior getGroupingBehavior() { 
2226          return this.groupingBehavior == null ? null : this.groupingBehavior.getValue();
2227        }
2228
2229        /**
2230         * @param value Defines the grouping behavior for the action and its children.
2231         */
2232        public RequestGroupActionComponent setGroupingBehavior(ActionGroupingBehavior value) { 
2233          if (value == null)
2234            this.groupingBehavior = null;
2235          else {
2236            if (this.groupingBehavior == null)
2237              this.groupingBehavior = new Enumeration<ActionGroupingBehavior>(new ActionGroupingBehaviorEnumFactory());
2238            this.groupingBehavior.setValue(value);
2239          }
2240          return this;
2241        }
2242
2243        /**
2244         * @return {@link #selectionBehavior} (Defines the selection behavior for the action and its children.). This is the underlying object with id, value and extensions. The accessor "getSelectionBehavior" gives direct access to the value
2245         */
2246        public Enumeration<ActionSelectionBehavior> getSelectionBehaviorElement() { 
2247          if (this.selectionBehavior == null)
2248            if (Configuration.errorOnAutoCreate())
2249              throw new Error("Attempt to auto-create RequestGroupActionComponent.selectionBehavior");
2250            else if (Configuration.doAutoCreate())
2251              this.selectionBehavior = new Enumeration<ActionSelectionBehavior>(new ActionSelectionBehaviorEnumFactory()); // bb
2252          return this.selectionBehavior;
2253        }
2254
2255        public boolean hasSelectionBehaviorElement() { 
2256          return this.selectionBehavior != null && !this.selectionBehavior.isEmpty();
2257        }
2258
2259        public boolean hasSelectionBehavior() { 
2260          return this.selectionBehavior != null && !this.selectionBehavior.isEmpty();
2261        }
2262
2263        /**
2264         * @param value {@link #selectionBehavior} (Defines the selection behavior for the action and its children.). This is the underlying object with id, value and extensions. The accessor "getSelectionBehavior" gives direct access to the value
2265         */
2266        public RequestGroupActionComponent setSelectionBehaviorElement(Enumeration<ActionSelectionBehavior> value) { 
2267          this.selectionBehavior = value;
2268          return this;
2269        }
2270
2271        /**
2272         * @return Defines the selection behavior for the action and its children.
2273         */
2274        public ActionSelectionBehavior getSelectionBehavior() { 
2275          return this.selectionBehavior == null ? null : this.selectionBehavior.getValue();
2276        }
2277
2278        /**
2279         * @param value Defines the selection behavior for the action and its children.
2280         */
2281        public RequestGroupActionComponent setSelectionBehavior(ActionSelectionBehavior value) { 
2282          if (value == null)
2283            this.selectionBehavior = null;
2284          else {
2285            if (this.selectionBehavior == null)
2286              this.selectionBehavior = new Enumeration<ActionSelectionBehavior>(new ActionSelectionBehaviorEnumFactory());
2287            this.selectionBehavior.setValue(value);
2288          }
2289          return this;
2290        }
2291
2292        /**
2293         * @return {@link #requiredBehavior} (Defines the requiredness behavior for the action.). This is the underlying object with id, value and extensions. The accessor "getRequiredBehavior" gives direct access to the value
2294         */
2295        public Enumeration<ActionRequiredBehavior> getRequiredBehaviorElement() { 
2296          if (this.requiredBehavior == null)
2297            if (Configuration.errorOnAutoCreate())
2298              throw new Error("Attempt to auto-create RequestGroupActionComponent.requiredBehavior");
2299            else if (Configuration.doAutoCreate())
2300              this.requiredBehavior = new Enumeration<ActionRequiredBehavior>(new ActionRequiredBehaviorEnumFactory()); // bb
2301          return this.requiredBehavior;
2302        }
2303
2304        public boolean hasRequiredBehaviorElement() { 
2305          return this.requiredBehavior != null && !this.requiredBehavior.isEmpty();
2306        }
2307
2308        public boolean hasRequiredBehavior() { 
2309          return this.requiredBehavior != null && !this.requiredBehavior.isEmpty();
2310        }
2311
2312        /**
2313         * @param value {@link #requiredBehavior} (Defines the requiredness behavior for the action.). This is the underlying object with id, value and extensions. The accessor "getRequiredBehavior" gives direct access to the value
2314         */
2315        public RequestGroupActionComponent setRequiredBehaviorElement(Enumeration<ActionRequiredBehavior> value) { 
2316          this.requiredBehavior = value;
2317          return this;
2318        }
2319
2320        /**
2321         * @return Defines the requiredness behavior for the action.
2322         */
2323        public ActionRequiredBehavior getRequiredBehavior() { 
2324          return this.requiredBehavior == null ? null : this.requiredBehavior.getValue();
2325        }
2326
2327        /**
2328         * @param value Defines the requiredness behavior for the action.
2329         */
2330        public RequestGroupActionComponent setRequiredBehavior(ActionRequiredBehavior value) { 
2331          if (value == null)
2332            this.requiredBehavior = null;
2333          else {
2334            if (this.requiredBehavior == null)
2335              this.requiredBehavior = new Enumeration<ActionRequiredBehavior>(new ActionRequiredBehaviorEnumFactory());
2336            this.requiredBehavior.setValue(value);
2337          }
2338          return this;
2339        }
2340
2341        /**
2342         * @return {@link #precheckBehavior} (Defines whether the action should usually be preselected.). This is the underlying object with id, value and extensions. The accessor "getPrecheckBehavior" gives direct access to the value
2343         */
2344        public Enumeration<ActionPrecheckBehavior> getPrecheckBehaviorElement() { 
2345          if (this.precheckBehavior == null)
2346            if (Configuration.errorOnAutoCreate())
2347              throw new Error("Attempt to auto-create RequestGroupActionComponent.precheckBehavior");
2348            else if (Configuration.doAutoCreate())
2349              this.precheckBehavior = new Enumeration<ActionPrecheckBehavior>(new ActionPrecheckBehaviorEnumFactory()); // bb
2350          return this.precheckBehavior;
2351        }
2352
2353        public boolean hasPrecheckBehaviorElement() { 
2354          return this.precheckBehavior != null && !this.precheckBehavior.isEmpty();
2355        }
2356
2357        public boolean hasPrecheckBehavior() { 
2358          return this.precheckBehavior != null && !this.precheckBehavior.isEmpty();
2359        }
2360
2361        /**
2362         * @param value {@link #precheckBehavior} (Defines whether the action should usually be preselected.). This is the underlying object with id, value and extensions. The accessor "getPrecheckBehavior" gives direct access to the value
2363         */
2364        public RequestGroupActionComponent setPrecheckBehaviorElement(Enumeration<ActionPrecheckBehavior> value) { 
2365          this.precheckBehavior = value;
2366          return this;
2367        }
2368
2369        /**
2370         * @return Defines whether the action should usually be preselected.
2371         */
2372        public ActionPrecheckBehavior getPrecheckBehavior() { 
2373          return this.precheckBehavior == null ? null : this.precheckBehavior.getValue();
2374        }
2375
2376        /**
2377         * @param value Defines whether the action should usually be preselected.
2378         */
2379        public RequestGroupActionComponent setPrecheckBehavior(ActionPrecheckBehavior value) { 
2380          if (value == null)
2381            this.precheckBehavior = null;
2382          else {
2383            if (this.precheckBehavior == null)
2384              this.precheckBehavior = new Enumeration<ActionPrecheckBehavior>(new ActionPrecheckBehaviorEnumFactory());
2385            this.precheckBehavior.setValue(value);
2386          }
2387          return this;
2388        }
2389
2390        /**
2391         * @return {@link #cardinalityBehavior} (Defines whether the action can be selected multiple times.). This is the underlying object with id, value and extensions. The accessor "getCardinalityBehavior" gives direct access to the value
2392         */
2393        public Enumeration<ActionCardinalityBehavior> getCardinalityBehaviorElement() { 
2394          if (this.cardinalityBehavior == null)
2395            if (Configuration.errorOnAutoCreate())
2396              throw new Error("Attempt to auto-create RequestGroupActionComponent.cardinalityBehavior");
2397            else if (Configuration.doAutoCreate())
2398              this.cardinalityBehavior = new Enumeration<ActionCardinalityBehavior>(new ActionCardinalityBehaviorEnumFactory()); // bb
2399          return this.cardinalityBehavior;
2400        }
2401
2402        public boolean hasCardinalityBehaviorElement() { 
2403          return this.cardinalityBehavior != null && !this.cardinalityBehavior.isEmpty();
2404        }
2405
2406        public boolean hasCardinalityBehavior() { 
2407          return this.cardinalityBehavior != null && !this.cardinalityBehavior.isEmpty();
2408        }
2409
2410        /**
2411         * @param value {@link #cardinalityBehavior} (Defines whether the action can be selected multiple times.). This is the underlying object with id, value and extensions. The accessor "getCardinalityBehavior" gives direct access to the value
2412         */
2413        public RequestGroupActionComponent setCardinalityBehaviorElement(Enumeration<ActionCardinalityBehavior> value) { 
2414          this.cardinalityBehavior = value;
2415          return this;
2416        }
2417
2418        /**
2419         * @return Defines whether the action can be selected multiple times.
2420         */
2421        public ActionCardinalityBehavior getCardinalityBehavior() { 
2422          return this.cardinalityBehavior == null ? null : this.cardinalityBehavior.getValue();
2423        }
2424
2425        /**
2426         * @param value Defines whether the action can be selected multiple times.
2427         */
2428        public RequestGroupActionComponent setCardinalityBehavior(ActionCardinalityBehavior value) { 
2429          if (value == null)
2430            this.cardinalityBehavior = null;
2431          else {
2432            if (this.cardinalityBehavior == null)
2433              this.cardinalityBehavior = new Enumeration<ActionCardinalityBehavior>(new ActionCardinalityBehaviorEnumFactory());
2434            this.cardinalityBehavior.setValue(value);
2435          }
2436          return this;
2437        }
2438
2439        /**
2440         * @return {@link #resource} (The resource that is the target of the action (e.g. CommunicationRequest).)
2441         */
2442        public Reference getResource() { 
2443          if (this.resource == null)
2444            if (Configuration.errorOnAutoCreate())
2445              throw new Error("Attempt to auto-create RequestGroupActionComponent.resource");
2446            else if (Configuration.doAutoCreate())
2447              this.resource = new Reference(); // cc
2448          return this.resource;
2449        }
2450
2451        public boolean hasResource() { 
2452          return this.resource != null && !this.resource.isEmpty();
2453        }
2454
2455        /**
2456         * @param value {@link #resource} (The resource that is the target of the action (e.g. CommunicationRequest).)
2457         */
2458        public RequestGroupActionComponent setResource(Reference value)  { 
2459          this.resource = value;
2460          return this;
2461        }
2462
2463        /**
2464         * @return {@link #resource} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The resource that is the target of the action (e.g. CommunicationRequest).)
2465         */
2466        public Resource getResourceTarget() { 
2467          return this.resourceTarget;
2468        }
2469
2470        /**
2471         * @param value {@link #resource} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The resource that is the target of the action (e.g. CommunicationRequest).)
2472         */
2473        public RequestGroupActionComponent setResourceTarget(Resource value) { 
2474          this.resourceTarget = value;
2475          return this;
2476        }
2477
2478        /**
2479         * @return {@link #action} (Sub actions.)
2480         */
2481        public List<RequestGroupActionComponent> getAction() { 
2482          if (this.action == null)
2483            this.action = new ArrayList<RequestGroupActionComponent>();
2484          return this.action;
2485        }
2486
2487        /**
2488         * @return Returns a reference to <code>this</code> for easy method chaining
2489         */
2490        public RequestGroupActionComponent setAction(List<RequestGroupActionComponent> theAction) { 
2491          this.action = theAction;
2492          return this;
2493        }
2494
2495        public boolean hasAction() { 
2496          if (this.action == null)
2497            return false;
2498          for (RequestGroupActionComponent item : this.action)
2499            if (!item.isEmpty())
2500              return true;
2501          return false;
2502        }
2503
2504        public RequestGroupActionComponent addAction() { //3
2505          RequestGroupActionComponent t = new RequestGroupActionComponent();
2506          if (this.action == null)
2507            this.action = new ArrayList<RequestGroupActionComponent>();
2508          this.action.add(t);
2509          return t;
2510        }
2511
2512        public RequestGroupActionComponent addAction(RequestGroupActionComponent t) { //3
2513          if (t == null)
2514            return this;
2515          if (this.action == null)
2516            this.action = new ArrayList<RequestGroupActionComponent>();
2517          this.action.add(t);
2518          return this;
2519        }
2520
2521        /**
2522         * @return The first repetition of repeating field {@link #action}, creating it if it does not already exist
2523         */
2524        public RequestGroupActionComponent getActionFirstRep() { 
2525          if (getAction().isEmpty()) {
2526            addAction();
2527          }
2528          return getAction().get(0);
2529        }
2530
2531        protected void listChildren(List<Property> children) {
2532          super.listChildren(children);
2533          children.add(new Property("label", "string", "A user-visible label for the action.", 0, 1, label));
2534          children.add(new Property("title", "string", "The title of the action displayed to a user.", 0, 1, title));
2535          children.add(new Property("description", "string", "A short description of the action used to provide a summary to display to the user.", 0, 1, description));
2536          children.add(new Property("textEquivalent", "string", "A text equivalent of the action to be performed. This provides a human-interpretable description of the action when the definition is consumed by a system that may not be capable of interpreting it dynamically.", 0, 1, textEquivalent));
2537          children.add(new Property("code", "CodeableConcept", "A code that provides meaning for the action or action group. For example, a section may have a LOINC code for a the section of a documentation template.", 0, java.lang.Integer.MAX_VALUE, code));
2538          children.add(new Property("documentation", "RelatedArtifact", "Didactic or other informational resources associated with the action that can be provided to the CDS recipient. Information resources can include inline text commentary and links to web resources.", 0, java.lang.Integer.MAX_VALUE, documentation));
2539          children.add(new Property("condition", "", "An expression that describes applicability criteria, or start/stop conditions for the action.", 0, java.lang.Integer.MAX_VALUE, condition));
2540          children.add(new Property("relatedAction", "", "A relationship to another action such as \"before\" or \"30-60 minutes after start of\".", 0, java.lang.Integer.MAX_VALUE, relatedAction));
2541          children.add(new Property("timing[x]", "dateTime|Period|Duration|Range|Timing", "An optional value describing when the action should be performed.", 0, 1, timing));
2542          children.add(new Property("participant", "Reference(Patient|Person|Practitioner|RelatedPerson)", "The participant that should perform or be responsible for this action.", 0, java.lang.Integer.MAX_VALUE, participant));
2543          children.add(new Property("type", "Coding", "The type of action to perform (create, update, remove).", 0, 1, type));
2544          children.add(new Property("groupingBehavior", "code", "Defines the grouping behavior for the action and its children.", 0, 1, groupingBehavior));
2545          children.add(new Property("selectionBehavior", "code", "Defines the selection behavior for the action and its children.", 0, 1, selectionBehavior));
2546          children.add(new Property("requiredBehavior", "code", "Defines the requiredness behavior for the action.", 0, 1, requiredBehavior));
2547          children.add(new Property("precheckBehavior", "code", "Defines whether the action should usually be preselected.", 0, 1, precheckBehavior));
2548          children.add(new Property("cardinalityBehavior", "code", "Defines whether the action can be selected multiple times.", 0, 1, cardinalityBehavior));
2549          children.add(new Property("resource", "Reference(Any)", "The resource that is the target of the action (e.g. CommunicationRequest).", 0, 1, resource));
2550          children.add(new Property("action", "@RequestGroup.action", "Sub actions.", 0, java.lang.Integer.MAX_VALUE, action));
2551        }
2552
2553        @Override
2554        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
2555          switch (_hash) {
2556          case 102727412: /*label*/  return new Property("label", "string", "A user-visible label for the action.", 0, 1, label);
2557          case 110371416: /*title*/  return new Property("title", "string", "The title of the action displayed to a user.", 0, 1, title);
2558          case -1724546052: /*description*/  return new Property("description", "string", "A short description of the action used to provide a summary to display to the user.", 0, 1, description);
2559          case -900391049: /*textEquivalent*/  return new Property("textEquivalent", "string", "A text equivalent of the action to be performed. This provides a human-interpretable description of the action when the definition is consumed by a system that may not be capable of interpreting it dynamically.", 0, 1, textEquivalent);
2560          case 3059181: /*code*/  return new Property("code", "CodeableConcept", "A code that provides meaning for the action or action group. For example, a section may have a LOINC code for a the section of a documentation template.", 0, java.lang.Integer.MAX_VALUE, code);
2561          case 1587405498: /*documentation*/  return new Property("documentation", "RelatedArtifact", "Didactic or other informational resources associated with the action that can be provided to the CDS recipient. Information resources can include inline text commentary and links to web resources.", 0, java.lang.Integer.MAX_VALUE, documentation);
2562          case -861311717: /*condition*/  return new Property("condition", "", "An expression that describes applicability criteria, or start/stop conditions for the action.", 0, java.lang.Integer.MAX_VALUE, condition);
2563          case -384107967: /*relatedAction*/  return new Property("relatedAction", "", "A relationship to another action such as \"before\" or \"30-60 minutes after start of\".", 0, java.lang.Integer.MAX_VALUE, relatedAction);
2564          case 164632566: /*timing[x]*/  return new Property("timing[x]", "dateTime|Period|Duration|Range|Timing", "An optional value describing when the action should be performed.", 0, 1, timing);
2565          case -873664438: /*timing*/  return new Property("timing[x]", "dateTime|Period|Duration|Range|Timing", "An optional value describing when the action should be performed.", 0, 1, timing);
2566          case -1837458939: /*timingDateTime*/  return new Property("timing[x]", "dateTime|Period|Duration|Range|Timing", "An optional value describing when the action should be performed.", 0, 1, timing);
2567          case -615615829: /*timingPeriod*/  return new Property("timing[x]", "dateTime|Period|Duration|Range|Timing", "An optional value describing when the action should be performed.", 0, 1, timing);
2568          case -1327253506: /*timingDuration*/  return new Property("timing[x]", "dateTime|Period|Duration|Range|Timing", "An optional value describing when the action should be performed.", 0, 1, timing);
2569          case -710871277: /*timingRange*/  return new Property("timing[x]", "dateTime|Period|Duration|Range|Timing", "An optional value describing when the action should be performed.", 0, 1, timing);
2570          case -497554124: /*timingTiming*/  return new Property("timing[x]", "dateTime|Period|Duration|Range|Timing", "An optional value describing when the action should be performed.", 0, 1, timing);
2571          case 767422259: /*participant*/  return new Property("participant", "Reference(Patient|Person|Practitioner|RelatedPerson)", "The participant that should perform or be responsible for this action.", 0, java.lang.Integer.MAX_VALUE, participant);
2572          case 3575610: /*type*/  return new Property("type", "Coding", "The type of action to perform (create, update, remove).", 0, 1, type);
2573          case 586678389: /*groupingBehavior*/  return new Property("groupingBehavior", "code", "Defines the grouping behavior for the action and its children.", 0, 1, groupingBehavior);
2574          case 168639486: /*selectionBehavior*/  return new Property("selectionBehavior", "code", "Defines the selection behavior for the action and its children.", 0, 1, selectionBehavior);
2575          case -1163906287: /*requiredBehavior*/  return new Property("requiredBehavior", "code", "Defines the requiredness behavior for the action.", 0, 1, requiredBehavior);
2576          case -1174249033: /*precheckBehavior*/  return new Property("precheckBehavior", "code", "Defines whether the action should usually be preselected.", 0, 1, precheckBehavior);
2577          case -922577408: /*cardinalityBehavior*/  return new Property("cardinalityBehavior", "code", "Defines whether the action can be selected multiple times.", 0, 1, cardinalityBehavior);
2578          case -341064690: /*resource*/  return new Property("resource", "Reference(Any)", "The resource that is the target of the action (e.g. CommunicationRequest).", 0, 1, resource);
2579          case -1422950858: /*action*/  return new Property("action", "@RequestGroup.action", "Sub actions.", 0, java.lang.Integer.MAX_VALUE, action);
2580          default: return super.getNamedProperty(_hash, _name, _checkValid);
2581          }
2582
2583        }
2584
2585      @Override
2586      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
2587        switch (hash) {
2588        case 102727412: /*label*/ return this.label == null ? new Base[0] : new Base[] {this.label}; // StringType
2589        case 110371416: /*title*/ return this.title == null ? new Base[0] : new Base[] {this.title}; // StringType
2590        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType
2591        case -900391049: /*textEquivalent*/ return this.textEquivalent == null ? new Base[0] : new Base[] {this.textEquivalent}; // StringType
2592        case 3059181: /*code*/ return this.code == null ? new Base[0] : this.code.toArray(new Base[this.code.size()]); // CodeableConcept
2593        case 1587405498: /*documentation*/ return this.documentation == null ? new Base[0] : this.documentation.toArray(new Base[this.documentation.size()]); // RelatedArtifact
2594        case -861311717: /*condition*/ return this.condition == null ? new Base[0] : this.condition.toArray(new Base[this.condition.size()]); // RequestGroupActionConditionComponent
2595        case -384107967: /*relatedAction*/ return this.relatedAction == null ? new Base[0] : this.relatedAction.toArray(new Base[this.relatedAction.size()]); // RequestGroupActionRelatedActionComponent
2596        case -873664438: /*timing*/ return this.timing == null ? new Base[0] : new Base[] {this.timing}; // Type
2597        case 767422259: /*participant*/ return this.participant == null ? new Base[0] : this.participant.toArray(new Base[this.participant.size()]); // Reference
2598        case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Coding
2599        case 586678389: /*groupingBehavior*/ return this.groupingBehavior == null ? new Base[0] : new Base[] {this.groupingBehavior}; // Enumeration<ActionGroupingBehavior>
2600        case 168639486: /*selectionBehavior*/ return this.selectionBehavior == null ? new Base[0] : new Base[] {this.selectionBehavior}; // Enumeration<ActionSelectionBehavior>
2601        case -1163906287: /*requiredBehavior*/ return this.requiredBehavior == null ? new Base[0] : new Base[] {this.requiredBehavior}; // Enumeration<ActionRequiredBehavior>
2602        case -1174249033: /*precheckBehavior*/ return this.precheckBehavior == null ? new Base[0] : new Base[] {this.precheckBehavior}; // Enumeration<ActionPrecheckBehavior>
2603        case -922577408: /*cardinalityBehavior*/ return this.cardinalityBehavior == null ? new Base[0] : new Base[] {this.cardinalityBehavior}; // Enumeration<ActionCardinalityBehavior>
2604        case -341064690: /*resource*/ return this.resource == null ? new Base[0] : new Base[] {this.resource}; // Reference
2605        case -1422950858: /*action*/ return this.action == null ? new Base[0] : this.action.toArray(new Base[this.action.size()]); // RequestGroupActionComponent
2606        default: return super.getProperty(hash, name, checkValid);
2607        }
2608
2609      }
2610
2611      @Override
2612      public Base setProperty(int hash, String name, Base value) throws FHIRException {
2613        switch (hash) {
2614        case 102727412: // label
2615          this.label = castToString(value); // StringType
2616          return value;
2617        case 110371416: // title
2618          this.title = castToString(value); // StringType
2619          return value;
2620        case -1724546052: // description
2621          this.description = castToString(value); // StringType
2622          return value;
2623        case -900391049: // textEquivalent
2624          this.textEquivalent = castToString(value); // StringType
2625          return value;
2626        case 3059181: // code
2627          this.getCode().add(castToCodeableConcept(value)); // CodeableConcept
2628          return value;
2629        case 1587405498: // documentation
2630          this.getDocumentation().add(castToRelatedArtifact(value)); // RelatedArtifact
2631          return value;
2632        case -861311717: // condition
2633          this.getCondition().add((RequestGroupActionConditionComponent) value); // RequestGroupActionConditionComponent
2634          return value;
2635        case -384107967: // relatedAction
2636          this.getRelatedAction().add((RequestGroupActionRelatedActionComponent) value); // RequestGroupActionRelatedActionComponent
2637          return value;
2638        case -873664438: // timing
2639          this.timing = castToType(value); // Type
2640          return value;
2641        case 767422259: // participant
2642          this.getParticipant().add(castToReference(value)); // Reference
2643          return value;
2644        case 3575610: // type
2645          this.type = castToCoding(value); // Coding
2646          return value;
2647        case 586678389: // groupingBehavior
2648          value = new ActionGroupingBehaviorEnumFactory().fromType(castToCode(value));
2649          this.groupingBehavior = (Enumeration) value; // Enumeration<ActionGroupingBehavior>
2650          return value;
2651        case 168639486: // selectionBehavior
2652          value = new ActionSelectionBehaviorEnumFactory().fromType(castToCode(value));
2653          this.selectionBehavior = (Enumeration) value; // Enumeration<ActionSelectionBehavior>
2654          return value;
2655        case -1163906287: // requiredBehavior
2656          value = new ActionRequiredBehaviorEnumFactory().fromType(castToCode(value));
2657          this.requiredBehavior = (Enumeration) value; // Enumeration<ActionRequiredBehavior>
2658          return value;
2659        case -1174249033: // precheckBehavior
2660          value = new ActionPrecheckBehaviorEnumFactory().fromType(castToCode(value));
2661          this.precheckBehavior = (Enumeration) value; // Enumeration<ActionPrecheckBehavior>
2662          return value;
2663        case -922577408: // cardinalityBehavior
2664          value = new ActionCardinalityBehaviorEnumFactory().fromType(castToCode(value));
2665          this.cardinalityBehavior = (Enumeration) value; // Enumeration<ActionCardinalityBehavior>
2666          return value;
2667        case -341064690: // resource
2668          this.resource = castToReference(value); // Reference
2669          return value;
2670        case -1422950858: // action
2671          this.getAction().add((RequestGroupActionComponent) value); // RequestGroupActionComponent
2672          return value;
2673        default: return super.setProperty(hash, name, value);
2674        }
2675
2676      }
2677
2678      @Override
2679      public Base setProperty(String name, Base value) throws FHIRException {
2680        if (name.equals("label")) {
2681          this.label = castToString(value); // StringType
2682        } else if (name.equals("title")) {
2683          this.title = castToString(value); // StringType
2684        } else if (name.equals("description")) {
2685          this.description = castToString(value); // StringType
2686        } else if (name.equals("textEquivalent")) {
2687          this.textEquivalent = castToString(value); // StringType
2688        } else if (name.equals("code")) {
2689          this.getCode().add(castToCodeableConcept(value));
2690        } else if (name.equals("documentation")) {
2691          this.getDocumentation().add(castToRelatedArtifact(value));
2692        } else if (name.equals("condition")) {
2693          this.getCondition().add((RequestGroupActionConditionComponent) value);
2694        } else if (name.equals("relatedAction")) {
2695          this.getRelatedAction().add((RequestGroupActionRelatedActionComponent) value);
2696        } else if (name.equals("timing[x]")) {
2697          this.timing = castToType(value); // Type
2698        } else if (name.equals("participant")) {
2699          this.getParticipant().add(castToReference(value));
2700        } else if (name.equals("type")) {
2701          this.type = castToCoding(value); // Coding
2702        } else if (name.equals("groupingBehavior")) {
2703          value = new ActionGroupingBehaviorEnumFactory().fromType(castToCode(value));
2704          this.groupingBehavior = (Enumeration) value; // Enumeration<ActionGroupingBehavior>
2705        } else if (name.equals("selectionBehavior")) {
2706          value = new ActionSelectionBehaviorEnumFactory().fromType(castToCode(value));
2707          this.selectionBehavior = (Enumeration) value; // Enumeration<ActionSelectionBehavior>
2708        } else if (name.equals("requiredBehavior")) {
2709          value = new ActionRequiredBehaviorEnumFactory().fromType(castToCode(value));
2710          this.requiredBehavior = (Enumeration) value; // Enumeration<ActionRequiredBehavior>
2711        } else if (name.equals("precheckBehavior")) {
2712          value = new ActionPrecheckBehaviorEnumFactory().fromType(castToCode(value));
2713          this.precheckBehavior = (Enumeration) value; // Enumeration<ActionPrecheckBehavior>
2714        } else if (name.equals("cardinalityBehavior")) {
2715          value = new ActionCardinalityBehaviorEnumFactory().fromType(castToCode(value));
2716          this.cardinalityBehavior = (Enumeration) value; // Enumeration<ActionCardinalityBehavior>
2717        } else if (name.equals("resource")) {
2718          this.resource = castToReference(value); // Reference
2719        } else if (name.equals("action")) {
2720          this.getAction().add((RequestGroupActionComponent) value);
2721        } else
2722          return super.setProperty(name, value);
2723        return value;
2724      }
2725
2726      @Override
2727      public Base makeProperty(int hash, String name) throws FHIRException {
2728        switch (hash) {
2729        case 102727412:  return getLabelElement();
2730        case 110371416:  return getTitleElement();
2731        case -1724546052:  return getDescriptionElement();
2732        case -900391049:  return getTextEquivalentElement();
2733        case 3059181:  return addCode(); 
2734        case 1587405498:  return addDocumentation(); 
2735        case -861311717:  return addCondition(); 
2736        case -384107967:  return addRelatedAction(); 
2737        case 164632566:  return getTiming(); 
2738        case -873664438:  return getTiming(); 
2739        case 767422259:  return addParticipant(); 
2740        case 3575610:  return getType(); 
2741        case 586678389:  return getGroupingBehaviorElement();
2742        case 168639486:  return getSelectionBehaviorElement();
2743        case -1163906287:  return getRequiredBehaviorElement();
2744        case -1174249033:  return getPrecheckBehaviorElement();
2745        case -922577408:  return getCardinalityBehaviorElement();
2746        case -341064690:  return getResource(); 
2747        case -1422950858:  return addAction(); 
2748        default: return super.makeProperty(hash, name);
2749        }
2750
2751      }
2752
2753      @Override
2754      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
2755        switch (hash) {
2756        case 102727412: /*label*/ return new String[] {"string"};
2757        case 110371416: /*title*/ return new String[] {"string"};
2758        case -1724546052: /*description*/ return new String[] {"string"};
2759        case -900391049: /*textEquivalent*/ return new String[] {"string"};
2760        case 3059181: /*code*/ return new String[] {"CodeableConcept"};
2761        case 1587405498: /*documentation*/ return new String[] {"RelatedArtifact"};
2762        case -861311717: /*condition*/ return new String[] {};
2763        case -384107967: /*relatedAction*/ return new String[] {};
2764        case -873664438: /*timing*/ return new String[] {"dateTime", "Period", "Duration", "Range", "Timing"};
2765        case 767422259: /*participant*/ return new String[] {"Reference"};
2766        case 3575610: /*type*/ return new String[] {"Coding"};
2767        case 586678389: /*groupingBehavior*/ return new String[] {"code"};
2768        case 168639486: /*selectionBehavior*/ return new String[] {"code"};
2769        case -1163906287: /*requiredBehavior*/ return new String[] {"code"};
2770        case -1174249033: /*precheckBehavior*/ return new String[] {"code"};
2771        case -922577408: /*cardinalityBehavior*/ return new String[] {"code"};
2772        case -341064690: /*resource*/ return new String[] {"Reference"};
2773        case -1422950858: /*action*/ return new String[] {"@RequestGroup.action"};
2774        default: return super.getTypesForProperty(hash, name);
2775        }
2776
2777      }
2778
2779      @Override
2780      public Base addChild(String name) throws FHIRException {
2781        if (name.equals("label")) {
2782          throw new FHIRException("Cannot call addChild on a primitive type RequestGroup.label");
2783        }
2784        else if (name.equals("title")) {
2785          throw new FHIRException("Cannot call addChild on a primitive type RequestGroup.title");
2786        }
2787        else if (name.equals("description")) {
2788          throw new FHIRException("Cannot call addChild on a primitive type RequestGroup.description");
2789        }
2790        else if (name.equals("textEquivalent")) {
2791          throw new FHIRException("Cannot call addChild on a primitive type RequestGroup.textEquivalent");
2792        }
2793        else if (name.equals("code")) {
2794          return addCode();
2795        }
2796        else if (name.equals("documentation")) {
2797          return addDocumentation();
2798        }
2799        else if (name.equals("condition")) {
2800          return addCondition();
2801        }
2802        else if (name.equals("relatedAction")) {
2803          return addRelatedAction();
2804        }
2805        else if (name.equals("timingDateTime")) {
2806          this.timing = new DateTimeType();
2807          return this.timing;
2808        }
2809        else if (name.equals("timingPeriod")) {
2810          this.timing = new Period();
2811          return this.timing;
2812        }
2813        else if (name.equals("timingDuration")) {
2814          this.timing = new Duration();
2815          return this.timing;
2816        }
2817        else if (name.equals("timingRange")) {
2818          this.timing = new Range();
2819          return this.timing;
2820        }
2821        else if (name.equals("timingTiming")) {
2822          this.timing = new Timing();
2823          return this.timing;
2824        }
2825        else if (name.equals("participant")) {
2826          return addParticipant();
2827        }
2828        else if (name.equals("type")) {
2829          this.type = new Coding();
2830          return this.type;
2831        }
2832        else if (name.equals("groupingBehavior")) {
2833          throw new FHIRException("Cannot call addChild on a primitive type RequestGroup.groupingBehavior");
2834        }
2835        else if (name.equals("selectionBehavior")) {
2836          throw new FHIRException("Cannot call addChild on a primitive type RequestGroup.selectionBehavior");
2837        }
2838        else if (name.equals("requiredBehavior")) {
2839          throw new FHIRException("Cannot call addChild on a primitive type RequestGroup.requiredBehavior");
2840        }
2841        else if (name.equals("precheckBehavior")) {
2842          throw new FHIRException("Cannot call addChild on a primitive type RequestGroup.precheckBehavior");
2843        }
2844        else if (name.equals("cardinalityBehavior")) {
2845          throw new FHIRException("Cannot call addChild on a primitive type RequestGroup.cardinalityBehavior");
2846        }
2847        else if (name.equals("resource")) {
2848          this.resource = new Reference();
2849          return this.resource;
2850        }
2851        else if (name.equals("action")) {
2852          return addAction();
2853        }
2854        else
2855          return super.addChild(name);
2856      }
2857
2858      public RequestGroupActionComponent copy() {
2859        RequestGroupActionComponent dst = new RequestGroupActionComponent();
2860        copyValues(dst);
2861        dst.label = label == null ? null : label.copy();
2862        dst.title = title == null ? null : title.copy();
2863        dst.description = description == null ? null : description.copy();
2864        dst.textEquivalent = textEquivalent == null ? null : textEquivalent.copy();
2865        if (code != null) {
2866          dst.code = new ArrayList<CodeableConcept>();
2867          for (CodeableConcept i : code)
2868            dst.code.add(i.copy());
2869        };
2870        if (documentation != null) {
2871          dst.documentation = new ArrayList<RelatedArtifact>();
2872          for (RelatedArtifact i : documentation)
2873            dst.documentation.add(i.copy());
2874        };
2875        if (condition != null) {
2876          dst.condition = new ArrayList<RequestGroupActionConditionComponent>();
2877          for (RequestGroupActionConditionComponent i : condition)
2878            dst.condition.add(i.copy());
2879        };
2880        if (relatedAction != null) {
2881          dst.relatedAction = new ArrayList<RequestGroupActionRelatedActionComponent>();
2882          for (RequestGroupActionRelatedActionComponent i : relatedAction)
2883            dst.relatedAction.add(i.copy());
2884        };
2885        dst.timing = timing == null ? null : timing.copy();
2886        if (participant != null) {
2887          dst.participant = new ArrayList<Reference>();
2888          for (Reference i : participant)
2889            dst.participant.add(i.copy());
2890        };
2891        dst.type = type == null ? null : type.copy();
2892        dst.groupingBehavior = groupingBehavior == null ? null : groupingBehavior.copy();
2893        dst.selectionBehavior = selectionBehavior == null ? null : selectionBehavior.copy();
2894        dst.requiredBehavior = requiredBehavior == null ? null : requiredBehavior.copy();
2895        dst.precheckBehavior = precheckBehavior == null ? null : precheckBehavior.copy();
2896        dst.cardinalityBehavior = cardinalityBehavior == null ? null : cardinalityBehavior.copy();
2897        dst.resource = resource == null ? null : resource.copy();
2898        if (action != null) {
2899          dst.action = new ArrayList<RequestGroupActionComponent>();
2900          for (RequestGroupActionComponent i : action)
2901            dst.action.add(i.copy());
2902        };
2903        return dst;
2904      }
2905
2906      @Override
2907      public boolean equalsDeep(Base other_) {
2908        if (!super.equalsDeep(other_))
2909          return false;
2910        if (!(other_ instanceof RequestGroupActionComponent))
2911          return false;
2912        RequestGroupActionComponent o = (RequestGroupActionComponent) other_;
2913        return compareDeep(label, o.label, true) && compareDeep(title, o.title, true) && compareDeep(description, o.description, true)
2914           && compareDeep(textEquivalent, o.textEquivalent, true) && compareDeep(code, o.code, true) && compareDeep(documentation, o.documentation, true)
2915           && compareDeep(condition, o.condition, true) && compareDeep(relatedAction, o.relatedAction, true)
2916           && compareDeep(timing, o.timing, true) && compareDeep(participant, o.participant, true) && compareDeep(type, o.type, true)
2917           && compareDeep(groupingBehavior, o.groupingBehavior, true) && compareDeep(selectionBehavior, o.selectionBehavior, true)
2918           && compareDeep(requiredBehavior, o.requiredBehavior, true) && compareDeep(precheckBehavior, o.precheckBehavior, true)
2919           && compareDeep(cardinalityBehavior, o.cardinalityBehavior, true) && compareDeep(resource, o.resource, true)
2920           && compareDeep(action, o.action, true);
2921      }
2922
2923      @Override
2924      public boolean equalsShallow(Base other_) {
2925        if (!super.equalsShallow(other_))
2926          return false;
2927        if (!(other_ instanceof RequestGroupActionComponent))
2928          return false;
2929        RequestGroupActionComponent o = (RequestGroupActionComponent) other_;
2930        return compareValues(label, o.label, true) && compareValues(title, o.title, true) && compareValues(description, o.description, true)
2931           && compareValues(textEquivalent, o.textEquivalent, true) && compareValues(groupingBehavior, o.groupingBehavior, true)
2932           && compareValues(selectionBehavior, o.selectionBehavior, true) && compareValues(requiredBehavior, o.requiredBehavior, true)
2933           && compareValues(precheckBehavior, o.precheckBehavior, true) && compareValues(cardinalityBehavior, o.cardinalityBehavior, true)
2934          ;
2935      }
2936
2937      public boolean isEmpty() {
2938        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(label, title, description
2939          , textEquivalent, code, documentation, condition, relatedAction, timing, participant
2940          , type, groupingBehavior, selectionBehavior, requiredBehavior, precheckBehavior, cardinalityBehavior
2941          , resource, action);
2942      }
2943
2944  public String fhirType() {
2945    return "RequestGroup.action";
2946
2947  }
2948
2949  }
2950
2951    @Block()
2952    public static class RequestGroupActionConditionComponent extends BackboneElement implements IBaseBackboneElement {
2953        /**
2954         * The kind of condition.
2955         */
2956        @Child(name = "kind", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=false)
2957        @Description(shortDefinition="applicability | start | stop", formalDefinition="The kind of condition." )
2958        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/action-condition-kind")
2959        protected Enumeration<ActionConditionKind> kind;
2960
2961        /**
2962         * A brief, natural language description of the condition that effectively communicates the intended semantics.
2963         */
2964        @Child(name = "description", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=false)
2965        @Description(shortDefinition="Natural language description of the condition", formalDefinition="A brief, natural language description of the condition that effectively communicates the intended semantics." )
2966        protected StringType description;
2967
2968        /**
2969         * The media type of the language for the expression.
2970         */
2971        @Child(name = "language", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=false)
2972        @Description(shortDefinition="Language of the expression", formalDefinition="The media type of the language for the expression." )
2973        protected StringType language;
2974
2975        /**
2976         * An expression that returns true or false, indicating whether or not the condition is satisfied.
2977         */
2978        @Child(name = "expression", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=false)
2979        @Description(shortDefinition="Boolean-valued expression", formalDefinition="An expression that returns true or false, indicating whether or not the condition is satisfied." )
2980        protected StringType expression;
2981
2982        private static final long serialVersionUID = 944300105L;
2983
2984    /**
2985     * Constructor
2986     */
2987      public RequestGroupActionConditionComponent() {
2988        super();
2989      }
2990
2991    /**
2992     * Constructor
2993     */
2994      public RequestGroupActionConditionComponent(Enumeration<ActionConditionKind> kind) {
2995        super();
2996        this.kind = kind;
2997      }
2998
2999        /**
3000         * @return {@link #kind} (The kind of condition.). This is the underlying object with id, value and extensions. The accessor "getKind" gives direct access to the value
3001         */
3002        public Enumeration<ActionConditionKind> getKindElement() { 
3003          if (this.kind == null)
3004            if (Configuration.errorOnAutoCreate())
3005              throw new Error("Attempt to auto-create RequestGroupActionConditionComponent.kind");
3006            else if (Configuration.doAutoCreate())
3007              this.kind = new Enumeration<ActionConditionKind>(new ActionConditionKindEnumFactory()); // bb
3008          return this.kind;
3009        }
3010
3011        public boolean hasKindElement() { 
3012          return this.kind != null && !this.kind.isEmpty();
3013        }
3014
3015        public boolean hasKind() { 
3016          return this.kind != null && !this.kind.isEmpty();
3017        }
3018
3019        /**
3020         * @param value {@link #kind} (The kind of condition.). This is the underlying object with id, value and extensions. The accessor "getKind" gives direct access to the value
3021         */
3022        public RequestGroupActionConditionComponent setKindElement(Enumeration<ActionConditionKind> value) { 
3023          this.kind = value;
3024          return this;
3025        }
3026
3027        /**
3028         * @return The kind of condition.
3029         */
3030        public ActionConditionKind getKind() { 
3031          return this.kind == null ? null : this.kind.getValue();
3032        }
3033
3034        /**
3035         * @param value The kind of condition.
3036         */
3037        public RequestGroupActionConditionComponent setKind(ActionConditionKind value) { 
3038            if (this.kind == null)
3039              this.kind = new Enumeration<ActionConditionKind>(new ActionConditionKindEnumFactory());
3040            this.kind.setValue(value);
3041          return this;
3042        }
3043
3044        /**
3045         * @return {@link #description} (A brief, natural language description of the condition that effectively communicates the intended semantics.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
3046         */
3047        public StringType getDescriptionElement() { 
3048          if (this.description == null)
3049            if (Configuration.errorOnAutoCreate())
3050              throw new Error("Attempt to auto-create RequestGroupActionConditionComponent.description");
3051            else if (Configuration.doAutoCreate())
3052              this.description = new StringType(); // bb
3053          return this.description;
3054        }
3055
3056        public boolean hasDescriptionElement() { 
3057          return this.description != null && !this.description.isEmpty();
3058        }
3059
3060        public boolean hasDescription() { 
3061          return this.description != null && !this.description.isEmpty();
3062        }
3063
3064        /**
3065         * @param value {@link #description} (A brief, natural language description of the condition that effectively communicates the intended semantics.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
3066         */
3067        public RequestGroupActionConditionComponent setDescriptionElement(StringType value) { 
3068          this.description = value;
3069          return this;
3070        }
3071
3072        /**
3073         * @return A brief, natural language description of the condition that effectively communicates the intended semantics.
3074         */
3075        public String getDescription() { 
3076          return this.description == null ? null : this.description.getValue();
3077        }
3078
3079        /**
3080         * @param value A brief, natural language description of the condition that effectively communicates the intended semantics.
3081         */
3082        public RequestGroupActionConditionComponent setDescription(String value) { 
3083          if (Utilities.noString(value))
3084            this.description = null;
3085          else {
3086            if (this.description == null)
3087              this.description = new StringType();
3088            this.description.setValue(value);
3089          }
3090          return this;
3091        }
3092
3093        /**
3094         * @return {@link #language} (The media type of the language for the expression.). This is the underlying object with id, value and extensions. The accessor "getLanguage" gives direct access to the value
3095         */
3096        public StringType getLanguageElement() { 
3097          if (this.language == null)
3098            if (Configuration.errorOnAutoCreate())
3099              throw new Error("Attempt to auto-create RequestGroupActionConditionComponent.language");
3100            else if (Configuration.doAutoCreate())
3101              this.language = new StringType(); // bb
3102          return this.language;
3103        }
3104
3105        public boolean hasLanguageElement() { 
3106          return this.language != null && !this.language.isEmpty();
3107        }
3108
3109        public boolean hasLanguage() { 
3110          return this.language != null && !this.language.isEmpty();
3111        }
3112
3113        /**
3114         * @param value {@link #language} (The media type of the language for the expression.). This is the underlying object with id, value and extensions. The accessor "getLanguage" gives direct access to the value
3115         */
3116        public RequestGroupActionConditionComponent setLanguageElement(StringType value) { 
3117          this.language = value;
3118          return this;
3119        }
3120
3121        /**
3122         * @return The media type of the language for the expression.
3123         */
3124        public String getLanguage() { 
3125          return this.language == null ? null : this.language.getValue();
3126        }
3127
3128        /**
3129         * @param value The media type of the language for the expression.
3130         */
3131        public RequestGroupActionConditionComponent setLanguage(String value) { 
3132          if (Utilities.noString(value))
3133            this.language = null;
3134          else {
3135            if (this.language == null)
3136              this.language = new StringType();
3137            this.language.setValue(value);
3138          }
3139          return this;
3140        }
3141
3142        /**
3143         * @return {@link #expression} (An expression that returns true or false, indicating whether or not the condition is satisfied.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value
3144         */
3145        public StringType getExpressionElement() { 
3146          if (this.expression == null)
3147            if (Configuration.errorOnAutoCreate())
3148              throw new Error("Attempt to auto-create RequestGroupActionConditionComponent.expression");
3149            else if (Configuration.doAutoCreate())
3150              this.expression = new StringType(); // bb
3151          return this.expression;
3152        }
3153
3154        public boolean hasExpressionElement() { 
3155          return this.expression != null && !this.expression.isEmpty();
3156        }
3157
3158        public boolean hasExpression() { 
3159          return this.expression != null && !this.expression.isEmpty();
3160        }
3161
3162        /**
3163         * @param value {@link #expression} (An expression that returns true or false, indicating whether or not the condition is satisfied.). This is the underlying object with id, value and extensions. The accessor "getExpression" gives direct access to the value
3164         */
3165        public RequestGroupActionConditionComponent setExpressionElement(StringType value) { 
3166          this.expression = value;
3167          return this;
3168        }
3169
3170        /**
3171         * @return An expression that returns true or false, indicating whether or not the condition is satisfied.
3172         */
3173        public String getExpression() { 
3174          return this.expression == null ? null : this.expression.getValue();
3175        }
3176
3177        /**
3178         * @param value An expression that returns true or false, indicating whether or not the condition is satisfied.
3179         */
3180        public RequestGroupActionConditionComponent setExpression(String value) { 
3181          if (Utilities.noString(value))
3182            this.expression = null;
3183          else {
3184            if (this.expression == null)
3185              this.expression = new StringType();
3186            this.expression.setValue(value);
3187          }
3188          return this;
3189        }
3190
3191        protected void listChildren(List<Property> children) {
3192          super.listChildren(children);
3193          children.add(new Property("kind", "code", "The kind of condition.", 0, 1, kind));
3194          children.add(new Property("description", "string", "A brief, natural language description of the condition that effectively communicates the intended semantics.", 0, 1, description));
3195          children.add(new Property("language", "string", "The media type of the language for the expression.", 0, 1, language));
3196          children.add(new Property("expression", "string", "An expression that returns true or false, indicating whether or not the condition is satisfied.", 0, 1, expression));
3197        }
3198
3199        @Override
3200        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
3201          switch (_hash) {
3202          case 3292052: /*kind*/  return new Property("kind", "code", "The kind of condition.", 0, 1, kind);
3203          case -1724546052: /*description*/  return new Property("description", "string", "A brief, natural language description of the condition that effectively communicates the intended semantics.", 0, 1, description);
3204          case -1613589672: /*language*/  return new Property("language", "string", "The media type of the language for the expression.", 0, 1, language);
3205          case -1795452264: /*expression*/  return new Property("expression", "string", "An expression that returns true or false, indicating whether or not the condition is satisfied.", 0, 1, expression);
3206          default: return super.getNamedProperty(_hash, _name, _checkValid);
3207          }
3208
3209        }
3210
3211      @Override
3212      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3213        switch (hash) {
3214        case 3292052: /*kind*/ return this.kind == null ? new Base[0] : new Base[] {this.kind}; // Enumeration<ActionConditionKind>
3215        case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType
3216        case -1613589672: /*language*/ return this.language == null ? new Base[0] : new Base[] {this.language}; // StringType
3217        case -1795452264: /*expression*/ return this.expression == null ? new Base[0] : new Base[] {this.expression}; // StringType
3218        default: return super.getProperty(hash, name, checkValid);
3219        }
3220
3221      }
3222
3223      @Override
3224      public Base setProperty(int hash, String name, Base value) throws FHIRException {
3225        switch (hash) {
3226        case 3292052: // kind
3227          value = new ActionConditionKindEnumFactory().fromType(castToCode(value));
3228          this.kind = (Enumeration) value; // Enumeration<ActionConditionKind>
3229          return value;
3230        case -1724546052: // description
3231          this.description = castToString(value); // StringType
3232          return value;
3233        case -1613589672: // language
3234          this.language = castToString(value); // StringType
3235          return value;
3236        case -1795452264: // expression
3237          this.expression = castToString(value); // StringType
3238          return value;
3239        default: return super.setProperty(hash, name, value);
3240        }
3241
3242      }
3243
3244      @Override
3245      public Base setProperty(String name, Base value) throws FHIRException {
3246        if (name.equals("kind")) {
3247          value = new ActionConditionKindEnumFactory().fromType(castToCode(value));
3248          this.kind = (Enumeration) value; // Enumeration<ActionConditionKind>
3249        } else if (name.equals("description")) {
3250          this.description = castToString(value); // StringType
3251        } else if (name.equals("language")) {
3252          this.language = castToString(value); // StringType
3253        } else if (name.equals("expression")) {
3254          this.expression = castToString(value); // StringType
3255        } else
3256          return super.setProperty(name, value);
3257        return value;
3258      }
3259
3260      @Override
3261      public Base makeProperty(int hash, String name) throws FHIRException {
3262        switch (hash) {
3263        case 3292052:  return getKindElement();
3264        case -1724546052:  return getDescriptionElement();
3265        case -1613589672:  return getLanguageElement();
3266        case -1795452264:  return getExpressionElement();
3267        default: return super.makeProperty(hash, name);
3268        }
3269
3270      }
3271
3272      @Override
3273      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
3274        switch (hash) {
3275        case 3292052: /*kind*/ return new String[] {"code"};
3276        case -1724546052: /*description*/ return new String[] {"string"};
3277        case -1613589672: /*language*/ return new String[] {"string"};
3278        case -1795452264: /*expression*/ return new String[] {"string"};
3279        default: return super.getTypesForProperty(hash, name);
3280        }
3281
3282      }
3283
3284      @Override
3285      public Base addChild(String name) throws FHIRException {
3286        if (name.equals("kind")) {
3287          throw new FHIRException("Cannot call addChild on a primitive type RequestGroup.kind");
3288        }
3289        else if (name.equals("description")) {
3290          throw new FHIRException("Cannot call addChild on a primitive type RequestGroup.description");
3291        }
3292        else if (name.equals("language")) {
3293          throw new FHIRException("Cannot call addChild on a primitive type RequestGroup.language");
3294        }
3295        else if (name.equals("expression")) {
3296          throw new FHIRException("Cannot call addChild on a primitive type RequestGroup.expression");
3297        }
3298        else
3299          return super.addChild(name);
3300      }
3301
3302      public RequestGroupActionConditionComponent copy() {
3303        RequestGroupActionConditionComponent dst = new RequestGroupActionConditionComponent();
3304        copyValues(dst);
3305        dst.kind = kind == null ? null : kind.copy();
3306        dst.description = description == null ? null : description.copy();
3307        dst.language = language == null ? null : language.copy();
3308        dst.expression = expression == null ? null : expression.copy();
3309        return dst;
3310      }
3311
3312      @Override
3313      public boolean equalsDeep(Base other_) {
3314        if (!super.equalsDeep(other_))
3315          return false;
3316        if (!(other_ instanceof RequestGroupActionConditionComponent))
3317          return false;
3318        RequestGroupActionConditionComponent o = (RequestGroupActionConditionComponent) other_;
3319        return compareDeep(kind, o.kind, true) && compareDeep(description, o.description, true) && compareDeep(language, o.language, true)
3320           && compareDeep(expression, o.expression, true);
3321      }
3322
3323      @Override
3324      public boolean equalsShallow(Base other_) {
3325        if (!super.equalsShallow(other_))
3326          return false;
3327        if (!(other_ instanceof RequestGroupActionConditionComponent))
3328          return false;
3329        RequestGroupActionConditionComponent o = (RequestGroupActionConditionComponent) other_;
3330        return compareValues(kind, o.kind, true) && compareValues(description, o.description, true) && compareValues(language, o.language, true)
3331           && compareValues(expression, o.expression, true);
3332      }
3333
3334      public boolean isEmpty() {
3335        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(kind, description, language
3336          , expression);
3337      }
3338
3339  public String fhirType() {
3340    return "RequestGroup.action.condition";
3341
3342  }
3343
3344  }
3345
3346    @Block()
3347    public static class RequestGroupActionRelatedActionComponent extends BackboneElement implements IBaseBackboneElement {
3348        /**
3349         * The element id of the action this is related to.
3350         */
3351        @Child(name = "actionId", type = {IdType.class}, order=1, min=1, max=1, modifier=false, summary=false)
3352        @Description(shortDefinition="What action this is related to", formalDefinition="The element id of the action this is related to." )
3353        protected IdType actionId;
3354
3355        /**
3356         * The relationship of this action to the related action.
3357         */
3358        @Child(name = "relationship", type = {CodeType.class}, order=2, min=1, max=1, modifier=false, summary=false)
3359        @Description(shortDefinition="before-start | before | before-end | concurrent-with-start | concurrent | concurrent-with-end | after-start | after | after-end", formalDefinition="The relationship of this action to the related action." )
3360        @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/action-relationship-type")
3361        protected Enumeration<ActionRelationshipType> relationship;
3362
3363        /**
3364         * A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.
3365         */
3366        @Child(name = "offset", type = {Duration.class, Range.class}, order=3, min=0, max=1, modifier=false, summary=false)
3367        @Description(shortDefinition="Time offset for the relationship", formalDefinition="A duration or range of durations to apply to the relationship. For example, 30-60 minutes before." )
3368        protected Type offset;
3369
3370        private static final long serialVersionUID = 1063306770L;
3371
3372    /**
3373     * Constructor
3374     */
3375      public RequestGroupActionRelatedActionComponent() {
3376        super();
3377      }
3378
3379    /**
3380     * Constructor
3381     */
3382      public RequestGroupActionRelatedActionComponent(IdType actionId, Enumeration<ActionRelationshipType> relationship) {
3383        super();
3384        this.actionId = actionId;
3385        this.relationship = relationship;
3386      }
3387
3388        /**
3389         * @return {@link #actionId} (The element id of the action this is related to.). This is the underlying object with id, value and extensions. The accessor "getActionId" gives direct access to the value
3390         */
3391        public IdType getActionIdElement() { 
3392          if (this.actionId == null)
3393            if (Configuration.errorOnAutoCreate())
3394              throw new Error("Attempt to auto-create RequestGroupActionRelatedActionComponent.actionId");
3395            else if (Configuration.doAutoCreate())
3396              this.actionId = new IdType(); // bb
3397          return this.actionId;
3398        }
3399
3400        public boolean hasActionIdElement() { 
3401          return this.actionId != null && !this.actionId.isEmpty();
3402        }
3403
3404        public boolean hasActionId() { 
3405          return this.actionId != null && !this.actionId.isEmpty();
3406        }
3407
3408        /**
3409         * @param value {@link #actionId} (The element id of the action this is related to.). This is the underlying object with id, value and extensions. The accessor "getActionId" gives direct access to the value
3410         */
3411        public RequestGroupActionRelatedActionComponent setActionIdElement(IdType value) { 
3412          this.actionId = value;
3413          return this;
3414        }
3415
3416        /**
3417         * @return The element id of the action this is related to.
3418         */
3419        public String getActionId() { 
3420          return this.actionId == null ? null : this.actionId.getValue();
3421        }
3422
3423        /**
3424         * @param value The element id of the action this is related to.
3425         */
3426        public RequestGroupActionRelatedActionComponent setActionId(String value) { 
3427            if (this.actionId == null)
3428              this.actionId = new IdType();
3429            this.actionId.setValue(value);
3430          return this;
3431        }
3432
3433        /**
3434         * @return {@link #relationship} (The relationship of this action to the related action.). This is the underlying object with id, value and extensions. The accessor "getRelationship" gives direct access to the value
3435         */
3436        public Enumeration<ActionRelationshipType> getRelationshipElement() { 
3437          if (this.relationship == null)
3438            if (Configuration.errorOnAutoCreate())
3439              throw new Error("Attempt to auto-create RequestGroupActionRelatedActionComponent.relationship");
3440            else if (Configuration.doAutoCreate())
3441              this.relationship = new Enumeration<ActionRelationshipType>(new ActionRelationshipTypeEnumFactory()); // bb
3442          return this.relationship;
3443        }
3444
3445        public boolean hasRelationshipElement() { 
3446          return this.relationship != null && !this.relationship.isEmpty();
3447        }
3448
3449        public boolean hasRelationship() { 
3450          return this.relationship != null && !this.relationship.isEmpty();
3451        }
3452
3453        /**
3454         * @param value {@link #relationship} (The relationship of this action to the related action.). This is the underlying object with id, value and extensions. The accessor "getRelationship" gives direct access to the value
3455         */
3456        public RequestGroupActionRelatedActionComponent setRelationshipElement(Enumeration<ActionRelationshipType> value) { 
3457          this.relationship = value;
3458          return this;
3459        }
3460
3461        /**
3462         * @return The relationship of this action to the related action.
3463         */
3464        public ActionRelationshipType getRelationship() { 
3465          return this.relationship == null ? null : this.relationship.getValue();
3466        }
3467
3468        /**
3469         * @param value The relationship of this action to the related action.
3470         */
3471        public RequestGroupActionRelatedActionComponent setRelationship(ActionRelationshipType value) { 
3472            if (this.relationship == null)
3473              this.relationship = new Enumeration<ActionRelationshipType>(new ActionRelationshipTypeEnumFactory());
3474            this.relationship.setValue(value);
3475          return this;
3476        }
3477
3478        /**
3479         * @return {@link #offset} (A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.)
3480         */
3481        public Type getOffset() { 
3482          return this.offset;
3483        }
3484
3485        /**
3486         * @return {@link #offset} (A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.)
3487         */
3488        public Duration getOffsetDuration() throws FHIRException { 
3489          if (this.offset == null)
3490            return null;
3491          if (!(this.offset instanceof Duration))
3492            throw new FHIRException("Type mismatch: the type Duration was expected, but "+this.offset.getClass().getName()+" was encountered");
3493          return (Duration) this.offset;
3494        }
3495
3496        public boolean hasOffsetDuration() { 
3497          return this != null && this.offset instanceof Duration;
3498        }
3499
3500        /**
3501         * @return {@link #offset} (A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.)
3502         */
3503        public Range getOffsetRange() throws FHIRException { 
3504          if (this.offset == null)
3505            return null;
3506          if (!(this.offset instanceof Range))
3507            throw new FHIRException("Type mismatch: the type Range was expected, but "+this.offset.getClass().getName()+" was encountered");
3508          return (Range) this.offset;
3509        }
3510
3511        public boolean hasOffsetRange() { 
3512          return this != null && this.offset instanceof Range;
3513        }
3514
3515        public boolean hasOffset() { 
3516          return this.offset != null && !this.offset.isEmpty();
3517        }
3518
3519        /**
3520         * @param value {@link #offset} (A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.)
3521         */
3522        public RequestGroupActionRelatedActionComponent setOffset(Type value) throws FHIRFormatError { 
3523          if (value != null && !(value instanceof Duration || value instanceof Range))
3524            throw new FHIRFormatError("Not the right type for RequestGroup.action.relatedAction.offset[x]: "+value.fhirType());
3525          this.offset = value;
3526          return this;
3527        }
3528
3529        protected void listChildren(List<Property> children) {
3530          super.listChildren(children);
3531          children.add(new Property("actionId", "id", "The element id of the action this is related to.", 0, 1, actionId));
3532          children.add(new Property("relationship", "code", "The relationship of this action to the related action.", 0, 1, relationship));
3533          children.add(new Property("offset[x]", "Duration|Range", "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.", 0, 1, offset));
3534        }
3535
3536        @Override
3537        public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
3538          switch (_hash) {
3539          case -1656172047: /*actionId*/  return new Property("actionId", "id", "The element id of the action this is related to.", 0, 1, actionId);
3540          case -261851592: /*relationship*/  return new Property("relationship", "code", "The relationship of this action to the related action.", 0, 1, relationship);
3541          case -1960684787: /*offset[x]*/  return new Property("offset[x]", "Duration|Range", "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.", 0, 1, offset);
3542          case -1019779949: /*offset*/  return new Property("offset[x]", "Duration|Range", "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.", 0, 1, offset);
3543          case 134075207: /*offsetDuration*/  return new Property("offset[x]", "Duration|Range", "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.", 0, 1, offset);
3544          case 1263585386: /*offsetRange*/  return new Property("offset[x]", "Duration|Range", "A duration or range of durations to apply to the relationship. For example, 30-60 minutes before.", 0, 1, offset);
3545          default: return super.getNamedProperty(_hash, _name, _checkValid);
3546          }
3547
3548        }
3549
3550      @Override
3551      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
3552        switch (hash) {
3553        case -1656172047: /*actionId*/ return this.actionId == null ? new Base[0] : new Base[] {this.actionId}; // IdType
3554        case -261851592: /*relationship*/ return this.relationship == null ? new Base[0] : new Base[] {this.relationship}; // Enumeration<ActionRelationshipType>
3555        case -1019779949: /*offset*/ return this.offset == null ? new Base[0] : new Base[] {this.offset}; // Type
3556        default: return super.getProperty(hash, name, checkValid);
3557        }
3558
3559      }
3560
3561      @Override
3562      public Base setProperty(int hash, String name, Base value) throws FHIRException {
3563        switch (hash) {
3564        case -1656172047: // actionId
3565          this.actionId = castToId(value); // IdType
3566          return value;
3567        case -261851592: // relationship
3568          value = new ActionRelationshipTypeEnumFactory().fromType(castToCode(value));
3569          this.relationship = (Enumeration) value; // Enumeration<ActionRelationshipType>
3570          return value;
3571        case -1019779949: // offset
3572          this.offset = castToType(value); // Type
3573          return value;
3574        default: return super.setProperty(hash, name, value);
3575        }
3576
3577      }
3578
3579      @Override
3580      public Base setProperty(String name, Base value) throws FHIRException {
3581        if (name.equals("actionId")) {
3582          this.actionId = castToId(value); // IdType
3583        } else if (name.equals("relationship")) {
3584          value = new ActionRelationshipTypeEnumFactory().fromType(castToCode(value));
3585          this.relationship = (Enumeration) value; // Enumeration<ActionRelationshipType>
3586        } else if (name.equals("offset[x]")) {
3587          this.offset = castToType(value); // Type
3588        } else
3589          return super.setProperty(name, value);
3590        return value;
3591      }
3592
3593      @Override
3594      public Base makeProperty(int hash, String name) throws FHIRException {
3595        switch (hash) {
3596        case -1656172047:  return getActionIdElement();
3597        case -261851592:  return getRelationshipElement();
3598        case -1960684787:  return getOffset(); 
3599        case -1019779949:  return getOffset(); 
3600        default: return super.makeProperty(hash, name);
3601        }
3602
3603      }
3604
3605      @Override
3606      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
3607        switch (hash) {
3608        case -1656172047: /*actionId*/ return new String[] {"id"};
3609        case -261851592: /*relationship*/ return new String[] {"code"};
3610        case -1019779949: /*offset*/ return new String[] {"Duration", "Range"};
3611        default: return super.getTypesForProperty(hash, name);
3612        }
3613
3614      }
3615
3616      @Override
3617      public Base addChild(String name) throws FHIRException {
3618        if (name.equals("actionId")) {
3619          throw new FHIRException("Cannot call addChild on a primitive type RequestGroup.actionId");
3620        }
3621        else if (name.equals("relationship")) {
3622          throw new FHIRException("Cannot call addChild on a primitive type RequestGroup.relationship");
3623        }
3624        else if (name.equals("offsetDuration")) {
3625          this.offset = new Duration();
3626          return this.offset;
3627        }
3628        else if (name.equals("offsetRange")) {
3629          this.offset = new Range();
3630          return this.offset;
3631        }
3632        else
3633          return super.addChild(name);
3634      }
3635
3636      public RequestGroupActionRelatedActionComponent copy() {
3637        RequestGroupActionRelatedActionComponent dst = new RequestGroupActionRelatedActionComponent();
3638        copyValues(dst);
3639        dst.actionId = actionId == null ? null : actionId.copy();
3640        dst.relationship = relationship == null ? null : relationship.copy();
3641        dst.offset = offset == null ? null : offset.copy();
3642        return dst;
3643      }
3644
3645      @Override
3646      public boolean equalsDeep(Base other_) {
3647        if (!super.equalsDeep(other_))
3648          return false;
3649        if (!(other_ instanceof RequestGroupActionRelatedActionComponent))
3650          return false;
3651        RequestGroupActionRelatedActionComponent o = (RequestGroupActionRelatedActionComponent) other_;
3652        return compareDeep(actionId, o.actionId, true) && compareDeep(relationship, o.relationship, true)
3653           && compareDeep(offset, o.offset, true);
3654      }
3655
3656      @Override
3657      public boolean equalsShallow(Base other_) {
3658        if (!super.equalsShallow(other_))
3659          return false;
3660        if (!(other_ instanceof RequestGroupActionRelatedActionComponent))
3661          return false;
3662        RequestGroupActionRelatedActionComponent o = (RequestGroupActionRelatedActionComponent) other_;
3663        return compareValues(actionId, o.actionId, true) && compareValues(relationship, o.relationship, true)
3664          ;
3665      }
3666
3667      public boolean isEmpty() {
3668        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(actionId, relationship, offset
3669          );
3670      }
3671
3672  public String fhirType() {
3673    return "RequestGroup.action.relatedAction";
3674
3675  }
3676
3677  }
3678
3679    /**
3680     * Allows a service to provide a unique, business identifier for the request.
3681     */
3682    @Child(name = "identifier", type = {Identifier.class}, order=0, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
3683    @Description(shortDefinition="Business identifier", formalDefinition="Allows a service to provide a unique, business identifier for the request." )
3684    protected List<Identifier> identifier;
3685
3686    /**
3687     * A protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request.
3688     */
3689    @Child(name = "definition", type = {Reference.class}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
3690    @Description(shortDefinition="Instantiates protocol or definition", formalDefinition="A protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request." )
3691    protected List<Reference> definition;
3692    /**
3693     * The actual objects that are the target of the reference (A protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request.)
3694     */
3695    protected List<Resource> definitionTarget;
3696
3697
3698    /**
3699     * A plan, proposal or order that is fulfilled in whole or in part by this request.
3700     */
3701    @Child(name = "basedOn", type = {Reference.class}, order=2, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
3702    @Description(shortDefinition="Fulfills plan, proposal, or order", formalDefinition="A plan, proposal or order that is fulfilled in whole or in part by this request." )
3703    protected List<Reference> basedOn;
3704    /**
3705     * The actual objects that are the target of the reference (A plan, proposal or order that is fulfilled in whole or in part by this request.)
3706     */
3707    protected List<Resource> basedOnTarget;
3708
3709
3710    /**
3711     * Completed or terminated request(s) whose function is taken by this new request.
3712     */
3713    @Child(name = "replaces", type = {Reference.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
3714    @Description(shortDefinition="Request(s) replaced by this request", formalDefinition="Completed or terminated request(s) whose function is taken by this new request." )
3715    protected List<Reference> replaces;
3716    /**
3717     * The actual objects that are the target of the reference (Completed or terminated request(s) whose function is taken by this new request.)
3718     */
3719    protected List<Resource> replacesTarget;
3720
3721
3722    /**
3723     * A shared identifier common to all requests that were authorized more or less simultaneously by a single author, representing the identifier of the requisition, prescription or similar form.
3724     */
3725    @Child(name = "groupIdentifier", type = {Identifier.class}, order=4, min=0, max=1, modifier=false, summary=true)
3726    @Description(shortDefinition="Composite request this is part of", formalDefinition="A shared identifier common to all requests that were authorized more or less simultaneously by a single author, representing the identifier of the requisition, prescription or similar form." )
3727    protected Identifier groupIdentifier;
3728
3729    /**
3730     * The current state of the request. For request groups, the status reflects the status of all the requests in the group.
3731     */
3732    @Child(name = "status", type = {CodeType.class}, order=5, min=1, max=1, modifier=true, summary=true)
3733    @Description(shortDefinition="draft | active | suspended | cancelled | completed | entered-in-error | unknown", formalDefinition="The current state of the request. For request groups, the status reflects the status of all the requests in the group." )
3734    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/request-status")
3735    protected Enumeration<RequestStatus> status;
3736
3737    /**
3738     * Indicates the level of authority/intentionality associated with the request and where the request fits into the workflow chain.
3739     */
3740    @Child(name = "intent", type = {CodeType.class}, order=6, min=1, max=1, modifier=true, summary=true)
3741    @Description(shortDefinition="proposal | plan | order", formalDefinition="Indicates the level of authority/intentionality associated with the request and where the request fits into the workflow chain." )
3742    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/request-intent")
3743    protected Enumeration<RequestIntent> intent;
3744
3745    /**
3746     * Indicates how quickly the request should be addressed with respect to other requests.
3747     */
3748    @Child(name = "priority", type = {CodeType.class}, order=7, min=0, max=1, modifier=false, summary=true)
3749    @Description(shortDefinition="routine | urgent | asap | stat", formalDefinition="Indicates how quickly the request should be addressed with respect to other requests." )
3750    @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/request-priority")
3751    protected Enumeration<RequestPriority> priority;
3752
3753    /**
3754     * The subject for which the request group was created.
3755     */
3756    @Child(name = "subject", type = {Patient.class, Group.class}, order=8, min=0, max=1, modifier=false, summary=false)
3757    @Description(shortDefinition="Who the request group is about", formalDefinition="The subject for which the request group was created." )
3758    protected Reference subject;
3759
3760    /**
3761     * The actual object that is the target of the reference (The subject for which the request group was created.)
3762     */
3763    protected Resource subjectTarget;
3764
3765    /**
3766     * Describes the context of the request group, if any.
3767     */
3768    @Child(name = "context", type = {Encounter.class, EpisodeOfCare.class}, order=9, min=0, max=1, modifier=false, summary=false)
3769    @Description(shortDefinition="Encounter or Episode for the request group", formalDefinition="Describes the context of the request group, if any." )
3770    protected Reference context;
3771
3772    /**
3773     * The actual object that is the target of the reference (Describes the context of the request group, if any.)
3774     */
3775    protected Resource contextTarget;
3776
3777    /**
3778     * Indicates when the request group was created.
3779     */
3780    @Child(name = "authoredOn", type = {DateTimeType.class}, order=10, min=0, max=1, modifier=false, summary=false)
3781    @Description(shortDefinition="When the request group was authored", formalDefinition="Indicates when the request group was created." )
3782    protected DateTimeType authoredOn;
3783
3784    /**
3785     * Provides a reference to the author of the request group.
3786     */
3787    @Child(name = "author", type = {Device.class, Practitioner.class}, order=11, min=0, max=1, modifier=false, summary=false)
3788    @Description(shortDefinition="Device or practitioner that authored the request group", formalDefinition="Provides a reference to the author of the request group." )
3789    protected Reference author;
3790
3791    /**
3792     * The actual object that is the target of the reference (Provides a reference to the author of the request group.)
3793     */
3794    protected Resource authorTarget;
3795
3796    /**
3797     * Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.
3798     */
3799    @Child(name = "reason", type = {CodeableConcept.class, Reference.class}, order=12, min=0, max=1, modifier=false, summary=false)
3800    @Description(shortDefinition="Reason for the request group", formalDefinition="Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response." )
3801    protected Type reason;
3802
3803    /**
3804     * Provides a mechanism to communicate additional information about the response.
3805     */
3806    @Child(name = "note", type = {Annotation.class}, order=13, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
3807    @Description(shortDefinition="Additional notes about the response", formalDefinition="Provides a mechanism to communicate additional information about the response." )
3808    protected List<Annotation> note;
3809
3810    /**
3811     * The actions, if any, produced by the evaluation of the artifact.
3812     */
3813    @Child(name = "action", type = {}, order=14, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
3814    @Description(shortDefinition="Proposed actions, if any", formalDefinition="The actions, if any, produced by the evaluation of the artifact." )
3815    protected List<RequestGroupActionComponent> action;
3816
3817    private static final long serialVersionUID = -1812083587L;
3818
3819  /**
3820   * Constructor
3821   */
3822    public RequestGroup() {
3823      super();
3824    }
3825
3826  /**
3827   * Constructor
3828   */
3829    public RequestGroup(Enumeration<RequestStatus> status, Enumeration<RequestIntent> intent) {
3830      super();
3831      this.status = status;
3832      this.intent = intent;
3833    }
3834
3835    /**
3836     * @return {@link #identifier} (Allows a service to provide a unique, business identifier for the request.)
3837     */
3838    public List<Identifier> getIdentifier() { 
3839      if (this.identifier == null)
3840        this.identifier = new ArrayList<Identifier>();
3841      return this.identifier;
3842    }
3843
3844    /**
3845     * @return Returns a reference to <code>this</code> for easy method chaining
3846     */
3847    public RequestGroup setIdentifier(List<Identifier> theIdentifier) { 
3848      this.identifier = theIdentifier;
3849      return this;
3850    }
3851
3852    public boolean hasIdentifier() { 
3853      if (this.identifier == null)
3854        return false;
3855      for (Identifier item : this.identifier)
3856        if (!item.isEmpty())
3857          return true;
3858      return false;
3859    }
3860
3861    public Identifier addIdentifier() { //3
3862      Identifier t = new Identifier();
3863      if (this.identifier == null)
3864        this.identifier = new ArrayList<Identifier>();
3865      this.identifier.add(t);
3866      return t;
3867    }
3868
3869    public RequestGroup addIdentifier(Identifier t) { //3
3870      if (t == null)
3871        return this;
3872      if (this.identifier == null)
3873        this.identifier = new ArrayList<Identifier>();
3874      this.identifier.add(t);
3875      return this;
3876    }
3877
3878    /**
3879     * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist
3880     */
3881    public Identifier getIdentifierFirstRep() { 
3882      if (getIdentifier().isEmpty()) {
3883        addIdentifier();
3884      }
3885      return getIdentifier().get(0);
3886    }
3887
3888    /**
3889     * @return {@link #definition} (A protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request.)
3890     */
3891    public List<Reference> getDefinition() { 
3892      if (this.definition == null)
3893        this.definition = new ArrayList<Reference>();
3894      return this.definition;
3895    }
3896
3897    /**
3898     * @return Returns a reference to <code>this</code> for easy method chaining
3899     */
3900    public RequestGroup setDefinition(List<Reference> theDefinition) { 
3901      this.definition = theDefinition;
3902      return this;
3903    }
3904
3905    public boolean hasDefinition() { 
3906      if (this.definition == null)
3907        return false;
3908      for (Reference item : this.definition)
3909        if (!item.isEmpty())
3910          return true;
3911      return false;
3912    }
3913
3914    public Reference addDefinition() { //3
3915      Reference t = new Reference();
3916      if (this.definition == null)
3917        this.definition = new ArrayList<Reference>();
3918      this.definition.add(t);
3919      return t;
3920    }
3921
3922    public RequestGroup addDefinition(Reference t) { //3
3923      if (t == null)
3924        return this;
3925      if (this.definition == null)
3926        this.definition = new ArrayList<Reference>();
3927      this.definition.add(t);
3928      return this;
3929    }
3930
3931    /**
3932     * @return The first repetition of repeating field {@link #definition}, creating it if it does not already exist
3933     */
3934    public Reference getDefinitionFirstRep() { 
3935      if (getDefinition().isEmpty()) {
3936        addDefinition();
3937      }
3938      return getDefinition().get(0);
3939    }
3940
3941    /**
3942     * @deprecated Use Reference#setResource(IBaseResource) instead
3943     */
3944    @Deprecated
3945    public List<Resource> getDefinitionTarget() { 
3946      if (this.definitionTarget == null)
3947        this.definitionTarget = new ArrayList<Resource>();
3948      return this.definitionTarget;
3949    }
3950
3951    /**
3952     * @return {@link #basedOn} (A plan, proposal or order that is fulfilled in whole or in part by this request.)
3953     */
3954    public List<Reference> getBasedOn() { 
3955      if (this.basedOn == null)
3956        this.basedOn = new ArrayList<Reference>();
3957      return this.basedOn;
3958    }
3959
3960    /**
3961     * @return Returns a reference to <code>this</code> for easy method chaining
3962     */
3963    public RequestGroup setBasedOn(List<Reference> theBasedOn) { 
3964      this.basedOn = theBasedOn;
3965      return this;
3966    }
3967
3968    public boolean hasBasedOn() { 
3969      if (this.basedOn == null)
3970        return false;
3971      for (Reference item : this.basedOn)
3972        if (!item.isEmpty())
3973          return true;
3974      return false;
3975    }
3976
3977    public Reference addBasedOn() { //3
3978      Reference t = new Reference();
3979      if (this.basedOn == null)
3980        this.basedOn = new ArrayList<Reference>();
3981      this.basedOn.add(t);
3982      return t;
3983    }
3984
3985    public RequestGroup addBasedOn(Reference t) { //3
3986      if (t == null)
3987        return this;
3988      if (this.basedOn == null)
3989        this.basedOn = new ArrayList<Reference>();
3990      this.basedOn.add(t);
3991      return this;
3992    }
3993
3994    /**
3995     * @return The first repetition of repeating field {@link #basedOn}, creating it if it does not already exist
3996     */
3997    public Reference getBasedOnFirstRep() { 
3998      if (getBasedOn().isEmpty()) {
3999        addBasedOn();
4000      }
4001      return getBasedOn().get(0);
4002    }
4003
4004    /**
4005     * @deprecated Use Reference#setResource(IBaseResource) instead
4006     */
4007    @Deprecated
4008    public List<Resource> getBasedOnTarget() { 
4009      if (this.basedOnTarget == null)
4010        this.basedOnTarget = new ArrayList<Resource>();
4011      return this.basedOnTarget;
4012    }
4013
4014    /**
4015     * @return {@link #replaces} (Completed or terminated request(s) whose function is taken by this new request.)
4016     */
4017    public List<Reference> getReplaces() { 
4018      if (this.replaces == null)
4019        this.replaces = new ArrayList<Reference>();
4020      return this.replaces;
4021    }
4022
4023    /**
4024     * @return Returns a reference to <code>this</code> for easy method chaining
4025     */
4026    public RequestGroup setReplaces(List<Reference> theReplaces) { 
4027      this.replaces = theReplaces;
4028      return this;
4029    }
4030
4031    public boolean hasReplaces() { 
4032      if (this.replaces == null)
4033        return false;
4034      for (Reference item : this.replaces)
4035        if (!item.isEmpty())
4036          return true;
4037      return false;
4038    }
4039
4040    public Reference addReplaces() { //3
4041      Reference t = new Reference();
4042      if (this.replaces == null)
4043        this.replaces = new ArrayList<Reference>();
4044      this.replaces.add(t);
4045      return t;
4046    }
4047
4048    public RequestGroup addReplaces(Reference t) { //3
4049      if (t == null)
4050        return this;
4051      if (this.replaces == null)
4052        this.replaces = new ArrayList<Reference>();
4053      this.replaces.add(t);
4054      return this;
4055    }
4056
4057    /**
4058     * @return The first repetition of repeating field {@link #replaces}, creating it if it does not already exist
4059     */
4060    public Reference getReplacesFirstRep() { 
4061      if (getReplaces().isEmpty()) {
4062        addReplaces();
4063      }
4064      return getReplaces().get(0);
4065    }
4066
4067    /**
4068     * @deprecated Use Reference#setResource(IBaseResource) instead
4069     */
4070    @Deprecated
4071    public List<Resource> getReplacesTarget() { 
4072      if (this.replacesTarget == null)
4073        this.replacesTarget = new ArrayList<Resource>();
4074      return this.replacesTarget;
4075    }
4076
4077    /**
4078     * @return {@link #groupIdentifier} (A shared identifier common to all requests that were authorized more or less simultaneously by a single author, representing the identifier of the requisition, prescription or similar form.)
4079     */
4080    public Identifier getGroupIdentifier() { 
4081      if (this.groupIdentifier == null)
4082        if (Configuration.errorOnAutoCreate())
4083          throw new Error("Attempt to auto-create RequestGroup.groupIdentifier");
4084        else if (Configuration.doAutoCreate())
4085          this.groupIdentifier = new Identifier(); // cc
4086      return this.groupIdentifier;
4087    }
4088
4089    public boolean hasGroupIdentifier() { 
4090      return this.groupIdentifier != null && !this.groupIdentifier.isEmpty();
4091    }
4092
4093    /**
4094     * @param value {@link #groupIdentifier} (A shared identifier common to all requests that were authorized more or less simultaneously by a single author, representing the identifier of the requisition, prescription or similar form.)
4095     */
4096    public RequestGroup setGroupIdentifier(Identifier value)  { 
4097      this.groupIdentifier = value;
4098      return this;
4099    }
4100
4101    /**
4102     * @return {@link #status} (The current state of the request. For request groups, the status reflects the status of all the requests in the group.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value
4103     */
4104    public Enumeration<RequestStatus> getStatusElement() { 
4105      if (this.status == null)
4106        if (Configuration.errorOnAutoCreate())
4107          throw new Error("Attempt to auto-create RequestGroup.status");
4108        else if (Configuration.doAutoCreate())
4109          this.status = new Enumeration<RequestStatus>(new RequestStatusEnumFactory()); // bb
4110      return this.status;
4111    }
4112
4113    public boolean hasStatusElement() { 
4114      return this.status != null && !this.status.isEmpty();
4115    }
4116
4117    public boolean hasStatus() { 
4118      return this.status != null && !this.status.isEmpty();
4119    }
4120
4121    /**
4122     * @param value {@link #status} (The current state of the request. For request groups, the status reflects the status of all the requests in the group.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value
4123     */
4124    public RequestGroup setStatusElement(Enumeration<RequestStatus> value) { 
4125      this.status = value;
4126      return this;
4127    }
4128
4129    /**
4130     * @return The current state of the request. For request groups, the status reflects the status of all the requests in the group.
4131     */
4132    public RequestStatus getStatus() { 
4133      return this.status == null ? null : this.status.getValue();
4134    }
4135
4136    /**
4137     * @param value The current state of the request. For request groups, the status reflects the status of all the requests in the group.
4138     */
4139    public RequestGroup setStatus(RequestStatus value) { 
4140        if (this.status == null)
4141          this.status = new Enumeration<RequestStatus>(new RequestStatusEnumFactory());
4142        this.status.setValue(value);
4143      return this;
4144    }
4145
4146    /**
4147     * @return {@link #intent} (Indicates the level of authority/intentionality associated with the request and where the request fits into the workflow chain.). This is the underlying object with id, value and extensions. The accessor "getIntent" gives direct access to the value
4148     */
4149    public Enumeration<RequestIntent> getIntentElement() { 
4150      if (this.intent == null)
4151        if (Configuration.errorOnAutoCreate())
4152          throw new Error("Attempt to auto-create RequestGroup.intent");
4153        else if (Configuration.doAutoCreate())
4154          this.intent = new Enumeration<RequestIntent>(new RequestIntentEnumFactory()); // bb
4155      return this.intent;
4156    }
4157
4158    public boolean hasIntentElement() { 
4159      return this.intent != null && !this.intent.isEmpty();
4160    }
4161
4162    public boolean hasIntent() { 
4163      return this.intent != null && !this.intent.isEmpty();
4164    }
4165
4166    /**
4167     * @param value {@link #intent} (Indicates the level of authority/intentionality associated with the request and where the request fits into the workflow chain.). This is the underlying object with id, value and extensions. The accessor "getIntent" gives direct access to the value
4168     */
4169    public RequestGroup setIntentElement(Enumeration<RequestIntent> value) { 
4170      this.intent = value;
4171      return this;
4172    }
4173
4174    /**
4175     * @return Indicates the level of authority/intentionality associated with the request and where the request fits into the workflow chain.
4176     */
4177    public RequestIntent getIntent() { 
4178      return this.intent == null ? null : this.intent.getValue();
4179    }
4180
4181    /**
4182     * @param value Indicates the level of authority/intentionality associated with the request and where the request fits into the workflow chain.
4183     */
4184    public RequestGroup setIntent(RequestIntent value) { 
4185        if (this.intent == null)
4186          this.intent = new Enumeration<RequestIntent>(new RequestIntentEnumFactory());
4187        this.intent.setValue(value);
4188      return this;
4189    }
4190
4191    /**
4192     * @return {@link #priority} (Indicates how quickly the request should be addressed with respect to other requests.). This is the underlying object with id, value and extensions. The accessor "getPriority" gives direct access to the value
4193     */
4194    public Enumeration<RequestPriority> getPriorityElement() { 
4195      if (this.priority == null)
4196        if (Configuration.errorOnAutoCreate())
4197          throw new Error("Attempt to auto-create RequestGroup.priority");
4198        else if (Configuration.doAutoCreate())
4199          this.priority = new Enumeration<RequestPriority>(new RequestPriorityEnumFactory()); // bb
4200      return this.priority;
4201    }
4202
4203    public boolean hasPriorityElement() { 
4204      return this.priority != null && !this.priority.isEmpty();
4205    }
4206
4207    public boolean hasPriority() { 
4208      return this.priority != null && !this.priority.isEmpty();
4209    }
4210
4211    /**
4212     * @param value {@link #priority} (Indicates how quickly the request should be addressed with respect to other requests.). This is the underlying object with id, value and extensions. The accessor "getPriority" gives direct access to the value
4213     */
4214    public RequestGroup setPriorityElement(Enumeration<RequestPriority> value) { 
4215      this.priority = value;
4216      return this;
4217    }
4218
4219    /**
4220     * @return Indicates how quickly the request should be addressed with respect to other requests.
4221     */
4222    public RequestPriority getPriority() { 
4223      return this.priority == null ? null : this.priority.getValue();
4224    }
4225
4226    /**
4227     * @param value Indicates how quickly the request should be addressed with respect to other requests.
4228     */
4229    public RequestGroup setPriority(RequestPriority value) { 
4230      if (value == null)
4231        this.priority = null;
4232      else {
4233        if (this.priority == null)
4234          this.priority = new Enumeration<RequestPriority>(new RequestPriorityEnumFactory());
4235        this.priority.setValue(value);
4236      }
4237      return this;
4238    }
4239
4240    /**
4241     * @return {@link #subject} (The subject for which the request group was created.)
4242     */
4243    public Reference getSubject() { 
4244      if (this.subject == null)
4245        if (Configuration.errorOnAutoCreate())
4246          throw new Error("Attempt to auto-create RequestGroup.subject");
4247        else if (Configuration.doAutoCreate())
4248          this.subject = new Reference(); // cc
4249      return this.subject;
4250    }
4251
4252    public boolean hasSubject() { 
4253      return this.subject != null && !this.subject.isEmpty();
4254    }
4255
4256    /**
4257     * @param value {@link #subject} (The subject for which the request group was created.)
4258     */
4259    public RequestGroup setSubject(Reference value)  { 
4260      this.subject = value;
4261      return this;
4262    }
4263
4264    /**
4265     * @return {@link #subject} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (The subject for which the request group was created.)
4266     */
4267    public Resource getSubjectTarget() { 
4268      return this.subjectTarget;
4269    }
4270
4271    /**
4272     * @param value {@link #subject} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (The subject for which the request group was created.)
4273     */
4274    public RequestGroup setSubjectTarget(Resource value) { 
4275      this.subjectTarget = value;
4276      return this;
4277    }
4278
4279    /**
4280     * @return {@link #context} (Describes the context of the request group, if any.)
4281     */
4282    public Reference getContext() { 
4283      if (this.context == null)
4284        if (Configuration.errorOnAutoCreate())
4285          throw new Error("Attempt to auto-create RequestGroup.context");
4286        else if (Configuration.doAutoCreate())
4287          this.context = new Reference(); // cc
4288      return this.context;
4289    }
4290
4291    public boolean hasContext() { 
4292      return this.context != null && !this.context.isEmpty();
4293    }
4294
4295    /**
4296     * @param value {@link #context} (Describes the context of the request group, if any.)
4297     */
4298    public RequestGroup setContext(Reference value)  { 
4299      this.context = value;
4300      return this;
4301    }
4302
4303    /**
4304     * @return {@link #context} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (Describes the context of the request group, if any.)
4305     */
4306    public Resource getContextTarget() { 
4307      return this.contextTarget;
4308    }
4309
4310    /**
4311     * @param value {@link #context} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (Describes the context of the request group, if any.)
4312     */
4313    public RequestGroup setContextTarget(Resource value) { 
4314      this.contextTarget = value;
4315      return this;
4316    }
4317
4318    /**
4319     * @return {@link #authoredOn} (Indicates when the request group was created.). This is the underlying object with id, value and extensions. The accessor "getAuthoredOn" gives direct access to the value
4320     */
4321    public DateTimeType getAuthoredOnElement() { 
4322      if (this.authoredOn == null)
4323        if (Configuration.errorOnAutoCreate())
4324          throw new Error("Attempt to auto-create RequestGroup.authoredOn");
4325        else if (Configuration.doAutoCreate())
4326          this.authoredOn = new DateTimeType(); // bb
4327      return this.authoredOn;
4328    }
4329
4330    public boolean hasAuthoredOnElement() { 
4331      return this.authoredOn != null && !this.authoredOn.isEmpty();
4332    }
4333
4334    public boolean hasAuthoredOn() { 
4335      return this.authoredOn != null && !this.authoredOn.isEmpty();
4336    }
4337
4338    /**
4339     * @param value {@link #authoredOn} (Indicates when the request group was created.). This is the underlying object with id, value and extensions. The accessor "getAuthoredOn" gives direct access to the value
4340     */
4341    public RequestGroup setAuthoredOnElement(DateTimeType value) { 
4342      this.authoredOn = value;
4343      return this;
4344    }
4345
4346    /**
4347     * @return Indicates when the request group was created.
4348     */
4349    public Date getAuthoredOn() { 
4350      return this.authoredOn == null ? null : this.authoredOn.getValue();
4351    }
4352
4353    /**
4354     * @param value Indicates when the request group was created.
4355     */
4356    public RequestGroup setAuthoredOn(Date value) { 
4357      if (value == null)
4358        this.authoredOn = null;
4359      else {
4360        if (this.authoredOn == null)
4361          this.authoredOn = new DateTimeType();
4362        this.authoredOn.setValue(value);
4363      }
4364      return this;
4365    }
4366
4367    /**
4368     * @return {@link #author} (Provides a reference to the author of the request group.)
4369     */
4370    public Reference getAuthor() { 
4371      if (this.author == null)
4372        if (Configuration.errorOnAutoCreate())
4373          throw new Error("Attempt to auto-create RequestGroup.author");
4374        else if (Configuration.doAutoCreate())
4375          this.author = new Reference(); // cc
4376      return this.author;
4377    }
4378
4379    public boolean hasAuthor() { 
4380      return this.author != null && !this.author.isEmpty();
4381    }
4382
4383    /**
4384     * @param value {@link #author} (Provides a reference to the author of the request group.)
4385     */
4386    public RequestGroup setAuthor(Reference value)  { 
4387      this.author = value;
4388      return this;
4389    }
4390
4391    /**
4392     * @return {@link #author} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (Provides a reference to the author of the request group.)
4393     */
4394    public Resource getAuthorTarget() { 
4395      return this.authorTarget;
4396    }
4397
4398    /**
4399     * @param value {@link #author} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (Provides a reference to the author of the request group.)
4400     */
4401    public RequestGroup setAuthorTarget(Resource value) { 
4402      this.authorTarget = value;
4403      return this;
4404    }
4405
4406    /**
4407     * @return {@link #reason} (Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.)
4408     */
4409    public Type getReason() { 
4410      return this.reason;
4411    }
4412
4413    /**
4414     * @return {@link #reason} (Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.)
4415     */
4416    public CodeableConcept getReasonCodeableConcept() throws FHIRException { 
4417      if (this.reason == null)
4418        return null;
4419      if (!(this.reason instanceof CodeableConcept))
4420        throw new FHIRException("Type mismatch: the type CodeableConcept was expected, but "+this.reason.getClass().getName()+" was encountered");
4421      return (CodeableConcept) this.reason;
4422    }
4423
4424    public boolean hasReasonCodeableConcept() { 
4425      return this != null && this.reason instanceof CodeableConcept;
4426    }
4427
4428    /**
4429     * @return {@link #reason} (Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.)
4430     */
4431    public Reference getReasonReference() throws FHIRException { 
4432      if (this.reason == null)
4433        return null;
4434      if (!(this.reason instanceof Reference))
4435        throw new FHIRException("Type mismatch: the type Reference was expected, but "+this.reason.getClass().getName()+" was encountered");
4436      return (Reference) this.reason;
4437    }
4438
4439    public boolean hasReasonReference() { 
4440      return this != null && this.reason instanceof Reference;
4441    }
4442
4443    public boolean hasReason() { 
4444      return this.reason != null && !this.reason.isEmpty();
4445    }
4446
4447    /**
4448     * @param value {@link #reason} (Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.)
4449     */
4450    public RequestGroup setReason(Type value) throws FHIRFormatError { 
4451      if (value != null && !(value instanceof CodeableConcept || value instanceof Reference))
4452        throw new FHIRFormatError("Not the right type for RequestGroup.reason[x]: "+value.fhirType());
4453      this.reason = value;
4454      return this;
4455    }
4456
4457    /**
4458     * @return {@link #note} (Provides a mechanism to communicate additional information about the response.)
4459     */
4460    public List<Annotation> getNote() { 
4461      if (this.note == null)
4462        this.note = new ArrayList<Annotation>();
4463      return this.note;
4464    }
4465
4466    /**
4467     * @return Returns a reference to <code>this</code> for easy method chaining
4468     */
4469    public RequestGroup setNote(List<Annotation> theNote) { 
4470      this.note = theNote;
4471      return this;
4472    }
4473
4474    public boolean hasNote() { 
4475      if (this.note == null)
4476        return false;
4477      for (Annotation item : this.note)
4478        if (!item.isEmpty())
4479          return true;
4480      return false;
4481    }
4482
4483    public Annotation addNote() { //3
4484      Annotation t = new Annotation();
4485      if (this.note == null)
4486        this.note = new ArrayList<Annotation>();
4487      this.note.add(t);
4488      return t;
4489    }
4490
4491    public RequestGroup addNote(Annotation t) { //3
4492      if (t == null)
4493        return this;
4494      if (this.note == null)
4495        this.note = new ArrayList<Annotation>();
4496      this.note.add(t);
4497      return this;
4498    }
4499
4500    /**
4501     * @return The first repetition of repeating field {@link #note}, creating it if it does not already exist
4502     */
4503    public Annotation getNoteFirstRep() { 
4504      if (getNote().isEmpty()) {
4505        addNote();
4506      }
4507      return getNote().get(0);
4508    }
4509
4510    /**
4511     * @return {@link #action} (The actions, if any, produced by the evaluation of the artifact.)
4512     */
4513    public List<RequestGroupActionComponent> getAction() { 
4514      if (this.action == null)
4515        this.action = new ArrayList<RequestGroupActionComponent>();
4516      return this.action;
4517    }
4518
4519    /**
4520     * @return Returns a reference to <code>this</code> for easy method chaining
4521     */
4522    public RequestGroup setAction(List<RequestGroupActionComponent> theAction) { 
4523      this.action = theAction;
4524      return this;
4525    }
4526
4527    public boolean hasAction() { 
4528      if (this.action == null)
4529        return false;
4530      for (RequestGroupActionComponent item : this.action)
4531        if (!item.isEmpty())
4532          return true;
4533      return false;
4534    }
4535
4536    public RequestGroupActionComponent addAction() { //3
4537      RequestGroupActionComponent t = new RequestGroupActionComponent();
4538      if (this.action == null)
4539        this.action = new ArrayList<RequestGroupActionComponent>();
4540      this.action.add(t);
4541      return t;
4542    }
4543
4544    public RequestGroup addAction(RequestGroupActionComponent t) { //3
4545      if (t == null)
4546        return this;
4547      if (this.action == null)
4548        this.action = new ArrayList<RequestGroupActionComponent>();
4549      this.action.add(t);
4550      return this;
4551    }
4552
4553    /**
4554     * @return The first repetition of repeating field {@link #action}, creating it if it does not already exist
4555     */
4556    public RequestGroupActionComponent getActionFirstRep() { 
4557      if (getAction().isEmpty()) {
4558        addAction();
4559      }
4560      return getAction().get(0);
4561    }
4562
4563      protected void listChildren(List<Property> children) {
4564        super.listChildren(children);
4565        children.add(new Property("identifier", "Identifier", "Allows a service to provide a unique, business identifier for the request.", 0, java.lang.Integer.MAX_VALUE, identifier));
4566        children.add(new Property("definition", "Reference(Any)", "A protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request.", 0, java.lang.Integer.MAX_VALUE, definition));
4567        children.add(new Property("basedOn", "Reference(Any)", "A plan, proposal or order that is fulfilled in whole or in part by this request.", 0, java.lang.Integer.MAX_VALUE, basedOn));
4568        children.add(new Property("replaces", "Reference(Any)", "Completed or terminated request(s) whose function is taken by this new request.", 0, java.lang.Integer.MAX_VALUE, replaces));
4569        children.add(new Property("groupIdentifier", "Identifier", "A shared identifier common to all requests that were authorized more or less simultaneously by a single author, representing the identifier of the requisition, prescription or similar form.", 0, 1, groupIdentifier));
4570        children.add(new Property("status", "code", "The current state of the request. For request groups, the status reflects the status of all the requests in the group.", 0, 1, status));
4571        children.add(new Property("intent", "code", "Indicates the level of authority/intentionality associated with the request and where the request fits into the workflow chain.", 0, 1, intent));
4572        children.add(new Property("priority", "code", "Indicates how quickly the request should be addressed with respect to other requests.", 0, 1, priority));
4573        children.add(new Property("subject", "Reference(Patient|Group)", "The subject for which the request group was created.", 0, 1, subject));
4574        children.add(new Property("context", "Reference(Encounter|EpisodeOfCare)", "Describes the context of the request group, if any.", 0, 1, context));
4575        children.add(new Property("authoredOn", "dateTime", "Indicates when the request group was created.", 0, 1, authoredOn));
4576        children.add(new Property("author", "Reference(Device|Practitioner)", "Provides a reference to the author of the request group.", 0, 1, author));
4577        children.add(new Property("reason[x]", "CodeableConcept|Reference(Any)", "Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.", 0, 1, reason));
4578        children.add(new Property("note", "Annotation", "Provides a mechanism to communicate additional information about the response.", 0, java.lang.Integer.MAX_VALUE, note));
4579        children.add(new Property("action", "", "The actions, if any, produced by the evaluation of the artifact.", 0, java.lang.Integer.MAX_VALUE, action));
4580      }
4581
4582      @Override
4583      public Property getNamedProperty(int _hash, String _name, boolean _checkValid) throws FHIRException {
4584        switch (_hash) {
4585        case -1618432855: /*identifier*/  return new Property("identifier", "Identifier", "Allows a service to provide a unique, business identifier for the request.", 0, java.lang.Integer.MAX_VALUE, identifier);
4586        case -1014418093: /*definition*/  return new Property("definition", "Reference(Any)", "A protocol, guideline, orderset or other definition that is adhered to in whole or in part by this request.", 0, java.lang.Integer.MAX_VALUE, definition);
4587        case -332612366: /*basedOn*/  return new Property("basedOn", "Reference(Any)", "A plan, proposal or order that is fulfilled in whole or in part by this request.", 0, java.lang.Integer.MAX_VALUE, basedOn);
4588        case -430332865: /*replaces*/  return new Property("replaces", "Reference(Any)", "Completed or terminated request(s) whose function is taken by this new request.", 0, java.lang.Integer.MAX_VALUE, replaces);
4589        case -445338488: /*groupIdentifier*/  return new Property("groupIdentifier", "Identifier", "A shared identifier common to all requests that were authorized more or less simultaneously by a single author, representing the identifier of the requisition, prescription or similar form.", 0, 1, groupIdentifier);
4590        case -892481550: /*status*/  return new Property("status", "code", "The current state of the request. For request groups, the status reflects the status of all the requests in the group.", 0, 1, status);
4591        case -1183762788: /*intent*/  return new Property("intent", "code", "Indicates the level of authority/intentionality associated with the request and where the request fits into the workflow chain.", 0, 1, intent);
4592        case -1165461084: /*priority*/  return new Property("priority", "code", "Indicates how quickly the request should be addressed with respect to other requests.", 0, 1, priority);
4593        case -1867885268: /*subject*/  return new Property("subject", "Reference(Patient|Group)", "The subject for which the request group was created.", 0, 1, subject);
4594        case 951530927: /*context*/  return new Property("context", "Reference(Encounter|EpisodeOfCare)", "Describes the context of the request group, if any.", 0, 1, context);
4595        case -1500852503: /*authoredOn*/  return new Property("authoredOn", "dateTime", "Indicates when the request group was created.", 0, 1, authoredOn);
4596        case -1406328437: /*author*/  return new Property("author", "Reference(Device|Practitioner)", "Provides a reference to the author of the request group.", 0, 1, author);
4597        case -669418564: /*reason[x]*/  return new Property("reason[x]", "CodeableConcept|Reference(Any)", "Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.", 0, 1, reason);
4598        case -934964668: /*reason*/  return new Property("reason[x]", "CodeableConcept|Reference(Any)", "Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.", 0, 1, reason);
4599        case -610155331: /*reasonCodeableConcept*/  return new Property("reason[x]", "CodeableConcept|Reference(Any)", "Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.", 0, 1, reason);
4600        case -1146218137: /*reasonReference*/  return new Property("reason[x]", "CodeableConcept|Reference(Any)", "Indicates the reason the request group was created. This is typically provided as a parameter to the evaluation and echoed by the service, although for some use cases, such as subscription- or event-based scenarios, it may provide an indication of the cause for the response.", 0, 1, reason);
4601        case 3387378: /*note*/  return new Property("note", "Annotation", "Provides a mechanism to communicate additional information about the response.", 0, java.lang.Integer.MAX_VALUE, note);
4602        case -1422950858: /*action*/  return new Property("action", "", "The actions, if any, produced by the evaluation of the artifact.", 0, java.lang.Integer.MAX_VALUE, action);
4603        default: return super.getNamedProperty(_hash, _name, _checkValid);
4604        }
4605
4606      }
4607
4608      @Override
4609      public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
4610        switch (hash) {
4611        case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier
4612        case -1014418093: /*definition*/ return this.definition == null ? new Base[0] : this.definition.toArray(new Base[this.definition.size()]); // Reference
4613        case -332612366: /*basedOn*/ return this.basedOn == null ? new Base[0] : this.basedOn.toArray(new Base[this.basedOn.size()]); // Reference
4614        case -430332865: /*replaces*/ return this.replaces == null ? new Base[0] : this.replaces.toArray(new Base[this.replaces.size()]); // Reference
4615        case -445338488: /*groupIdentifier*/ return this.groupIdentifier == null ? new Base[0] : new Base[] {this.groupIdentifier}; // Identifier
4616        case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // Enumeration<RequestStatus>
4617        case -1183762788: /*intent*/ return this.intent == null ? new Base[0] : new Base[] {this.intent}; // Enumeration<RequestIntent>
4618        case -1165461084: /*priority*/ return this.priority == null ? new Base[0] : new Base[] {this.priority}; // Enumeration<RequestPriority>
4619        case -1867885268: /*subject*/ return this.subject == null ? new Base[0] : new Base[] {this.subject}; // Reference
4620        case 951530927: /*context*/ return this.context == null ? new Base[0] : new Base[] {this.context}; // Reference
4621        case -1500852503: /*authoredOn*/ return this.authoredOn == null ? new Base[0] : new Base[] {this.authoredOn}; // DateTimeType
4622        case -1406328437: /*author*/ return this.author == null ? new Base[0] : new Base[] {this.author}; // Reference
4623        case -934964668: /*reason*/ return this.reason == null ? new Base[0] : new Base[] {this.reason}; // Type
4624        case 3387378: /*note*/ return this.note == null ? new Base[0] : this.note.toArray(new Base[this.note.size()]); // Annotation
4625        case -1422950858: /*action*/ return this.action == null ? new Base[0] : this.action.toArray(new Base[this.action.size()]); // RequestGroupActionComponent
4626        default: return super.getProperty(hash, name, checkValid);
4627        }
4628
4629      }
4630
4631      @Override
4632      public Base setProperty(int hash, String name, Base value) throws FHIRException {
4633        switch (hash) {
4634        case -1618432855: // identifier
4635          this.getIdentifier().add(castToIdentifier(value)); // Identifier
4636          return value;
4637        case -1014418093: // definition
4638          this.getDefinition().add(castToReference(value)); // Reference
4639          return value;
4640        case -332612366: // basedOn
4641          this.getBasedOn().add(castToReference(value)); // Reference
4642          return value;
4643        case -430332865: // replaces
4644          this.getReplaces().add(castToReference(value)); // Reference
4645          return value;
4646        case -445338488: // groupIdentifier
4647          this.groupIdentifier = castToIdentifier(value); // Identifier
4648          return value;
4649        case -892481550: // status
4650          value = new RequestStatusEnumFactory().fromType(castToCode(value));
4651          this.status = (Enumeration) value; // Enumeration<RequestStatus>
4652          return value;
4653        case -1183762788: // intent
4654          value = new RequestIntentEnumFactory().fromType(castToCode(value));
4655          this.intent = (Enumeration) value; // Enumeration<RequestIntent>
4656          return value;
4657        case -1165461084: // priority
4658          value = new RequestPriorityEnumFactory().fromType(castToCode(value));
4659          this.priority = (Enumeration) value; // Enumeration<RequestPriority>
4660          return value;
4661        case -1867885268: // subject
4662          this.subject = castToReference(value); // Reference
4663          return value;
4664        case 951530927: // context
4665          this.context = castToReference(value); // Reference
4666          return value;
4667        case -1500852503: // authoredOn
4668          this.authoredOn = castToDateTime(value); // DateTimeType
4669          return value;
4670        case -1406328437: // author
4671          this.author = castToReference(value); // Reference
4672          return value;
4673        case -934964668: // reason
4674          this.reason = castToType(value); // Type
4675          return value;
4676        case 3387378: // note
4677          this.getNote().add(castToAnnotation(value)); // Annotation
4678          return value;
4679        case -1422950858: // action
4680          this.getAction().add((RequestGroupActionComponent) value); // RequestGroupActionComponent
4681          return value;
4682        default: return super.setProperty(hash, name, value);
4683        }
4684
4685      }
4686
4687      @Override
4688      public Base setProperty(String name, Base value) throws FHIRException {
4689        if (name.equals("identifier")) {
4690          this.getIdentifier().add(castToIdentifier(value));
4691        } else if (name.equals("definition")) {
4692          this.getDefinition().add(castToReference(value));
4693        } else if (name.equals("basedOn")) {
4694          this.getBasedOn().add(castToReference(value));
4695        } else if (name.equals("replaces")) {
4696          this.getReplaces().add(castToReference(value));
4697        } else if (name.equals("groupIdentifier")) {
4698          this.groupIdentifier = castToIdentifier(value); // Identifier
4699        } else if (name.equals("status")) {
4700          value = new RequestStatusEnumFactory().fromType(castToCode(value));
4701          this.status = (Enumeration) value; // Enumeration<RequestStatus>
4702        } else if (name.equals("intent")) {
4703          value = new RequestIntentEnumFactory().fromType(castToCode(value));
4704          this.intent = (Enumeration) value; // Enumeration<RequestIntent>
4705        } else if (name.equals("priority")) {
4706          value = new RequestPriorityEnumFactory().fromType(castToCode(value));
4707          this.priority = (Enumeration) value; // Enumeration<RequestPriority>
4708        } else if (name.equals("subject")) {
4709          this.subject = castToReference(value); // Reference
4710        } else if (name.equals("context")) {
4711          this.context = castToReference(value); // Reference
4712        } else if (name.equals("authoredOn")) {
4713          this.authoredOn = castToDateTime(value); // DateTimeType
4714        } else if (name.equals("author")) {
4715          this.author = castToReference(value); // Reference
4716        } else if (name.equals("reason[x]")) {
4717          this.reason = castToType(value); // Type
4718        } else if (name.equals("note")) {
4719          this.getNote().add(castToAnnotation(value));
4720        } else if (name.equals("action")) {
4721          this.getAction().add((RequestGroupActionComponent) value);
4722        } else
4723          return super.setProperty(name, value);
4724        return value;
4725      }
4726
4727      @Override
4728      public Base makeProperty(int hash, String name) throws FHIRException {
4729        switch (hash) {
4730        case -1618432855:  return addIdentifier(); 
4731        case -1014418093:  return addDefinition(); 
4732        case -332612366:  return addBasedOn(); 
4733        case -430332865:  return addReplaces(); 
4734        case -445338488:  return getGroupIdentifier(); 
4735        case -892481550:  return getStatusElement();
4736        case -1183762788:  return getIntentElement();
4737        case -1165461084:  return getPriorityElement();
4738        case -1867885268:  return getSubject(); 
4739        case 951530927:  return getContext(); 
4740        case -1500852503:  return getAuthoredOnElement();
4741        case -1406328437:  return getAuthor(); 
4742        case -669418564:  return getReason(); 
4743        case -934964668:  return getReason(); 
4744        case 3387378:  return addNote(); 
4745        case -1422950858:  return addAction(); 
4746        default: return super.makeProperty(hash, name);
4747        }
4748
4749      }
4750
4751      @Override
4752      public String[] getTypesForProperty(int hash, String name) throws FHIRException {
4753        switch (hash) {
4754        case -1618432855: /*identifier*/ return new String[] {"Identifier"};
4755        case -1014418093: /*definition*/ return new String[] {"Reference"};
4756        case -332612366: /*basedOn*/ return new String[] {"Reference"};
4757        case -430332865: /*replaces*/ return new String[] {"Reference"};
4758        case -445338488: /*groupIdentifier*/ return new String[] {"Identifier"};
4759        case -892481550: /*status*/ return new String[] {"code"};
4760        case -1183762788: /*intent*/ return new String[] {"code"};
4761        case -1165461084: /*priority*/ return new String[] {"code"};
4762        case -1867885268: /*subject*/ return new String[] {"Reference"};
4763        case 951530927: /*context*/ return new String[] {"Reference"};
4764        case -1500852503: /*authoredOn*/ return new String[] {"dateTime"};
4765        case -1406328437: /*author*/ return new String[] {"Reference"};
4766        case -934964668: /*reason*/ return new String[] {"CodeableConcept", "Reference"};
4767        case 3387378: /*note*/ return new String[] {"Annotation"};
4768        case -1422950858: /*action*/ return new String[] {};
4769        default: return super.getTypesForProperty(hash, name);
4770        }
4771
4772      }
4773
4774      @Override
4775      public Base addChild(String name) throws FHIRException {
4776        if (name.equals("identifier")) {
4777          return addIdentifier();
4778        }
4779        else if (name.equals("definition")) {
4780          return addDefinition();
4781        }
4782        else if (name.equals("basedOn")) {
4783          return addBasedOn();
4784        }
4785        else if (name.equals("replaces")) {
4786          return addReplaces();
4787        }
4788        else if (name.equals("groupIdentifier")) {
4789          this.groupIdentifier = new Identifier();
4790          return this.groupIdentifier;
4791        }
4792        else if (name.equals("status")) {
4793          throw new FHIRException("Cannot call addChild on a primitive type RequestGroup.status");
4794        }
4795        else if (name.equals("intent")) {
4796          throw new FHIRException("Cannot call addChild on a primitive type RequestGroup.intent");
4797        }
4798        else if (name.equals("priority")) {
4799          throw new FHIRException("Cannot call addChild on a primitive type RequestGroup.priority");
4800        }
4801        else if (name.equals("subject")) {
4802          this.subject = new Reference();
4803          return this.subject;
4804        }
4805        else if (name.equals("context")) {
4806          this.context = new Reference();
4807          return this.context;
4808        }
4809        else if (name.equals("authoredOn")) {
4810          throw new FHIRException("Cannot call addChild on a primitive type RequestGroup.authoredOn");
4811        }
4812        else if (name.equals("author")) {
4813          this.author = new Reference();
4814          return this.author;
4815        }
4816        else if (name.equals("reasonCodeableConcept")) {
4817          this.reason = new CodeableConcept();
4818          return this.reason;
4819        }
4820        else if (name.equals("reasonReference")) {
4821          this.reason = new Reference();
4822          return this.reason;
4823        }
4824        else if (name.equals("note")) {
4825          return addNote();
4826        }
4827        else if (name.equals("action")) {
4828          return addAction();
4829        }
4830        else
4831          return super.addChild(name);
4832      }
4833
4834  public String fhirType() {
4835    return "RequestGroup";
4836
4837  }
4838
4839      public RequestGroup copy() {
4840        RequestGroup dst = new RequestGroup();
4841        copyValues(dst);
4842        if (identifier != null) {
4843          dst.identifier = new ArrayList<Identifier>();
4844          for (Identifier i : identifier)
4845            dst.identifier.add(i.copy());
4846        };
4847        if (definition != null) {
4848          dst.definition = new ArrayList<Reference>();
4849          for (Reference i : definition)
4850            dst.definition.add(i.copy());
4851        };
4852        if (basedOn != null) {
4853          dst.basedOn = new ArrayList<Reference>();
4854          for (Reference i : basedOn)
4855            dst.basedOn.add(i.copy());
4856        };
4857        if (replaces != null) {
4858          dst.replaces = new ArrayList<Reference>();
4859          for (Reference i : replaces)
4860            dst.replaces.add(i.copy());
4861        };
4862        dst.groupIdentifier = groupIdentifier == null ? null : groupIdentifier.copy();
4863        dst.status = status == null ? null : status.copy();
4864        dst.intent = intent == null ? null : intent.copy();
4865        dst.priority = priority == null ? null : priority.copy();
4866        dst.subject = subject == null ? null : subject.copy();
4867        dst.context = context == null ? null : context.copy();
4868        dst.authoredOn = authoredOn == null ? null : authoredOn.copy();
4869        dst.author = author == null ? null : author.copy();
4870        dst.reason = reason == null ? null : reason.copy();
4871        if (note != null) {
4872          dst.note = new ArrayList<Annotation>();
4873          for (Annotation i : note)
4874            dst.note.add(i.copy());
4875        };
4876        if (action != null) {
4877          dst.action = new ArrayList<RequestGroupActionComponent>();
4878          for (RequestGroupActionComponent i : action)
4879            dst.action.add(i.copy());
4880        };
4881        return dst;
4882      }
4883
4884      protected RequestGroup typedCopy() {
4885        return copy();
4886      }
4887
4888      @Override
4889      public boolean equalsDeep(Base other_) {
4890        if (!super.equalsDeep(other_))
4891          return false;
4892        if (!(other_ instanceof RequestGroup))
4893          return false;
4894        RequestGroup o = (RequestGroup) other_;
4895        return compareDeep(identifier, o.identifier, true) && compareDeep(definition, o.definition, true)
4896           && compareDeep(basedOn, o.basedOn, true) && compareDeep(replaces, o.replaces, true) && compareDeep(groupIdentifier, o.groupIdentifier, true)
4897           && compareDeep(status, o.status, true) && compareDeep(intent, o.intent, true) && compareDeep(priority, o.priority, true)
4898           && compareDeep(subject, o.subject, true) && compareDeep(context, o.context, true) && compareDeep(authoredOn, o.authoredOn, true)
4899           && compareDeep(author, o.author, true) && compareDeep(reason, o.reason, true) && compareDeep(note, o.note, true)
4900           && compareDeep(action, o.action, true);
4901      }
4902
4903      @Override
4904      public boolean equalsShallow(Base other_) {
4905        if (!super.equalsShallow(other_))
4906          return false;
4907        if (!(other_ instanceof RequestGroup))
4908          return false;
4909        RequestGroup o = (RequestGroup) other_;
4910        return compareValues(status, o.status, true) && compareValues(intent, o.intent, true) && compareValues(priority, o.priority, true)
4911           && compareValues(authoredOn, o.authoredOn, true);
4912      }
4913
4914      public boolean isEmpty() {
4915        return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(identifier, definition, basedOn
4916          , replaces, groupIdentifier, status, intent, priority, subject, context, authoredOn
4917          , author, reason, note, action);
4918      }
4919
4920  @Override
4921  public ResourceType getResourceType() {
4922    return ResourceType.RequestGroup;
4923   }
4924
4925 /**
4926   * Search parameter: <b>authored</b>
4927   * <p>
4928   * Description: <b>The date the request group was authored</b><br>
4929   * Type: <b>date</b><br>
4930   * Path: <b>RequestGroup.authoredOn</b><br>
4931   * </p>
4932   */
4933  @SearchParamDefinition(name="authored", path="RequestGroup.authoredOn", description="The date the request group was authored", type="date" )
4934  public static final String SP_AUTHORED = "authored";
4935 /**
4936   * <b>Fluent Client</b> search parameter constant for <b>authored</b>
4937   * <p>
4938   * Description: <b>The date the request group was authored</b><br>
4939   * Type: <b>date</b><br>
4940   * Path: <b>RequestGroup.authoredOn</b><br>
4941   * </p>
4942   */
4943  public static final ca.uhn.fhir.rest.gclient.DateClientParam AUTHORED = new ca.uhn.fhir.rest.gclient.DateClientParam(SP_AUTHORED);
4944
4945 /**
4946   * Search parameter: <b>identifier</b>
4947   * <p>
4948   * Description: <b>External identifiers for the request group</b><br>
4949   * Type: <b>token</b><br>
4950   * Path: <b>RequestGroup.identifier</b><br>
4951   * </p>
4952   */
4953  @SearchParamDefinition(name="identifier", path="RequestGroup.identifier", description="External identifiers for the request group", type="token" )
4954  public static final String SP_IDENTIFIER = "identifier";
4955 /**
4956   * <b>Fluent Client</b> search parameter constant for <b>identifier</b>
4957   * <p>
4958   * Description: <b>External identifiers for the request group</b><br>
4959   * Type: <b>token</b><br>
4960   * Path: <b>RequestGroup.identifier</b><br>
4961   * </p>
4962   */
4963  public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER);
4964
4965 /**
4966   * Search parameter: <b>subject</b>
4967   * <p>
4968   * Description: <b>The subject that the request group is about</b><br>
4969   * Type: <b>reference</b><br>
4970   * Path: <b>RequestGroup.subject</b><br>
4971   * </p>
4972   */
4973  @SearchParamDefinition(name="subject", path="RequestGroup.subject", description="The subject that the request group is about", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient") }, target={Group.class, Patient.class } )
4974  public static final String SP_SUBJECT = "subject";
4975 /**
4976   * <b>Fluent Client</b> search parameter constant for <b>subject</b>
4977   * <p>
4978   * Description: <b>The subject that the request group is about</b><br>
4979   * Type: <b>reference</b><br>
4980   * Path: <b>RequestGroup.subject</b><br>
4981   * </p>
4982   */
4983  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam SUBJECT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_SUBJECT);
4984
4985/**
4986   * Constant for fluent queries to be used to add include statements. Specifies
4987   * the path value of "<b>RequestGroup:subject</b>".
4988   */
4989  public static final ca.uhn.fhir.model.api.Include INCLUDE_SUBJECT = new ca.uhn.fhir.model.api.Include("RequestGroup:subject").toLocked();
4990
4991 /**
4992   * Search parameter: <b>author</b>
4993   * <p>
4994   * Description: <b>The author of the request group</b><br>
4995   * Type: <b>reference</b><br>
4996   * Path: <b>RequestGroup.author</b><br>
4997   * </p>
4998   */
4999  @SearchParamDefinition(name="author", path="RequestGroup.author", description="The author of the request group", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Device"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner") }, target={Device.class, Practitioner.class } )
5000  public static final String SP_AUTHOR = "author";
5001 /**
5002   * <b>Fluent Client</b> search parameter constant for <b>author</b>
5003   * <p>
5004   * Description: <b>The author of the request group</b><br>
5005   * Type: <b>reference</b><br>
5006   * Path: <b>RequestGroup.author</b><br>
5007   * </p>
5008   */
5009  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam AUTHOR = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_AUTHOR);
5010
5011/**
5012   * Constant for fluent queries to be used to add include statements. Specifies
5013   * the path value of "<b>RequestGroup:author</b>".
5014   */
5015  public static final ca.uhn.fhir.model.api.Include INCLUDE_AUTHOR = new ca.uhn.fhir.model.api.Include("RequestGroup:author").toLocked();
5016
5017 /**
5018   * Search parameter: <b>encounter</b>
5019   * <p>
5020   * Description: <b>The encounter the request group applies to</b><br>
5021   * Type: <b>reference</b><br>
5022   * Path: <b>RequestGroup.context</b><br>
5023   * </p>
5024   */
5025  @SearchParamDefinition(name="encounter", path="RequestGroup.context", description="The encounter the request group applies to", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Encounter") }, target={Encounter.class } )
5026  public static final String SP_ENCOUNTER = "encounter";
5027 /**
5028   * <b>Fluent Client</b> search parameter constant for <b>encounter</b>
5029   * <p>
5030   * Description: <b>The encounter the request group applies to</b><br>
5031   * Type: <b>reference</b><br>
5032   * Path: <b>RequestGroup.context</b><br>
5033   * </p>
5034   */
5035  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam ENCOUNTER = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_ENCOUNTER);
5036
5037/**
5038   * Constant for fluent queries to be used to add include statements. Specifies
5039   * the path value of "<b>RequestGroup:encounter</b>".
5040   */
5041  public static final ca.uhn.fhir.model.api.Include INCLUDE_ENCOUNTER = new ca.uhn.fhir.model.api.Include("RequestGroup:encounter").toLocked();
5042
5043 /**
5044   * Search parameter: <b>priority</b>
5045   * <p>
5046   * Description: <b>The priority of the request group</b><br>
5047   * Type: <b>token</b><br>
5048   * Path: <b>RequestGroup.priority</b><br>
5049   * </p>
5050   */
5051  @SearchParamDefinition(name="priority", path="RequestGroup.priority", description="The priority of the request group", type="token" )
5052  public static final String SP_PRIORITY = "priority";
5053 /**
5054   * <b>Fluent Client</b> search parameter constant for <b>priority</b>
5055   * <p>
5056   * Description: <b>The priority of the request group</b><br>
5057   * Type: <b>token</b><br>
5058   * Path: <b>RequestGroup.priority</b><br>
5059   * </p>
5060   */
5061  public static final ca.uhn.fhir.rest.gclient.TokenClientParam PRIORITY = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_PRIORITY);
5062
5063 /**
5064   * Search parameter: <b>intent</b>
5065   * <p>
5066   * Description: <b>The intent of the request group</b><br>
5067   * Type: <b>token</b><br>
5068   * Path: <b>RequestGroup.intent</b><br>
5069   * </p>
5070   */
5071  @SearchParamDefinition(name="intent", path="RequestGroup.intent", description="The intent of the request group", type="token" )
5072  public static final String SP_INTENT = "intent";
5073 /**
5074   * <b>Fluent Client</b> search parameter constant for <b>intent</b>
5075   * <p>
5076   * Description: <b>The intent of the request group</b><br>
5077   * Type: <b>token</b><br>
5078   * Path: <b>RequestGroup.intent</b><br>
5079   * </p>
5080   */
5081  public static final ca.uhn.fhir.rest.gclient.TokenClientParam INTENT = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_INTENT);
5082
5083 /**
5084   * Search parameter: <b>participant</b>
5085   * <p>
5086   * Description: <b>The participant in the requests in the group</b><br>
5087   * Type: <b>reference</b><br>
5088   * Path: <b>RequestGroup.action.participant</b><br>
5089   * </p>
5090   */
5091  @SearchParamDefinition(name="participant", path="RequestGroup.action.participant", description="The participant in the requests in the group", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner"), @ca.uhn.fhir.model.api.annotation.Compartment(name="RelatedPerson") }, target={Patient.class, Person.class, Practitioner.class, RelatedPerson.class } )
5092  public static final String SP_PARTICIPANT = "participant";
5093 /**
5094   * <b>Fluent Client</b> search parameter constant for <b>participant</b>
5095   * <p>
5096   * Description: <b>The participant in the requests in the group</b><br>
5097   * Type: <b>reference</b><br>
5098   * Path: <b>RequestGroup.action.participant</b><br>
5099   * </p>
5100   */
5101  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PARTICIPANT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_PARTICIPANT);
5102
5103/**
5104   * Constant for fluent queries to be used to add include statements. Specifies
5105   * the path value of "<b>RequestGroup:participant</b>".
5106   */
5107  public static final ca.uhn.fhir.model.api.Include INCLUDE_PARTICIPANT = new ca.uhn.fhir.model.api.Include("RequestGroup:participant").toLocked();
5108
5109 /**
5110   * Search parameter: <b>group-identifier</b>
5111   * <p>
5112   * Description: <b>The group identifier for the request group</b><br>
5113   * Type: <b>token</b><br>
5114   * Path: <b>RequestGroup.groupIdentifier</b><br>
5115   * </p>
5116   */
5117  @SearchParamDefinition(name="group-identifier", path="RequestGroup.groupIdentifier", description="The group identifier for the request group", type="token" )
5118  public static final String SP_GROUP_IDENTIFIER = "group-identifier";
5119 /**
5120   * <b>Fluent Client</b> search parameter constant for <b>group-identifier</b>
5121   * <p>
5122   * Description: <b>The group identifier for the request group</b><br>
5123   * Type: <b>token</b><br>
5124   * Path: <b>RequestGroup.groupIdentifier</b><br>
5125   * </p>
5126   */
5127  public static final ca.uhn.fhir.rest.gclient.TokenClientParam GROUP_IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_GROUP_IDENTIFIER);
5128
5129 /**
5130   * Search parameter: <b>patient</b>
5131   * <p>
5132   * Description: <b>The identity of a patient to search for request groups</b><br>
5133   * Type: <b>reference</b><br>
5134   * Path: <b>RequestGroup.subject</b><br>
5135   * </p>
5136   */
5137  @SearchParamDefinition(name="patient", path="RequestGroup.subject", description="The identity of a patient to search for request groups", type="reference", target={Patient.class } )
5138  public static final String SP_PATIENT = "patient";
5139 /**
5140   * <b>Fluent Client</b> search parameter constant for <b>patient</b>
5141   * <p>
5142   * Description: <b>The identity of a patient to search for request groups</b><br>
5143   * Type: <b>reference</b><br>
5144   * Path: <b>RequestGroup.subject</b><br>
5145   * </p>
5146   */
5147  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam PATIENT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_PATIENT);
5148
5149/**
5150   * Constant for fluent queries to be used to add include statements. Specifies
5151   * the path value of "<b>RequestGroup:patient</b>".
5152   */
5153  public static final ca.uhn.fhir.model.api.Include INCLUDE_PATIENT = new ca.uhn.fhir.model.api.Include("RequestGroup:patient").toLocked();
5154
5155 /**
5156   * Search parameter: <b>context</b>
5157   * <p>
5158   * Description: <b>The context the request group applies to</b><br>
5159   * Type: <b>reference</b><br>
5160   * Path: <b>RequestGroup.context</b><br>
5161   * </p>
5162   */
5163  @SearchParamDefinition(name="context", path="RequestGroup.context", description="The context the request group applies to", type="reference", target={Encounter.class, EpisodeOfCare.class } )
5164  public static final String SP_CONTEXT = "context";
5165 /**
5166   * <b>Fluent Client</b> search parameter constant for <b>context</b>
5167   * <p>
5168   * Description: <b>The context the request group applies to</b><br>
5169   * Type: <b>reference</b><br>
5170   * Path: <b>RequestGroup.context</b><br>
5171   * </p>
5172   */
5173  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam CONTEXT = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_CONTEXT);
5174
5175/**
5176   * Constant for fluent queries to be used to add include statements. Specifies
5177   * the path value of "<b>RequestGroup:context</b>".
5178   */
5179  public static final ca.uhn.fhir.model.api.Include INCLUDE_CONTEXT = new ca.uhn.fhir.model.api.Include("RequestGroup:context").toLocked();
5180
5181 /**
5182   * Search parameter: <b>definition</b>
5183   * <p>
5184   * Description: <b>The definition from which the request group is realized</b><br>
5185   * Type: <b>reference</b><br>
5186   * Path: <b>RequestGroup.definition</b><br>
5187   * </p>
5188   */
5189  @SearchParamDefinition(name="definition", path="RequestGroup.definition", description="The definition from which the request group is realized", type="reference" )
5190  public static final String SP_DEFINITION = "definition";
5191 /**
5192   * <b>Fluent Client</b> search parameter constant for <b>definition</b>
5193   * <p>
5194   * Description: <b>The definition from which the request group is realized</b><br>
5195   * Type: <b>reference</b><br>
5196   * Path: <b>RequestGroup.definition</b><br>
5197   * </p>
5198   */
5199  public static final ca.uhn.fhir.rest.gclient.ReferenceClientParam DEFINITION = new ca.uhn.fhir.rest.gclient.ReferenceClientParam(SP_DEFINITION);
5200
5201/**
5202   * Constant for fluent queries to be used to add include statements. Specifies
5203   * the path value of "<b>RequestGroup:definition</b>".
5204   */
5205  public static final ca.uhn.fhir.model.api.Include INCLUDE_DEFINITION = new ca.uhn.fhir.model.api.Include("RequestGroup:definition").toLocked();
5206
5207 /**
5208   * Search parameter: <b>status</b>
5209   * <p>
5210   * Description: <b>The status of the request group</b><br>
5211   * Type: <b>token</b><br>
5212   * Path: <b>RequestGroup.status</b><br>
5213   * </p>
5214   */
5215  @SearchParamDefinition(name="status", path="RequestGroup.status", description="The status of the request group", type="token" )
5216  public static final String SP_STATUS = "status";
5217 /**
5218   * <b>Fluent Client</b> search parameter constant for <b>status</b>
5219   * <p>
5220   * Description: <b>The status of the request group</b><br>
5221   * Type: <b>token</b><br>
5222   * Path: <b>RequestGroup.status</b><br>
5223   * </p>
5224   */
5225  public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS);
5226
5227
5228}