1   /*
2    * SPDX-FileCopyrightText: none
3    * SPDX-License-Identifier: CC0-1.0
4    */
5   // Generated from: ../../../../../../metaschema/metaschema-bindings.yaml
6   // Do not edit - changes will be lost when regenerated.
7   
8   package dev.metaschema.databind.config.binding;
9   
10  import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
11  import org.apache.commons.lang3.builder.ToStringStyle;
12  
13  import java.net.URI;
14  import java.util.LinkedList;
15  import java.util.List;
16  
17  import dev.metaschema.core.datatype.adapter.BooleanAdapter;
18  import dev.metaschema.core.datatype.adapter.StringAdapter;
19  import dev.metaschema.core.datatype.adapter.TokenAdapter;
20  import dev.metaschema.core.datatype.adapter.UriAdapter;
21  import dev.metaschema.core.datatype.adapter.UriReferenceAdapter;
22  import dev.metaschema.core.model.IBoundObject;
23  import dev.metaschema.core.model.IMetaschemaData;
24  import dev.metaschema.core.model.JsonGroupAsBehavior;
25  import dev.metaschema.core.util.ObjectUtils;
26  import dev.metaschema.databind.model.annotations.BoundAssembly;
27  import dev.metaschema.databind.model.annotations.BoundField;
28  import dev.metaschema.databind.model.annotations.BoundFieldValue;
29  import dev.metaschema.databind.model.annotations.BoundFlag;
30  import dev.metaschema.databind.model.annotations.GroupAs;
31  import dev.metaschema.databind.model.annotations.MetaschemaAssembly;
32  import dev.metaschema.databind.model.annotations.MetaschemaField;
33  import edu.umd.cs.findbugs.annotations.NonNull;
34  import edu.umd.cs.findbugs.annotations.Nullable;
35  
36  /**
37   * The root element for a set of metaschema binding customizations.
38   */
39  @MetaschemaAssembly(
40      formalName = "Metaschema Bindings",
41      description = "The root element for a set of metaschema binding customizations.",
42      name = "metaschema-bindings",
43      moduleClass = MetaschemaBindingsModule.class,
44      rootName = "metaschema-bindings")
45  public class MetaschemaBindings implements IBoundObject {
46    private final IMetaschemaData __metaschemaData;
47  
48    /**
49     * Defines binding configurations that apply to a whole model described by a
50     * namespace.
51     */
52    @BoundAssembly(
53        formalName = "Model Binding",
54        description = "Defines binding configurations that apply to a whole model described by a namespace.",
55        useName = "model-binding",
56        maxOccurs = -1,
57        groupAs = @GroupAs(name = "model-bindings", inJson = JsonGroupAsBehavior.LIST))
58    private List<ModelBinding> _modelBindings;
59  
60    /**
61     * Defines a binding for a given metaschema identified by a relative URL.
62     */
63    @BoundAssembly(
64        formalName = "Metaschema Binding",
65        description = "Defines a binding for a given metaschema identified by a relative URL.",
66        useName = "metaschema-binding",
67        maxOccurs = -1,
68        groupAs = @GroupAs(name = "metaschema-bindings", inJson = JsonGroupAsBehavior.LIST))
69    private List<MetaschemaBinding> _metaschemaBindings;
70  
71    /**
72     * Constructs a new
73     * {@code dev.metaschema.databind.config.binding.MetaschemaBindings} instance
74     * with no metadata.
75     */
76    public MetaschemaBindings() {
77      this(null);
78    }
79  
80    /**
81     * Constructs a new
82     * {@code dev.metaschema.databind.config.binding.MetaschemaBindings} instance
83     * with the specified metadata.
84     *
85     * @param data
86     *          the metaschema data, or {@code null} if none
87     */
88    public MetaschemaBindings(IMetaschemaData data) {
89      this.__metaschemaData = data;
90    }
91  
92    @Override
93    public IMetaschemaData getMetaschemaData() {
94      return __metaschemaData;
95    }
96  
97    /**
98     * Get the model Binding.
99     *
100    * <p>
101    * Defines binding configurations that apply to a whole model described by a
102    * namespace.
103    *
104    * @return the model-binding value
105    */
106   @NonNull
107   public List<ModelBinding> getModelBindings() {
108     if (_modelBindings == null) {
109       _modelBindings = new LinkedList<>();
110     }
111     return ObjectUtils.notNull(_modelBindings);
112   }
113 
114   /**
115    * Set the model Binding.
116    *
117    * <p>
118    * Defines binding configurations that apply to a whole model described by a
119    * namespace.
120    *
121    * @param value
122    *          the model-binding value to set
123    */
124   public void setModelBindings(@NonNull List<ModelBinding> value) {
125     _modelBindings = value;
126   }
127 
128   /**
129    * Add a new {@link ModelBinding} item to the underlying collection.
130    *
131    * @param item
132    *          the item to add
133    * @return {@code true}
134    */
135   public boolean addModelBinding(ModelBinding item) {
136     ModelBinding value = ObjectUtils.requireNonNull(item, "item cannot be null");
137     if (_modelBindings == null) {
138       _modelBindings = new LinkedList<>();
139     }
140     return _modelBindings.add(value);
141   }
142 
143   /**
144    * Remove the first matching {@link ModelBinding} item from the underlying
145    * collection.
146    *
147    * @param item
148    *          the item to remove
149    * @return {@code true} if the item was removed or {@code false} otherwise
150    */
151   public boolean removeModelBinding(ModelBinding item) {
152     ModelBinding value = ObjectUtils.requireNonNull(item, "item cannot be null");
153     return _modelBindings != null && _modelBindings.remove(value);
154   }
155 
156   /**
157    * Get the metaschema Binding.
158    *
159    * <p>
160    * Defines a binding for a given metaschema identified by a relative URL.
161    *
162    * @return the metaschema-binding value
163    */
164   @NonNull
165   public List<MetaschemaBinding> getMetaschemaBindings() {
166     if (_metaschemaBindings == null) {
167       _metaschemaBindings = new LinkedList<>();
168     }
169     return ObjectUtils.notNull(_metaschemaBindings);
170   }
171 
172   /**
173    * Set the metaschema Binding.
174    *
175    * <p>
176    * Defines a binding for a given metaschema identified by a relative URL.
177    *
178    * @param value
179    *          the metaschema-binding value to set
180    */
181   public void setMetaschemaBindings(@NonNull List<MetaschemaBinding> value) {
182     _metaschemaBindings = value;
183   }
184 
185   /**
186    * Add a new {@link MetaschemaBinding} item to the underlying collection.
187    *
188    * @param item
189    *          the item to add
190    * @return {@code true}
191    */
192   public boolean addMetaschemaBinding(MetaschemaBinding item) {
193     MetaschemaBinding value = ObjectUtils.requireNonNull(item, "item cannot be null");
194     if (_metaschemaBindings == null) {
195       _metaschemaBindings = new LinkedList<>();
196     }
197     return _metaschemaBindings.add(value);
198   }
199 
200   /**
201    * Remove the first matching {@link MetaschemaBinding} item from the underlying
202    * collection.
203    *
204    * @param item
205    *          the item to remove
206    * @return {@code true} if the item was removed or {@code false} otherwise
207    */
208   public boolean removeMetaschemaBinding(MetaschemaBinding item) {
209     MetaschemaBinding value = ObjectUtils.requireNonNull(item, "item cannot be null");
210     return _metaschemaBindings != null && _metaschemaBindings.remove(value);
211   }
212 
213   @Override
214   public String toString() {
215     return ObjectUtils.notNull(new ReflectionToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE).toString());
216   }
217 
218   /**
219    * Defines binding configurations that apply to a whole model described by a
220    * namespace.
221    */
222   @MetaschemaAssembly(
223       formalName = "Model Binding",
224       description = "Defines binding configurations that apply to a whole model described by a namespace.",
225       name = "model-binding",
226       moduleClass = MetaschemaBindingsModule.class)
227   public static class ModelBinding implements IBoundObject {
228     private final IMetaschemaData __metaschemaData;
229 
230     /**
231      * A URI referencing the namespace of one or more related metaschema
232      * definitions.
233      */
234     @BoundFlag(
235         formalName = "Namespace",
236         description = "A URI referencing the namespace of one or more related metaschema definitions.",
237         name = "namespace",
238         required = true,
239         typeAdapter = UriAdapter.class)
240     private URI _namespace;
241 
242     /**
243      * Java-specific binding configuration for a model namespace.
244      */
245     @BoundAssembly(
246         formalName = "Java Model Binding",
247         description = "Java-specific binding configuration for a model namespace.",
248         useName = "java")
249     private Java _java;
250 
251     /**
252      * Constructs a new
253      * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.ModelBinding}
254      * instance with no metadata.
255      */
256     public ModelBinding() {
257       this(null);
258     }
259 
260     /**
261      * Constructs a new
262      * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.ModelBinding}
263      * instance with the specified metadata.
264      *
265      * @param data
266      *          the metaschema data, or {@code null} if none
267      */
268     public ModelBinding(IMetaschemaData data) {
269       this.__metaschemaData = data;
270     }
271 
272     @Override
273     public IMetaschemaData getMetaschemaData() {
274       return __metaschemaData;
275     }
276 
277     /**
278      * Get the namespace.
279      *
280      * <p>
281      * A URI referencing the namespace of one or more related metaschema
282      * definitions.
283      *
284      * @return the namespace value
285      */
286     @NonNull
287     public URI getNamespace() {
288       return _namespace;
289     }
290 
291     /**
292      * Set the namespace.
293      *
294      * <p>
295      * A URI referencing the namespace of one or more related metaschema
296      * definitions.
297      *
298      * @param value
299      *          the namespace value to set
300      */
301     public void setNamespace(@NonNull URI value) {
302       _namespace = value;
303     }
304 
305     /**
306      * Get the java Model Binding.
307      *
308      * <p>
309      * Java-specific binding configuration for a model namespace.
310      *
311      * @return the java value, or {@code null} if not set
312      */
313     @Nullable
314     public Java getJava() {
315       return _java;
316     }
317 
318     /**
319      * Set the java Model Binding.
320      *
321      * <p>
322      * Java-specific binding configuration for a model namespace.
323      *
324      * @param value
325      *          the java value to set, or {@code null} to clear
326      */
327     public void setJava(@Nullable Java value) {
328       _java = value;
329     }
330 
331     @Override
332     public String toString() {
333       return ObjectUtils.notNull(new ReflectionToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE).toString());
334     }
335 
336     /**
337      * Java-specific binding configuration for a model namespace.
338      */
339     @MetaschemaAssembly(
340         formalName = "Java Model Binding",
341         description = "Java-specific binding configuration for a model namespace.",
342         name = "java",
343         moduleClass = MetaschemaBindingsModule.class)
344     public static class Java implements IBoundObject {
345       private final IMetaschemaData __metaschemaData;
346 
347       /**
348        * The Java package name to use for classes generated from this namespace.
349        */
350       @BoundField(
351           formalName = "Use Package Name",
352           description = "The Java package name to use for classes generated from this namespace.",
353           useName = "use-package-name",
354           typeAdapter = TokenAdapter.class)
355       private String _usePackageName;
356 
357       /**
358        * Constructs a new
359        * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.ModelBinding.Java}
360        * instance with no metadata.
361        */
362       public Java() {
363         this(null);
364       }
365 
366       /**
367        * Constructs a new
368        * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.ModelBinding.Java}
369        * instance with the specified metadata.
370        *
371        * @param data
372        *          the metaschema data, or {@code null} if none
373        */
374       public Java(IMetaschemaData data) {
375         this.__metaschemaData = data;
376       }
377 
378       @Override
379       public IMetaschemaData getMetaschemaData() {
380         return __metaschemaData;
381       }
382 
383       /**
384        * Get the use Package Name.
385        *
386        * <p>
387        * The Java package name to use for classes generated from this namespace.
388        *
389        * @return the use-package-name value, or {@code null} if not set
390        */
391       @Nullable
392       public String getUsePackageName() {
393         return _usePackageName;
394       }
395 
396       /**
397        * Set the use Package Name.
398        *
399        * <p>
400        * The Java package name to use for classes generated from this namespace.
401        *
402        * @param value
403        *          the use-package-name value to set, or {@code null} to clear
404        */
405       public void setUsePackageName(@Nullable String value) {
406         _usePackageName = value;
407       }
408 
409       @Override
410       public String toString() {
411         return ObjectUtils.notNull(new ReflectionToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE).toString());
412       }
413     }
414   }
415 
416   /**
417    * Defines a binding for a given metaschema identified by a relative URL.
418    */
419   @MetaschemaAssembly(
420       formalName = "Metaschema Binding",
421       description = "Defines a binding for a given metaschema identified by a relative URL.",
422       name = "metaschema-binding",
423       moduleClass = MetaschemaBindingsModule.class)
424   public static class MetaschemaBinding implements IBoundObject {
425     private final IMetaschemaData __metaschemaData;
426 
427     /**
428      * A URL relative to this binding configuration file, pointing to a metaschema
429      * definition.
430      */
431     @BoundFlag(
432         formalName = "Href",
433         description = "A URL relative to this binding configuration file, pointing to a metaschema definition.",
434         name = "href",
435         required = true,
436         typeAdapter = UriReferenceAdapter.class)
437     private URI _href;
438 
439     /**
440      * Provides binding configurations for a given defined assembly within the
441      * parent metaschema.
442      */
443     @BoundAssembly(
444         formalName = "Define Assembly Binding",
445         description = "Provides binding configurations for a given defined assembly within the parent metaschema.",
446         useName = "define-assembly-binding",
447         maxOccurs = -1,
448         groupAs = @GroupAs(name = "define-assembly-bindings", inJson = JsonGroupAsBehavior.LIST))
449     private List<DefineAssemblyBinding> _defineAssemblyBindings;
450 
451     /**
452      * Provides binding configurations for a given defined field within the parent
453      * metaschema.
454      */
455     @BoundAssembly(
456         formalName = "Define Field Binding",
457         description = "Provides binding configurations for a given defined field within the parent metaschema.",
458         useName = "define-field-binding",
459         maxOccurs = -1,
460         groupAs = @GroupAs(name = "define-field-bindings", inJson = JsonGroupAsBehavior.LIST))
461     private List<DefineFieldBinding> _defineFieldBindings;
462 
463     /**
464      * Constructs a new
465      * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding}
466      * instance with no metadata.
467      */
468     public MetaschemaBinding() {
469       this(null);
470     }
471 
472     /**
473      * Constructs a new
474      * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding}
475      * instance with the specified metadata.
476      *
477      * @param data
478      *          the metaschema data, or {@code null} if none
479      */
480     public MetaschemaBinding(IMetaschemaData data) {
481       this.__metaschemaData = data;
482     }
483 
484     @Override
485     public IMetaschemaData getMetaschemaData() {
486       return __metaschemaData;
487     }
488 
489     /**
490      * Get the href.
491      *
492      * <p>
493      * A URL relative to this binding configuration file, pointing to a metaschema
494      * definition.
495      *
496      * @return the href value
497      */
498     @NonNull
499     public URI getHref() {
500       return _href;
501     }
502 
503     /**
504      * Set the href.
505      *
506      * <p>
507      * A URL relative to this binding configuration file, pointing to a metaschema
508      * definition.
509      *
510      * @param value
511      *          the href value to set
512      */
513     public void setHref(@NonNull URI value) {
514       _href = value;
515     }
516 
517     /**
518      * Get the define Assembly Binding.
519      *
520      * <p>
521      * Provides binding configurations for a given defined assembly within the
522      * parent metaschema.
523      *
524      * @return the define-assembly-binding value
525      */
526     @NonNull
527     public List<DefineAssemblyBinding> getDefineAssemblyBindings() {
528       if (_defineAssemblyBindings == null) {
529         _defineAssemblyBindings = new LinkedList<>();
530       }
531       return ObjectUtils.notNull(_defineAssemblyBindings);
532     }
533 
534     /**
535      * Set the define Assembly Binding.
536      *
537      * <p>
538      * Provides binding configurations for a given defined assembly within the
539      * parent metaschema.
540      *
541      * @param value
542      *          the define-assembly-binding value to set
543      */
544     public void setDefineAssemblyBindings(@NonNull List<DefineAssemblyBinding> value) {
545       _defineAssemblyBindings = value;
546     }
547 
548     /**
549      * Add a new {@link DefineAssemblyBinding} item to the underlying collection.
550      *
551      * @param item
552      *          the item to add
553      * @return {@code true}
554      */
555     public boolean addDefineAssemblyBinding(DefineAssemblyBinding item) {
556       DefineAssemblyBinding value = ObjectUtils.requireNonNull(item, "item cannot be null");
557       if (_defineAssemblyBindings == null) {
558         _defineAssemblyBindings = new LinkedList<>();
559       }
560       return _defineAssemblyBindings.add(value);
561     }
562 
563     /**
564      * Remove the first matching {@link DefineAssemblyBinding} item from the
565      * underlying collection.
566      *
567      * @param item
568      *          the item to remove
569      * @return {@code true} if the item was removed or {@code false} otherwise
570      */
571     public boolean removeDefineAssemblyBinding(DefineAssemblyBinding item) {
572       DefineAssemblyBinding value = ObjectUtils.requireNonNull(item, "item cannot be null");
573       return _defineAssemblyBindings != null && _defineAssemblyBindings.remove(value);
574     }
575 
576     /**
577      * Get the define Field Binding.
578      *
579      * <p>
580      * Provides binding configurations for a given defined field within the parent
581      * metaschema.
582      *
583      * @return the define-field-binding value
584      */
585     @NonNull
586     public List<DefineFieldBinding> getDefineFieldBindings() {
587       if (_defineFieldBindings == null) {
588         _defineFieldBindings = new LinkedList<>();
589       }
590       return ObjectUtils.notNull(_defineFieldBindings);
591     }
592 
593     /**
594      * Set the define Field Binding.
595      *
596      * <p>
597      * Provides binding configurations for a given defined field within the parent
598      * metaschema.
599      *
600      * @param value
601      *          the define-field-binding value to set
602      */
603     public void setDefineFieldBindings(@NonNull List<DefineFieldBinding> value) {
604       _defineFieldBindings = value;
605     }
606 
607     /**
608      * Add a new {@link DefineFieldBinding} item to the underlying collection.
609      *
610      * @param item
611      *          the item to add
612      * @return {@code true}
613      */
614     public boolean addDefineFieldBinding(DefineFieldBinding item) {
615       DefineFieldBinding value = ObjectUtils.requireNonNull(item, "item cannot be null");
616       if (_defineFieldBindings == null) {
617         _defineFieldBindings = new LinkedList<>();
618       }
619       return _defineFieldBindings.add(value);
620     }
621 
622     /**
623      * Remove the first matching {@link DefineFieldBinding} item from the underlying
624      * collection.
625      *
626      * @param item
627      *          the item to remove
628      * @return {@code true} if the item was removed or {@code false} otherwise
629      */
630     public boolean removeDefineFieldBinding(DefineFieldBinding item) {
631       DefineFieldBinding value = ObjectUtils.requireNonNull(item, "item cannot be null");
632       return _defineFieldBindings != null && _defineFieldBindings.remove(value);
633     }
634 
635     @Override
636     public String toString() {
637       return ObjectUtils.notNull(new ReflectionToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE).toString());
638     }
639 
640     /**
641      * Provides binding configurations for a given defined assembly within the
642      * parent metaschema.
643      */
644     @MetaschemaAssembly(
645         formalName = "Define Assembly Binding",
646         description = "Provides binding configurations for a given defined assembly within the parent metaschema.",
647         name = "define-assembly-binding",
648         moduleClass = MetaschemaBindingsModule.class)
649     public static class DefineAssemblyBinding implements IBoundObject {
650       private final IMetaschemaData __metaschemaData;
651 
652       /**
653        * The name of the metaschema assembly. Used for top-level definitions.
654        */
655       @BoundFlag(
656           formalName = "Name",
657           description = "The name of the metaschema assembly. Used for top-level definitions.",
658           name = "name",
659           typeAdapter = TokenAdapter.class)
660       private String _name;
661 
662       /**
663        * A Metapath expression targeting the assembly definition(s) within the
664        * metaschema. Used for inline definitions.
665        */
666       @BoundFlag(
667           formalName = "Target",
668           description = "A Metapath expression targeting the assembly definition(s) within the metaschema. Used for inline definitions.",
669           name = "target",
670           typeAdapter = StringAdapter.class)
671       private String _target;
672 
673       /**
674        * Field and assembly binding configurations for Java bound classes.
675        */
676       @BoundAssembly(
677           formalName = "Java Object Definition Binding",
678           description = "Field and assembly binding configurations for Java bound classes.",
679           useName = "java")
680       private Java _java;
681 
682       /**
683        * Provides binding configurations for a property within the parent definition.
684        */
685       @BoundAssembly(
686           formalName = "Property Binding",
687           description = "Provides binding configurations for a property within the parent definition.",
688           useName = "property-binding",
689           maxOccurs = -1,
690           groupAs = @GroupAs(name = "property-bindings", inJson = JsonGroupAsBehavior.LIST))
691       private List<PropertyBinding> _propertyBindings;
692 
693       /**
694        * Provides binding configuration for a choice group within the parent assembly.
695        */
696       @BoundAssembly(
697           formalName = "Choice Group Binding",
698           description = "Provides binding configuration for a choice group within the parent assembly.",
699           useName = "choice-group-binding",
700           maxOccurs = -1,
701           groupAs = @GroupAs(name = "choice-group-bindings", inJson = JsonGroupAsBehavior.LIST))
702       private List<ChoiceGroupBinding> _choiceGroupBindings;
703 
704       /**
705        * Constructs a new
706        * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding.DefineAssemblyBinding}
707        * instance with no metadata.
708        */
709       public DefineAssemblyBinding() {
710         this(null);
711       }
712 
713       /**
714        * Constructs a new
715        * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding.DefineAssemblyBinding}
716        * instance with the specified metadata.
717        *
718        * @param data
719        *          the metaschema data, or {@code null} if none
720        */
721       public DefineAssemblyBinding(IMetaschemaData data) {
722         this.__metaschemaData = data;
723       }
724 
725       @Override
726       public IMetaschemaData getMetaschemaData() {
727         return __metaschemaData;
728       }
729 
730       /**
731        * Get the name.
732        *
733        * <p>
734        * The name of the metaschema assembly. Used for top-level definitions.
735        *
736        * @return the name value, or {@code null} if not set
737        */
738       @Nullable
739       public String getName() {
740         return _name;
741       }
742 
743       /**
744        * Set the name.
745        *
746        * <p>
747        * The name of the metaschema assembly. Used for top-level definitions.
748        *
749        * @param value
750        *          the name value to set, or {@code null} to clear
751        */
752       public void setName(@Nullable String value) {
753         _name = value;
754       }
755 
756       /**
757        * Get the target.
758        *
759        * <p>
760        * A Metapath expression targeting the assembly definition(s) within the
761        * metaschema. Used for inline definitions.
762        *
763        * @return the target value, or {@code null} if not set
764        */
765       @Nullable
766       public String getTarget() {
767         return _target;
768       }
769 
770       /**
771        * Set the target.
772        *
773        * <p>
774        * A Metapath expression targeting the assembly definition(s) within the
775        * metaschema. Used for inline definitions.
776        *
777        * @param value
778        *          the target value to set, or {@code null} to clear
779        */
780       public void setTarget(@Nullable String value) {
781         _target = value;
782       }
783 
784       /**
785        * Get the java Object Definition Binding.
786        *
787        * <p>
788        * Field and assembly binding configurations for Java bound classes.
789        *
790        * @return the java value, or {@code null} if not set
791        */
792       @Nullable
793       public Java getJava() {
794         return _java;
795       }
796 
797       /**
798        * Set the java Object Definition Binding.
799        *
800        * <p>
801        * Field and assembly binding configurations for Java bound classes.
802        *
803        * @param value
804        *          the java value to set, or {@code null} to clear
805        */
806       public void setJava(@Nullable Java value) {
807         _java = value;
808       }
809 
810       /**
811        * Get the property Binding.
812        *
813        * <p>
814        * Provides binding configurations for a property within the parent definition.
815        *
816        * @return the property-binding value
817        */
818       @NonNull
819       public List<PropertyBinding> getPropertyBindings() {
820         if (_propertyBindings == null) {
821           _propertyBindings = new LinkedList<>();
822         }
823         return ObjectUtils.notNull(_propertyBindings);
824       }
825 
826       /**
827        * Set the property Binding.
828        *
829        * <p>
830        * Provides binding configurations for a property within the parent definition.
831        *
832        * @param value
833        *          the property-binding value to set
834        */
835       public void setPropertyBindings(@NonNull List<PropertyBinding> value) {
836         _propertyBindings = value;
837       }
838 
839       /**
840        * Add a new {@link PropertyBinding} item to the underlying collection.
841        *
842        * @param item
843        *          the item to add
844        * @return {@code true}
845        */
846       public boolean addPropertyBinding(PropertyBinding item) {
847         PropertyBinding value = ObjectUtils.requireNonNull(item, "item cannot be null");
848         if (_propertyBindings == null) {
849           _propertyBindings = new LinkedList<>();
850         }
851         return _propertyBindings.add(value);
852       }
853 
854       /**
855        * Remove the first matching {@link PropertyBinding} item from the underlying
856        * collection.
857        *
858        * @param item
859        *          the item to remove
860        * @return {@code true} if the item was removed or {@code false} otherwise
861        */
862       public boolean removePropertyBinding(PropertyBinding item) {
863         PropertyBinding value = ObjectUtils.requireNonNull(item, "item cannot be null");
864         return _propertyBindings != null && _propertyBindings.remove(value);
865       }
866 
867       /**
868        * Get the choice Group Binding.
869        *
870        * <p>
871        * Provides binding configuration for a choice group within the parent assembly.
872        *
873        * @return the choice-group-binding value
874        */
875       @NonNull
876       public List<ChoiceGroupBinding> getChoiceGroupBindings() {
877         if (_choiceGroupBindings == null) {
878           _choiceGroupBindings = new LinkedList<>();
879         }
880         return ObjectUtils.notNull(_choiceGroupBindings);
881       }
882 
883       /**
884        * Set the choice Group Binding.
885        *
886        * <p>
887        * Provides binding configuration for a choice group within the parent assembly.
888        *
889        * @param value
890        *          the choice-group-binding value to set
891        */
892       public void setChoiceGroupBindings(@NonNull List<ChoiceGroupBinding> value) {
893         _choiceGroupBindings = value;
894       }
895 
896       /**
897        * Add a new {@link ChoiceGroupBinding} item to the underlying collection.
898        *
899        * @param item
900        *          the item to add
901        * @return {@code true}
902        */
903       public boolean addChoiceGroupBinding(ChoiceGroupBinding item) {
904         ChoiceGroupBinding value = ObjectUtils.requireNonNull(item, "item cannot be null");
905         if (_choiceGroupBindings == null) {
906           _choiceGroupBindings = new LinkedList<>();
907         }
908         return _choiceGroupBindings.add(value);
909       }
910 
911       /**
912        * Remove the first matching {@link ChoiceGroupBinding} item from the underlying
913        * collection.
914        *
915        * @param item
916        *          the item to remove
917        * @return {@code true} if the item was removed or {@code false} otherwise
918        */
919       public boolean removeChoiceGroupBinding(ChoiceGroupBinding item) {
920         ChoiceGroupBinding value = ObjectUtils.requireNonNull(item, "item cannot be null");
921         return _choiceGroupBindings != null && _choiceGroupBindings.remove(value);
922       }
923 
924       @Override
925       public String toString() {
926         return ObjectUtils.notNull(new ReflectionToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE).toString());
927       }
928 
929       /**
930        * Field and assembly binding configurations for Java bound classes.
931        */
932       @MetaschemaAssembly(
933           formalName = "Java Object Definition Binding",
934           description = "Field and assembly binding configurations for Java bound classes.",
935           name = "java",
936           moduleClass = MetaschemaBindingsModule.class)
937       public static class Java implements IBoundObject {
938         private final IMetaschemaData __metaschemaData;
939 
940         /**
941          * The Java class name to use for the generated class.
942          */
943         @BoundField(
944             formalName = "Use Class Name",
945             description = "The Java class name to use for the generated class.",
946             useName = "use-class-name",
947             typeAdapter = TokenAdapter.class)
948         private String _useClassName;
949 
950         /**
951          * A fully qualified Java interface name that the generated class should
952          * implement.
953          */
954         @BoundField(
955             formalName = "Implement Interface",
956             description = "A fully qualified Java interface name that the generated class should implement.",
957             useName = "implement-interface",
958             maxOccurs = -1,
959             groupAs = @GroupAs(name = "implement-interfaces", inJson = JsonGroupAsBehavior.LIST),
960             typeAdapter = TokenAdapter.class)
961         private List<String> _implementInterfaces;
962 
963         /**
964          * A fully qualified Java class name that the generated class should extend.
965          */
966         @BoundField(
967             formalName = "Extend Base Class",
968             description = "A fully qualified Java class name that the generated class should extend.",
969             useName = "extend-base-class",
970             typeAdapter = TokenAdapter.class)
971         private String _extendBaseClass;
972 
973         /**
974          * A fully qualified Java collection class name to use instead of the default.
975          */
976         @BoundField(
977             formalName = "Collection Class",
978             description = "A fully qualified Java collection class name to use instead of the default.",
979             useName = "collection-class",
980             typeAdapter = TokenAdapter.class)
981         private String _collectionClass;
982 
983         /**
984          * Constructs a new
985          * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding.DefineAssemblyBinding.Java}
986          * instance with no metadata.
987          */
988         public Java() {
989           this(null);
990         }
991 
992         /**
993          * Constructs a new
994          * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding.DefineAssemblyBinding.Java}
995          * instance with the specified metadata.
996          *
997          * @param data
998          *          the metaschema data, or {@code null} if none
999          */
1000         public Java(IMetaschemaData data) {
1001           this.__metaschemaData = data;
1002         }
1003 
1004         @Override
1005         public IMetaschemaData getMetaschemaData() {
1006           return __metaschemaData;
1007         }
1008 
1009         /**
1010          * Get the use Class Name.
1011          *
1012          * <p>
1013          * The Java class name to use for the generated class.
1014          *
1015          * @return the use-class-name value, or {@code null} if not set
1016          */
1017         @Nullable
1018         public String getUseClassName() {
1019           return _useClassName;
1020         }
1021 
1022         /**
1023          * Set the use Class Name.
1024          *
1025          * <p>
1026          * The Java class name to use for the generated class.
1027          *
1028          * @param value
1029          *          the use-class-name value to set, or {@code null} to clear
1030          */
1031         public void setUseClassName(@Nullable String value) {
1032           _useClassName = value;
1033         }
1034 
1035         /**
1036          * Get the implement Interface.
1037          *
1038          * <p>
1039          * A fully qualified Java interface name that the generated class should
1040          * implement.
1041          *
1042          * @return the implement-interface value
1043          */
1044         @NonNull
1045         public List<String> getImplementInterfaces() {
1046           if (_implementInterfaces == null) {
1047             _implementInterfaces = new LinkedList<>();
1048           }
1049           return ObjectUtils.notNull(_implementInterfaces);
1050         }
1051 
1052         /**
1053          * Set the implement Interface.
1054          *
1055          * <p>
1056          * A fully qualified Java interface name that the generated class should
1057          * implement.
1058          *
1059          * @param value
1060          *          the implement-interface value to set
1061          */
1062         public void setImplementInterfaces(@NonNull List<String> value) {
1063           _implementInterfaces = value;
1064         }
1065 
1066         /**
1067          * Add a new {@link String} item to the underlying collection.
1068          *
1069          * @param item
1070          *          the item to add
1071          * @return {@code true}
1072          */
1073         public boolean addImplementInterface(String item) {
1074           String value = ObjectUtils.requireNonNull(item, "item cannot be null");
1075           if (_implementInterfaces == null) {
1076             _implementInterfaces = new LinkedList<>();
1077           }
1078           return _implementInterfaces.add(value);
1079         }
1080 
1081         /**
1082          * Remove the first matching {@link String} item from the underlying collection.
1083          *
1084          * @param item
1085          *          the item to remove
1086          * @return {@code true} if the item was removed or {@code false} otherwise
1087          */
1088         public boolean removeImplementInterface(String item) {
1089           String value = ObjectUtils.requireNonNull(item, "item cannot be null");
1090           return _implementInterfaces != null && _implementInterfaces.remove(value);
1091         }
1092 
1093         /**
1094          * Get the extend Base Class.
1095          *
1096          * <p>
1097          * A fully qualified Java class name that the generated class should extend.
1098          *
1099          * @return the extend-base-class value, or {@code null} if not set
1100          */
1101         @Nullable
1102         public String getExtendBaseClass() {
1103           return _extendBaseClass;
1104         }
1105 
1106         /**
1107          * Set the extend Base Class.
1108          *
1109          * <p>
1110          * A fully qualified Java class name that the generated class should extend.
1111          *
1112          * @param value
1113          *          the extend-base-class value to set, or {@code null} to clear
1114          */
1115         public void setExtendBaseClass(@Nullable String value) {
1116           _extendBaseClass = value;
1117         }
1118 
1119         /**
1120          * Get the collection Class.
1121          *
1122          * <p>
1123          * A fully qualified Java collection class name to use instead of the default.
1124          *
1125          * @return the collection-class value, or {@code null} if not set
1126          */
1127         @Nullable
1128         public String getCollectionClass() {
1129           return _collectionClass;
1130         }
1131 
1132         /**
1133          * Set the collection Class.
1134          *
1135          * <p>
1136          * A fully qualified Java collection class name to use instead of the default.
1137          *
1138          * @param value
1139          *          the collection-class value to set, or {@code null} to clear
1140          */
1141         public void setCollectionClass(@Nullable String value) {
1142           _collectionClass = value;
1143         }
1144 
1145         @Override
1146         public String toString() {
1147           return ObjectUtils.notNull(new ReflectionToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE).toString());
1148         }
1149       }
1150 
1151       /**
1152        * Provides binding configurations for a property within the parent definition.
1153        */
1154       @MetaschemaAssembly(
1155           formalName = "Property Binding",
1156           description = "Provides binding configurations for a property within the parent definition.",
1157           name = "property-binding",
1158           moduleClass = MetaschemaBindingsModule.class)
1159       public static class PropertyBinding implements IBoundObject {
1160         private final IMetaschemaData __metaschemaData;
1161 
1162         /**
1163          * The name of the property within the parent definition.
1164          */
1165         @BoundFlag(
1166             formalName = "Name",
1167             description = "The name of the property within the parent definition.",
1168             name = "name",
1169             required = true,
1170             typeAdapter = TokenAdapter.class)
1171         private String _name;
1172 
1173         /**
1174          * Java-specific binding configuration for a property.
1175          */
1176         @BoundAssembly(
1177             formalName = "Java Property Binding",
1178             description = "Java-specific binding configuration for a property.",
1179             useName = "java")
1180         private Java _java;
1181 
1182         /**
1183          * Constructs a new
1184          * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding.DefineAssemblyBinding.PropertyBinding}
1185          * instance with no metadata.
1186          */
1187         public PropertyBinding() {
1188           this(null);
1189         }
1190 
1191         /**
1192          * Constructs a new
1193          * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding.DefineAssemblyBinding.PropertyBinding}
1194          * instance with the specified metadata.
1195          *
1196          * @param data
1197          *          the metaschema data, or {@code null} if none
1198          */
1199         public PropertyBinding(IMetaschemaData data) {
1200           this.__metaschemaData = data;
1201         }
1202 
1203         @Override
1204         public IMetaschemaData getMetaschemaData() {
1205           return __metaschemaData;
1206         }
1207 
1208         /**
1209          * Get the name.
1210          *
1211          * <p>
1212          * The name of the property within the parent definition.
1213          *
1214          * @return the name value
1215          */
1216         @NonNull
1217         public String getName() {
1218           return _name;
1219         }
1220 
1221         /**
1222          * Set the name.
1223          *
1224          * <p>
1225          * The name of the property within the parent definition.
1226          *
1227          * @param value
1228          *          the name value to set
1229          */
1230         public void setName(@NonNull String value) {
1231           _name = value;
1232         }
1233 
1234         /**
1235          * Get the java Property Binding.
1236          *
1237          * <p>
1238          * Java-specific binding configuration for a property.
1239          *
1240          * @return the java value, or {@code null} if not set
1241          */
1242         @Nullable
1243         public Java getJava() {
1244           return _java;
1245         }
1246 
1247         /**
1248          * Set the java Property Binding.
1249          *
1250          * <p>
1251          * Java-specific binding configuration for a property.
1252          *
1253          * @param value
1254          *          the java value to set, or {@code null} to clear
1255          */
1256         public void setJava(@Nullable Java value) {
1257           _java = value;
1258         }
1259 
1260         @Override
1261         public String toString() {
1262           return ObjectUtils.notNull(new ReflectionToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE).toString());
1263         }
1264 
1265         /**
1266          * Java-specific binding configuration for a property.
1267          */
1268         @MetaschemaAssembly(
1269             formalName = "Java Property Binding",
1270             description = "Java-specific binding configuration for a property.",
1271             name = "java",
1272             moduleClass = MetaschemaBindingsModule.class)
1273         public static class Java implements IBoundObject {
1274           private final IMetaschemaData __metaschemaData;
1275 
1276           /**
1277            * A fully qualified Java collection class name to use instead of the default.
1278            */
1279           @BoundField(
1280               formalName = "Collection Class",
1281               description = "A fully qualified Java collection class name to use instead of the default.",
1282               useName = "collection-class",
1283               typeAdapter = TokenAdapter.class)
1284           private String _collectionClass;
1285 
1286           /**
1287            * Constructs a new
1288            * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding.DefineAssemblyBinding.PropertyBinding.Java}
1289            * instance with no metadata.
1290            */
1291           public Java() {
1292             this(null);
1293           }
1294 
1295           /**
1296            * Constructs a new
1297            * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding.DefineAssemblyBinding.PropertyBinding.Java}
1298            * instance with the specified metadata.
1299            *
1300            * @param data
1301            *          the metaschema data, or {@code null} if none
1302            */
1303           public Java(IMetaschemaData data) {
1304             this.__metaschemaData = data;
1305           }
1306 
1307           @Override
1308           public IMetaschemaData getMetaschemaData() {
1309             return __metaschemaData;
1310           }
1311 
1312           /**
1313            * Get the collection Class.
1314            *
1315            * <p>
1316            * A fully qualified Java collection class name to use instead of the default.
1317            *
1318            * @return the collection-class value, or {@code null} if not set
1319            */
1320           @Nullable
1321           public String getCollectionClass() {
1322             return _collectionClass;
1323           }
1324 
1325           /**
1326            * Set the collection Class.
1327            *
1328            * <p>
1329            * A fully qualified Java collection class name to use instead of the default.
1330            *
1331            * @param value
1332            *          the collection-class value to set, or {@code null} to clear
1333            */
1334           public void setCollectionClass(@Nullable String value) {
1335             _collectionClass = value;
1336           }
1337 
1338           @Override
1339           public String toString() {
1340             return ObjectUtils.notNull(new ReflectionToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE).toString());
1341           }
1342         }
1343       }
1344 
1345       /**
1346        * Provides binding configuration for a choice group within the parent assembly.
1347        */
1348       @MetaschemaAssembly(
1349           formalName = "Choice Group Binding",
1350           description = "Provides binding configuration for a choice group within the parent assembly.",
1351           name = "choice-group-binding",
1352           moduleClass = MetaschemaBindingsModule.class)
1353       public static class ChoiceGroupBinding implements IBoundObject {
1354         private final IMetaschemaData __metaschemaData;
1355 
1356         /**
1357          * The name of the choice group (matches the group-as name in the metaschema).
1358          */
1359         @BoundFlag(
1360             formalName = "Name",
1361             description = "The name of the choice group (matches the group-as name in the metaschema).",
1362             name = "name",
1363             required = true,
1364             typeAdapter = TokenAdapter.class)
1365         private String _name;
1366 
1367         /**
1368          * A fully qualified Java type for collection items. When specified, the
1369          * generated field and getter will use this type instead of Object.
1370          */
1371         @BoundField(
1372             formalName = "Item Type",
1373             description = "A fully qualified Java type for collection items. When specified, the generated field and getter will use this type instead of Object.",
1374             useName = "item-type")
1375         private ItemType _itemType;
1376 
1377         /**
1378          * Constructs a new
1379          * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding.DefineAssemblyBinding.ChoiceGroupBinding}
1380          * instance with no metadata.
1381          */
1382         public ChoiceGroupBinding() {
1383           this(null);
1384         }
1385 
1386         /**
1387          * Constructs a new
1388          * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding.DefineAssemblyBinding.ChoiceGroupBinding}
1389          * instance with the specified metadata.
1390          *
1391          * @param data
1392          *          the metaschema data, or {@code null} if none
1393          */
1394         public ChoiceGroupBinding(IMetaschemaData data) {
1395           this.__metaschemaData = data;
1396         }
1397 
1398         @Override
1399         public IMetaschemaData getMetaschemaData() {
1400           return __metaschemaData;
1401         }
1402 
1403         /**
1404          * Get the name.
1405          *
1406          * <p>
1407          * The name of the choice group (matches the group-as name in the metaschema).
1408          *
1409          * @return the name value
1410          */
1411         @NonNull
1412         public String getName() {
1413           return _name;
1414         }
1415 
1416         /**
1417          * Set the name.
1418          *
1419          * <p>
1420          * The name of the choice group (matches the group-as name in the metaschema).
1421          *
1422          * @param value
1423          *          the name value to set
1424          */
1425         public void setName(@NonNull String value) {
1426           _name = value;
1427         }
1428 
1429         /**
1430          * Get the item Type.
1431          *
1432          * <p>
1433          * A fully qualified Java type for collection items. When specified, the
1434          * generated field and getter will use this type instead of Object.
1435          *
1436          * @return the item-type value, or {@code null} if not set
1437          */
1438         @Nullable
1439         public ItemType getItemType() {
1440           return _itemType;
1441         }
1442 
1443         /**
1444          * Set the item Type.
1445          *
1446          * <p>
1447          * A fully qualified Java type for collection items. When specified, the
1448          * generated field and getter will use this type instead of Object.
1449          *
1450          * @param value
1451          *          the item-type value to set, or {@code null} to clear
1452          */
1453         public void setItemType(@Nullable ItemType value) {
1454           _itemType = value;
1455         }
1456 
1457         @Override
1458         public String toString() {
1459           return ObjectUtils.notNull(new ReflectionToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE).toString());
1460         }
1461 
1462         /**
1463          * A fully qualified Java type for collection items. When specified, the
1464          * generated field and getter will use this type instead of Object.
1465          */
1466         @MetaschemaField(
1467             formalName = "Item Type",
1468             description = "A fully qualified Java type for collection items. When specified, the generated field and getter will use this type instead of Object.",
1469             name = "item-type",
1470             moduleClass = MetaschemaBindingsModule.class)
1471         public static class ItemType implements IBoundObject {
1472           private final IMetaschemaData __metaschemaData;
1473 
1474           /**
1475            * Whether to use a wildcard bounded type (List&lt;? extends Type&gt;). Defaults
1476            * to true.
1477            */
1478           @BoundFlag(
1479               formalName = "Use Wildcard",
1480               description = "Whether to use a wildcard bounded type (List<? extends Type>). Defaults to true.",
1481               name = "use-wildcard",
1482               defaultValue = "true",
1483               typeAdapter = BooleanAdapter.class)
1484           private Boolean _useWildcard;
1485 
1486           /**
1487            * The field value.
1488            */
1489           @BoundFieldValue(
1490               valueKeyName = "STRVALUE",
1491               typeAdapter = TokenAdapter.class)
1492           private String _value;
1493 
1494           /**
1495            * Constructs a new
1496            * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding.DefineAssemblyBinding.ChoiceGroupBinding.ItemType}
1497            * instance with no metadata.
1498            */
1499           public ItemType() {
1500             this(null);
1501           }
1502 
1503           /**
1504            * Constructs a new
1505            * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding.DefineAssemblyBinding.ChoiceGroupBinding.ItemType}
1506            * instance with the specified metadata.
1507            *
1508            * @param data
1509            *          the metaschema data, or {@code null} if none
1510            */
1511           public ItemType(IMetaschemaData data) {
1512             this.__metaschemaData = data;
1513           }
1514 
1515           @Override
1516           public IMetaschemaData getMetaschemaData() {
1517             return __metaschemaData;
1518           }
1519 
1520           /**
1521            * Get the use Wildcard.
1522            *
1523            * <p>
1524            * Whether to use a wildcard bounded type (List&lt;? extends Type&gt;). Defaults
1525            * to true.
1526            *
1527            * @return the use-wildcard value, or {@code null} if not set
1528            */
1529           @Nullable
1530           public Boolean getUseWildcard() {
1531             return _useWildcard;
1532           }
1533 
1534           /**
1535            * Set the use Wildcard.
1536            *
1537            * <p>
1538            * Whether to use a wildcard bounded type (List&lt;? extends Type&gt;). Defaults
1539            * to true.
1540            *
1541            * @param value
1542            *          the use-wildcard value to set, or {@code null} to clear
1543            */
1544           public void setUseWildcard(@Nullable Boolean value) {
1545             _useWildcard = value;
1546           }
1547 
1548           /**
1549            * Get the field value.
1550            *
1551            * @return the value
1552            */
1553           @Nullable
1554           public String getValue() {
1555             return _value;
1556           }
1557 
1558           /**
1559            * Set the field value.
1560            *
1561            * @param value
1562            *          the value to set
1563            */
1564           public void setValue(@Nullable String value) {
1565             _value = value;
1566           }
1567 
1568           @Override
1569           public String toString() {
1570             return ObjectUtils.notNull(new ReflectionToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE).toString());
1571           }
1572         }
1573       }
1574     }
1575 
1576     /**
1577      * Provides binding configurations for a given defined field within the parent
1578      * metaschema.
1579      */
1580     @MetaschemaAssembly(
1581         formalName = "Define Field Binding",
1582         description = "Provides binding configurations for a given defined field within the parent metaschema.",
1583         name = "define-field-binding",
1584         moduleClass = MetaschemaBindingsModule.class)
1585     public static class DefineFieldBinding implements IBoundObject {
1586       private final IMetaschemaData __metaschemaData;
1587 
1588       /**
1589        * The name of the metaschema field. Used for top-level definitions.
1590        */
1591       @BoundFlag(
1592           formalName = "Name",
1593           description = "The name of the metaschema field. Used for top-level definitions.",
1594           name = "name",
1595           typeAdapter = TokenAdapter.class)
1596       private String _name;
1597 
1598       /**
1599        * A Metapath expression targeting the field definition(s) within the
1600        * metaschema. Used for inline definitions.
1601        */
1602       @BoundFlag(
1603           formalName = "Target",
1604           description = "A Metapath expression targeting the field definition(s) within the metaschema. Used for inline definitions.",
1605           name = "target",
1606           typeAdapter = StringAdapter.class)
1607       private String _target;
1608 
1609       /**
1610        * Field and assembly binding configurations for Java bound classes.
1611        */
1612       @BoundAssembly(
1613           formalName = "Java Object Definition Binding",
1614           description = "Field and assembly binding configurations for Java bound classes.",
1615           useName = "java")
1616       private Java _java;
1617 
1618       /**
1619        * Provides binding configurations for a property within the parent definition.
1620        */
1621       @BoundAssembly(
1622           formalName = "Property Binding",
1623           description = "Provides binding configurations for a property within the parent definition.",
1624           useName = "property-binding",
1625           maxOccurs = -1,
1626           groupAs = @GroupAs(name = "property-bindings", inJson = JsonGroupAsBehavior.LIST))
1627       private List<PropertyBinding> _propertyBindings;
1628 
1629       /**
1630        * Constructs a new
1631        * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding.DefineFieldBinding}
1632        * instance with no metadata.
1633        */
1634       public DefineFieldBinding() {
1635         this(null);
1636       }
1637 
1638       /**
1639        * Constructs a new
1640        * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding.DefineFieldBinding}
1641        * instance with the specified metadata.
1642        *
1643        * @param data
1644        *          the metaschema data, or {@code null} if none
1645        */
1646       public DefineFieldBinding(IMetaschemaData data) {
1647         this.__metaschemaData = data;
1648       }
1649 
1650       @Override
1651       public IMetaschemaData getMetaschemaData() {
1652         return __metaschemaData;
1653       }
1654 
1655       /**
1656        * Get the name.
1657        *
1658        * <p>
1659        * The name of the metaschema field. Used for top-level definitions.
1660        *
1661        * @return the name value, or {@code null} if not set
1662        */
1663       @Nullable
1664       public String getName() {
1665         return _name;
1666       }
1667 
1668       /**
1669        * Set the name.
1670        *
1671        * <p>
1672        * The name of the metaschema field. Used for top-level definitions.
1673        *
1674        * @param value
1675        *          the name value to set, or {@code null} to clear
1676        */
1677       public void setName(@Nullable String value) {
1678         _name = value;
1679       }
1680 
1681       /**
1682        * Get the target.
1683        *
1684        * <p>
1685        * A Metapath expression targeting the field definition(s) within the
1686        * metaschema. Used for inline definitions.
1687        *
1688        * @return the target value, or {@code null} if not set
1689        */
1690       @Nullable
1691       public String getTarget() {
1692         return _target;
1693       }
1694 
1695       /**
1696        * Set the target.
1697        *
1698        * <p>
1699        * A Metapath expression targeting the field definition(s) within the
1700        * metaschema. Used for inline definitions.
1701        *
1702        * @param value
1703        *          the target value to set, or {@code null} to clear
1704        */
1705       public void setTarget(@Nullable String value) {
1706         _target = value;
1707       }
1708 
1709       /**
1710        * Get the java Object Definition Binding.
1711        *
1712        * <p>
1713        * Field and assembly binding configurations for Java bound classes.
1714        *
1715        * @return the java value, or {@code null} if not set
1716        */
1717       @Nullable
1718       public Java getJava() {
1719         return _java;
1720       }
1721 
1722       /**
1723        * Set the java Object Definition Binding.
1724        *
1725        * <p>
1726        * Field and assembly binding configurations for Java bound classes.
1727        *
1728        * @param value
1729        *          the java value to set, or {@code null} to clear
1730        */
1731       public void setJava(@Nullable Java value) {
1732         _java = value;
1733       }
1734 
1735       /**
1736        * Get the property Binding.
1737        *
1738        * <p>
1739        * Provides binding configurations for a property within the parent definition.
1740        *
1741        * @return the property-binding value
1742        */
1743       @NonNull
1744       public List<PropertyBinding> getPropertyBindings() {
1745         if (_propertyBindings == null) {
1746           _propertyBindings = new LinkedList<>();
1747         }
1748         return ObjectUtils.notNull(_propertyBindings);
1749       }
1750 
1751       /**
1752        * Set the property Binding.
1753        *
1754        * <p>
1755        * Provides binding configurations for a property within the parent definition.
1756        *
1757        * @param value
1758        *          the property-binding value to set
1759        */
1760       public void setPropertyBindings(@NonNull List<PropertyBinding> value) {
1761         _propertyBindings = value;
1762       }
1763 
1764       /**
1765        * Add a new {@link PropertyBinding} item to the underlying collection.
1766        *
1767        * @param item
1768        *          the item to add
1769        * @return {@code true}
1770        */
1771       public boolean addPropertyBinding(PropertyBinding item) {
1772         PropertyBinding value = ObjectUtils.requireNonNull(item, "item cannot be null");
1773         if (_propertyBindings == null) {
1774           _propertyBindings = new LinkedList<>();
1775         }
1776         return _propertyBindings.add(value);
1777       }
1778 
1779       /**
1780        * Remove the first matching {@link PropertyBinding} item from the underlying
1781        * collection.
1782        *
1783        * @param item
1784        *          the item to remove
1785        * @return {@code true} if the item was removed or {@code false} otherwise
1786        */
1787       public boolean removePropertyBinding(PropertyBinding item) {
1788         PropertyBinding value = ObjectUtils.requireNonNull(item, "item cannot be null");
1789         return _propertyBindings != null && _propertyBindings.remove(value);
1790       }
1791 
1792       @Override
1793       public String toString() {
1794         return ObjectUtils.notNull(new ReflectionToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE).toString());
1795       }
1796 
1797       /**
1798        * Field and assembly binding configurations for Java bound classes.
1799        */
1800       @MetaschemaAssembly(
1801           formalName = "Java Object Definition Binding",
1802           description = "Field and assembly binding configurations for Java bound classes.",
1803           name = "java",
1804           moduleClass = MetaschemaBindingsModule.class)
1805       public static class Java implements IBoundObject {
1806         private final IMetaschemaData __metaschemaData;
1807 
1808         /**
1809          * The Java class name to use for the generated class.
1810          */
1811         @BoundField(
1812             formalName = "Use Class Name",
1813             description = "The Java class name to use for the generated class.",
1814             useName = "use-class-name",
1815             typeAdapter = TokenAdapter.class)
1816         private String _useClassName;
1817 
1818         /**
1819          * A fully qualified Java interface name that the generated class should
1820          * implement.
1821          */
1822         @BoundField(
1823             formalName = "Implement Interface",
1824             description = "A fully qualified Java interface name that the generated class should implement.",
1825             useName = "implement-interface",
1826             maxOccurs = -1,
1827             groupAs = @GroupAs(name = "implement-interfaces", inJson = JsonGroupAsBehavior.LIST),
1828             typeAdapter = TokenAdapter.class)
1829         private List<String> _implementInterfaces;
1830 
1831         /**
1832          * A fully qualified Java class name that the generated class should extend.
1833          */
1834         @BoundField(
1835             formalName = "Extend Base Class",
1836             description = "A fully qualified Java class name that the generated class should extend.",
1837             useName = "extend-base-class",
1838             typeAdapter = TokenAdapter.class)
1839         private String _extendBaseClass;
1840 
1841         /**
1842          * A fully qualified Java collection class name to use instead of the default.
1843          */
1844         @BoundField(
1845             formalName = "Collection Class",
1846             description = "A fully qualified Java collection class name to use instead of the default.",
1847             useName = "collection-class",
1848             typeAdapter = TokenAdapter.class)
1849         private String _collectionClass;
1850 
1851         /**
1852          * Constructs a new
1853          * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding.DefineFieldBinding.Java}
1854          * instance with no metadata.
1855          */
1856         public Java() {
1857           this(null);
1858         }
1859 
1860         /**
1861          * Constructs a new
1862          * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding.DefineFieldBinding.Java}
1863          * instance with the specified metadata.
1864          *
1865          * @param data
1866          *          the metaschema data, or {@code null} if none
1867          */
1868         public Java(IMetaschemaData data) {
1869           this.__metaschemaData = data;
1870         }
1871 
1872         @Override
1873         public IMetaschemaData getMetaschemaData() {
1874           return __metaschemaData;
1875         }
1876 
1877         /**
1878          * Get the use Class Name.
1879          *
1880          * <p>
1881          * The Java class name to use for the generated class.
1882          *
1883          * @return the use-class-name value, or {@code null} if not set
1884          */
1885         @Nullable
1886         public String getUseClassName() {
1887           return _useClassName;
1888         }
1889 
1890         /**
1891          * Set the use Class Name.
1892          *
1893          * <p>
1894          * The Java class name to use for the generated class.
1895          *
1896          * @param value
1897          *          the use-class-name value to set, or {@code null} to clear
1898          */
1899         public void setUseClassName(@Nullable String value) {
1900           _useClassName = value;
1901         }
1902 
1903         /**
1904          * Get the implement Interface.
1905          *
1906          * <p>
1907          * A fully qualified Java interface name that the generated class should
1908          * implement.
1909          *
1910          * @return the implement-interface value
1911          */
1912         @NonNull
1913         public List<String> getImplementInterfaces() {
1914           if (_implementInterfaces == null) {
1915             _implementInterfaces = new LinkedList<>();
1916           }
1917           return ObjectUtils.notNull(_implementInterfaces);
1918         }
1919 
1920         /**
1921          * Set the implement Interface.
1922          *
1923          * <p>
1924          * A fully qualified Java interface name that the generated class should
1925          * implement.
1926          *
1927          * @param value
1928          *          the implement-interface value to set
1929          */
1930         public void setImplementInterfaces(@NonNull List<String> value) {
1931           _implementInterfaces = value;
1932         }
1933 
1934         /**
1935          * Add a new {@link String} item to the underlying collection.
1936          *
1937          * @param item
1938          *          the item to add
1939          * @return {@code true}
1940          */
1941         public boolean addImplementInterface(String item) {
1942           String value = ObjectUtils.requireNonNull(item, "item cannot be null");
1943           if (_implementInterfaces == null) {
1944             _implementInterfaces = new LinkedList<>();
1945           }
1946           return _implementInterfaces.add(value);
1947         }
1948 
1949         /**
1950          * Remove the first matching {@link String} item from the underlying collection.
1951          *
1952          * @param item
1953          *          the item to remove
1954          * @return {@code true} if the item was removed or {@code false} otherwise
1955          */
1956         public boolean removeImplementInterface(String item) {
1957           String value = ObjectUtils.requireNonNull(item, "item cannot be null");
1958           return _implementInterfaces != null && _implementInterfaces.remove(value);
1959         }
1960 
1961         /**
1962          * Get the extend Base Class.
1963          *
1964          * <p>
1965          * A fully qualified Java class name that the generated class should extend.
1966          *
1967          * @return the extend-base-class value, or {@code null} if not set
1968          */
1969         @Nullable
1970         public String getExtendBaseClass() {
1971           return _extendBaseClass;
1972         }
1973 
1974         /**
1975          * Set the extend Base Class.
1976          *
1977          * <p>
1978          * A fully qualified Java class name that the generated class should extend.
1979          *
1980          * @param value
1981          *          the extend-base-class value to set, or {@code null} to clear
1982          */
1983         public void setExtendBaseClass(@Nullable String value) {
1984           _extendBaseClass = value;
1985         }
1986 
1987         /**
1988          * Get the collection Class.
1989          *
1990          * <p>
1991          * A fully qualified Java collection class name to use instead of the default.
1992          *
1993          * @return the collection-class value, or {@code null} if not set
1994          */
1995         @Nullable
1996         public String getCollectionClass() {
1997           return _collectionClass;
1998         }
1999 
2000         /**
2001          * Set the collection Class.
2002          *
2003          * <p>
2004          * A fully qualified Java collection class name to use instead of the default.
2005          *
2006          * @param value
2007          *          the collection-class value to set, or {@code null} to clear
2008          */
2009         public void setCollectionClass(@Nullable String value) {
2010           _collectionClass = value;
2011         }
2012 
2013         @Override
2014         public String toString() {
2015           return ObjectUtils.notNull(new ReflectionToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE).toString());
2016         }
2017       }
2018 
2019       /**
2020        * Provides binding configurations for a property within the parent definition.
2021        */
2022       @MetaschemaAssembly(
2023           formalName = "Property Binding",
2024           description = "Provides binding configurations for a property within the parent definition.",
2025           name = "property-binding",
2026           moduleClass = MetaschemaBindingsModule.class)
2027       public static class PropertyBinding implements IBoundObject {
2028         private final IMetaschemaData __metaschemaData;
2029 
2030         /**
2031          * The name of the property within the parent definition.
2032          */
2033         @BoundFlag(
2034             formalName = "Name",
2035             description = "The name of the property within the parent definition.",
2036             name = "name",
2037             required = true,
2038             typeAdapter = TokenAdapter.class)
2039         private String _name;
2040 
2041         /**
2042          * Java-specific binding configuration for a property.
2043          */
2044         @BoundAssembly(
2045             formalName = "Java Property Binding",
2046             description = "Java-specific binding configuration for a property.",
2047             useName = "java")
2048         private Java _java;
2049 
2050         /**
2051          * Constructs a new
2052          * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding.DefineFieldBinding.PropertyBinding}
2053          * instance with no metadata.
2054          */
2055         public PropertyBinding() {
2056           this(null);
2057         }
2058 
2059         /**
2060          * Constructs a new
2061          * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding.DefineFieldBinding.PropertyBinding}
2062          * instance with the specified metadata.
2063          *
2064          * @param data
2065          *          the metaschema data, or {@code null} if none
2066          */
2067         public PropertyBinding(IMetaschemaData data) {
2068           this.__metaschemaData = data;
2069         }
2070 
2071         @Override
2072         public IMetaschemaData getMetaschemaData() {
2073           return __metaschemaData;
2074         }
2075 
2076         /**
2077          * Get the name.
2078          *
2079          * <p>
2080          * The name of the property within the parent definition.
2081          *
2082          * @return the name value
2083          */
2084         @NonNull
2085         public String getName() {
2086           return _name;
2087         }
2088 
2089         /**
2090          * Set the name.
2091          *
2092          * <p>
2093          * The name of the property within the parent definition.
2094          *
2095          * @param value
2096          *          the name value to set
2097          */
2098         public void setName(@NonNull String value) {
2099           _name = value;
2100         }
2101 
2102         /**
2103          * Get the java Property Binding.
2104          *
2105          * <p>
2106          * Java-specific binding configuration for a property.
2107          *
2108          * @return the java value, or {@code null} if not set
2109          */
2110         @Nullable
2111         public Java getJava() {
2112           return _java;
2113         }
2114 
2115         /**
2116          * Set the java Property Binding.
2117          *
2118          * <p>
2119          * Java-specific binding configuration for a property.
2120          *
2121          * @param value
2122          *          the java value to set, or {@code null} to clear
2123          */
2124         public void setJava(@Nullable Java value) {
2125           _java = value;
2126         }
2127 
2128         @Override
2129         public String toString() {
2130           return ObjectUtils.notNull(new ReflectionToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE).toString());
2131         }
2132 
2133         /**
2134          * Java-specific binding configuration for a property.
2135          */
2136         @MetaschemaAssembly(
2137             formalName = "Java Property Binding",
2138             description = "Java-specific binding configuration for a property.",
2139             name = "java",
2140             moduleClass = MetaschemaBindingsModule.class)
2141         public static class Java implements IBoundObject {
2142           private final IMetaschemaData __metaschemaData;
2143 
2144           /**
2145            * A fully qualified Java collection class name to use instead of the default.
2146            */
2147           @BoundField(
2148               formalName = "Collection Class",
2149               description = "A fully qualified Java collection class name to use instead of the default.",
2150               useName = "collection-class",
2151               typeAdapter = TokenAdapter.class)
2152           private String _collectionClass;
2153 
2154           /**
2155            * Constructs a new
2156            * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding.DefineFieldBinding.PropertyBinding.Java}
2157            * instance with no metadata.
2158            */
2159           public Java() {
2160             this(null);
2161           }
2162 
2163           /**
2164            * Constructs a new
2165            * {@code dev.metaschema.databind.config.binding.MetaschemaBindings.MetaschemaBinding.DefineFieldBinding.PropertyBinding.Java}
2166            * instance with the specified metadata.
2167            *
2168            * @param data
2169            *          the metaschema data, or {@code null} if none
2170            */
2171           public Java(IMetaschemaData data) {
2172             this.__metaschemaData = data;
2173           }
2174 
2175           @Override
2176           public IMetaschemaData getMetaschemaData() {
2177             return __metaschemaData;
2178           }
2179 
2180           /**
2181            * Get the collection Class.
2182            *
2183            * <p>
2184            * A fully qualified Java collection class name to use instead of the default.
2185            *
2186            * @return the collection-class value, or {@code null} if not set
2187            */
2188           @Nullable
2189           public String getCollectionClass() {
2190             return _collectionClass;
2191           }
2192 
2193           /**
2194            * Set the collection Class.
2195            *
2196            * <p>
2197            * A fully qualified Java collection class name to use instead of the default.
2198            *
2199            * @param value
2200            *          the collection-class value to set, or {@code null} to clear
2201            */
2202           public void setCollectionClass(@Nullable String value) {
2203             _collectionClass = value;
2204           }
2205 
2206           @Override
2207           public String toString() {
2208             return ObjectUtils.notNull(new ReflectionToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE).toString());
2209           }
2210         }
2211       }
2212     }
2213   }
2214 }