package gov.nist.secauto.oscal.lib.model;
   
   import gov.nist.secauto.metaschema.binding.model.annotations.AllowedValue;
   import gov.nist.secauto.metaschema.binding.model.annotations.AllowedValues;
   import gov.nist.secauto.metaschema.binding.model.annotations.AssemblyConstraints;
   import gov.nist.secauto.metaschema.binding.model.annotations.BoundAssembly;
   import gov.nist.secauto.metaschema.binding.model.annotations.BoundField;
   import gov.nist.secauto.metaschema.binding.model.annotations.BoundFieldValue;
   import gov.nist.secauto.metaschema.binding.model.annotations.BoundFlag;
  import gov.nist.secauto.metaschema.binding.model.annotations.GroupAs;
  import gov.nist.secauto.metaschema.binding.model.annotations.IsUnique;
  import gov.nist.secauto.metaschema.binding.model.annotations.KeyField;
  import gov.nist.secauto.metaschema.binding.model.annotations.MetaschemaAssembly;
  import gov.nist.secauto.metaschema.binding.model.annotations.ValueConstraints;
  import gov.nist.secauto.metaschema.model.common.JsonGroupAsBehavior;
  import gov.nist.secauto.metaschema.model.common.constraint.IConstraint;
  import gov.nist.secauto.metaschema.model.common.datatype.adapter.TokenAdapter;
  import gov.nist.secauto.metaschema.model.common.datatype.markup.MarkupLine;
  import gov.nist.secauto.metaschema.model.common.datatype.markup.MarkupLineAdapter;
  import gov.nist.secauto.metaschema.model.common.datatype.markup.MarkupMultiline;
  import gov.nist.secauto.metaschema.model.common.datatype.markup.MarkupMultilineAdapter;
  import gov.nist.secauto.metaschema.model.common.util.ObjectUtils;
  import java.lang.Override;
  import java.lang.String;
  import java.util.LinkedList;
  import java.util.List;
  import org.apache.commons.lang3.builder.MultilineRecursiveToStringStyle;
  import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
  
  /**
   * Set parameters or amend controls in resolution.
   */
  @MetaschemaAssembly(
      formalName = "Modify Controls",
      description = "Set parameters or amend controls in resolution.",
      name = "modify",
      metaschema = OscalProfileMetaschema.class
  )
  @AssemblyConstraints(
      isUnique = @IsUnique(id = "unique-profile-modify-set-parameter", level = IConstraint.Level.ERROR, target = "set-parameter", keyFields = @KeyField(target = "@param-id"), remarks = "Since multiple `set-parameter` entries can be provided, each parameter must be set only once.")
  )
  public class Modify {
    /**
     * "A parameter setting, to be propagated to points of insertion."
     */
    @BoundAssembly(
        formalName = "Parameter Setting",
        description = "A parameter setting, to be propagated to points of insertion.",
        useName = "set-parameter",
        maxOccurs = -1
    )
    @GroupAs(
        name = "set-parameters",
        inJson = JsonGroupAsBehavior.LIST
    )
    private List<ProfileSetParameter> _setParameters;
  
    /**
     * "Specifies changes to be made to an included control when a profile is resolved."
     */
    @BoundAssembly(
        formalName = "Alteration",
        description = "Specifies changes to be made to an included control when a profile is resolved.",
        useName = "alter",
        maxOccurs = -1,
        remarks = "Use `@control-id` to indicate the scope of alteration.\n"
                + "\n"
                + "It is an error for two `alter` elements to apply to the same control. In practice, multiple alterations can be applied (together), but it creates confusion.\n"
                + "\n"
                + "At present, no provision is made for altering many controls at once (for example, to systematically remove properties or add global properties); extending this element to match multiple control IDs could provide for this."
    )
    @GroupAs(
        name = "alters",
        inJson = JsonGroupAsBehavior.LIST
    )
    private List<Alter> _alters;
  
    public Modify() {
    }
  
    public List<ProfileSetParameter> getSetParameters() {
      return _setParameters;
    }
  
    public void setSetParameters(List<ProfileSetParameter> value) {
      _setParameters = value;
    }
  
    /**
     * Add a new {@link ProfileSetParameter} item to the underlying collection.
     * @param item the item to add
     * @return {@code true}
     */
    public boolean addSetParameter(ProfileSetParameter item) {
      ProfileSetParameter value = ObjectUtils.requireNonNull(item,"item cannot be null");
      if (_setParameters == null) {
        _setParameters = new LinkedList<>();
      }
      return _setParameters.add(value);
   }
 
   /**
    * Remove the first matching {@link ProfileSetParameter} item from the underlying collection.
    * @param item the item to remove
    * @return {@code true} if the item was removed or {@code false} otherwise
    */
   public boolean removeSetParameter(ProfileSetParameter item) {
     ProfileSetParameter value = ObjectUtils.requireNonNull(item,"item cannot be null");
     return _setParameters == null ? false : _setParameters.remove(value);
   }
 
   public List<Alter> getAlters() {
     return _alters;
   }
 
   public void setAlters(List<Alter> value) {
     _alters = value;
   }
 
   /**
    * Add a new {@link Alter} item to the underlying collection.
    * @param item the item to add
    * @return {@code true}
    */
   public boolean addAlter(Alter item) {
     Alter value = ObjectUtils.requireNonNull(item,"item cannot be null");
     if (_alters == null) {
       _alters = new LinkedList<>();
     }
     return _alters.add(value);
   }
 
   /**
    * Remove the first matching {@link Alter} item from the underlying collection.
    * @param item the item to remove
    * @return {@code true} if the item was removed or {@code false} otherwise
    */
   public boolean removeAlter(Alter item) {
     Alter value = ObjectUtils.requireNonNull(item,"item cannot be null");
     return _alters == null ? false : _alters.remove(value);
   }
 
   @Override
   public String toString() {
     return new ReflectionToStringBuilder(this, MultilineRecursiveToStringStyle.MULTI_LINE_STYLE).toString();
   }
 
   /**
    * Specifies changes to be made to an included control when a profile is resolved.
    */
   @MetaschemaAssembly(
       formalName = "Alteration",
       description = "Specifies changes to be made to an included control when a profile is resolved.",
       name = "alter",
       metaschema = OscalProfileMetaschema.class,
       remarks = "Use `@control-id` to indicate the scope of alteration.\n"
               + "\n"
               + "It is an error for two `alter` elements to apply to the same control. In practice, multiple alterations can be applied (together), but it creates confusion.\n"
               + "\n"
               + "At present, no provision is made for altering many controls at once (for example, to systematically remove properties or add global properties); extending this element to match multiple control IDs could provide for this."
   )
   public static class Alter {
     @BoundFlag(
         formalName = "Control Identifier Reference",
         description = "A reference to a control with a corresponding `id` value. When referencing an externally defined `control`, the `Control Identifier Reference` must be used in the context of the external / imported OSCAL instance (e.g., uri-reference).",
         useName = "control-id",
         required = true,
         typeAdapter = TokenAdapter.class
     )
     private String _controlId;
 
     /**
      * "Specifies objects to be removed from a control based on specific aspects of the object that must all match."
      */
     @BoundAssembly(
         formalName = "Removal",
         description = "Specifies objects to be removed from a control based on specific aspects of the object that must all match.",
         useName = "remove",
         maxOccurs = -1,
         remarks = "Use `by-name`, `by-class`, `by-id` or `by-item-name` to indicate class tokens or ID reference, or the formal name, of the component to be removed or erased from a control, when a catalog is resolved. The control affected is indicated by the pointer on the removal's parent (containing) `alter` element.\n"
                 + "\n"
                 + "To change an element, use `remove` to remove the element, then `add` to add it back again with changes."
     )
     @GroupAs(
         name = "removes",
         inJson = JsonGroupAsBehavior.LIST
     )
     private List<Remove> _removes;
 
     /**
      * "Specifies contents to be added into controls, in resolution."
      */
     @BoundAssembly(
         formalName = "Addition",
         description = "Specifies contents to be added into controls, in resolution.",
         useName = "add",
         maxOccurs = -1,
         remarks = "When no `by-id` is given, the addition is inserted into the control targeted by the alteration at the start or end as indicated by `position`. Only `position` values of \"starting\" or \"ending\" are permitted when there is no `by-id`.\n"
                 + "\n"
                 + "`by-id`, when given, should indicate, by its ID, an element inside the control to serve as the anchor point for the addition. In this case, `position` value may be any of the permitted values."
     )
     @GroupAs(
         name = "adds",
         inJson = JsonGroupAsBehavior.LIST
     )
     private List<Add> _adds;
 
     public Alter() {
     }
 
     public String getControlId() {
       return _controlId;
     }
 
     public void setControlId(String value) {
       _controlId = value;
     }
 
     public List<Remove> getRemoves() {
       return _removes;
     }
 
     public void setRemoves(List<Remove> value) {
       _removes = value;
     }
 
     /**
      * Add a new {@link Remove} item to the underlying collection.
      * @param item the item to add
      * @return {@code true}
      */
     public boolean addRemove(Remove item) {
       Remove value = ObjectUtils.requireNonNull(item,"item cannot be null");
       if (_removes == null) {
         _removes = new LinkedList<>();
       }
       return _removes.add(value);
     }
 
     /**
      * Remove the first matching {@link Remove} item from the underlying collection.
      * @param item the item to remove
      * @return {@code true} if the item was removed or {@code false} otherwise
      */
     public boolean removeRemove(Remove item) {
       Remove value = ObjectUtils.requireNonNull(item,"item cannot be null");
       return _removes == null ? false : _removes.remove(value);
     }
 
     public List<Add> getAdds() {
       return _adds;
     }
 
     public void setAdds(List<Add> value) {
       _adds = value;
     }
 
     /**
      * Add a new {@link Add} item to the underlying collection.
      * @param item the item to add
      * @return {@code true}
      */
     public boolean addAdd(Add item) {
       Add value = ObjectUtils.requireNonNull(item,"item cannot be null");
       if (_adds == null) {
         _adds = new LinkedList<>();
       }
       return _adds.add(value);
     }
 
     /**
      * Remove the first matching {@link Add} item from the underlying collection.
      * @param item the item to remove
      * @return {@code true} if the item was removed or {@code false} otherwise
      */
     public boolean removeAdd(Add item) {
       Add value = ObjectUtils.requireNonNull(item,"item cannot be null");
       return _adds == null ? false : _adds.remove(value);
     }
 
     @Override
     public String toString() {
       return new ReflectionToStringBuilder(this, MultilineRecursiveToStringStyle.MULTI_LINE_STYLE).toString();
     }
 
     /**
      * Specifies contents to be added into controls, in resolution.
      */
     @MetaschemaAssembly(
         formalName = "Addition",
         description = "Specifies contents to be added into controls, in resolution.",
         name = "add",
         metaschema = OscalProfileMetaschema.class,
         remarks = "When no `by-id` is given, the addition is inserted into the control targeted by the alteration at the start or end as indicated by `position`. Only `position` values of \"starting\" or \"ending\" are permitted when there is no `by-id`.\n"
                 + "\n"
                 + "`by-id`, when given, should indicate, by its ID, an element inside the control to serve as the anchor point for the addition. In this case, `position` value may be any of the permitted values."
     )
     @ValueConstraints(
         allowedValues = @AllowedValues(level = IConstraint.Level.ERROR, target = "prop[has-oscal-namespace('http://csrc.nist.gov/ns/oscal')]/@name", values = {@AllowedValue(value = "label", description = "A human-readable label for the parent context, which may be rendered in place of the actual identifier for some use cases."), @AllowedValue(value = "sort-id", description = "An alternative identifier, whose value is easily sortable among other such values in the document."), @AllowedValue(value = "alt-identifier", description = "An alternate or aliased identifier for the parent context.")})
     )
     public static class Add {
       @BoundFlag(
           formalName = "Position",
           description = "Where to add the new content with respect to the targeted element (beside it or inside it).",
           useName = "position",
           typeAdapter = TokenAdapter.class
       )
       @ValueConstraints(
           allowedValues = @AllowedValues(level = IConstraint.Level.ERROR, values = {@AllowedValue(value = "before", description = "Preceding the by-id target"), @AllowedValue(value = "after", description = "Following the by-id target"), @AllowedValue(value = "starting", description = "Inside the control or by-id target, at the start"), @AllowedValue(value = "ending", description = "Inside the control or by-id target, at the end")})
       )
       private String _position;
 
       @BoundFlag(
           formalName = "Reference by ID",
           description = "Target location of the addition.",
           useName = "by-id",
           typeAdapter = TokenAdapter.class
       )
       private String _byId;
 
       /**
        * "A name given to the control, which may be used by a tool for display and navigation."
        */
       @BoundField(
           formalName = "Title Change",
           description = "A name given to the control, which may be used by a tool for display and navigation.",
           useName = "title"
       )
       @BoundFieldValue(
           typeAdapter = MarkupLineAdapter.class
       )
       private MarkupLine _title;
 
       @BoundAssembly(
           formalName = "Parameter",
           description = "Parameters provide a mechanism for the dynamic assignment of value(s) in a control.",
           useName = "param",
           maxOccurs = -1
       )
       @GroupAs(
           name = "params",
           inJson = JsonGroupAsBehavior.LIST
       )
       private List<Parameter> _params;
 
       @BoundAssembly(
           formalName = "Property",
           description = "An attribute, characteristic, or quality of the containing object expressed as a namespace qualified name/value pair.",
           useName = "prop",
           maxOccurs = -1
       )
       @GroupAs(
           name = "props",
           inJson = JsonGroupAsBehavior.LIST
       )
       private List<Property> _props;
 
       @BoundAssembly(
           formalName = "Link",
           description = "A reference to a local or remote resource, that has a specific relation to the containing object.",
           useName = "link",
           maxOccurs = -1
       )
       @GroupAs(
           name = "links",
           inJson = JsonGroupAsBehavior.LIST
       )
       private List<Link> _links;
 
       @BoundAssembly(
           formalName = "Part",
           description = "An annotated, markup-based textual element of a control's or catalog group's definition, or a child of another part.",
           useName = "part",
           maxOccurs = -1
       )
       @GroupAs(
           name = "parts",
           inJson = JsonGroupAsBehavior.LIST
       )
       private List<ControlPart> _parts;
 
       public Add() {
       }
 
       public String getPosition() {
         return _position;
       }
 
       public void setPosition(String value) {
         _position = value;
       }
 
       public String getById() {
         return _byId;
       }
 
       public void setById(String value) {
         _byId = value;
       }
 
       public MarkupLine getTitle() {
         return _title;
       }
 
       public void setTitle(MarkupLine value) {
         _title = value;
       }
 
       public List<Parameter> getParams() {
         return _params;
       }
 
       public void setParams(List<Parameter> value) {
         _params = value;
       }
 
       /**
        * Add a new {@link Parameter} item to the underlying collection.
        * @param item the item to add
        * @return {@code true}
        */
       public boolean addParam(Parameter item) {
         Parameter value = ObjectUtils.requireNonNull(item,"item cannot be null");
         if (_params == null) {
           _params = new LinkedList<>();
         }
         return _params.add(value);
       }
 
       /**
        * Remove the first matching {@link Parameter} item from the underlying collection.
        * @param item the item to remove
        * @return {@code true} if the item was removed or {@code false} otherwise
        */
       public boolean removeParam(Parameter item) {
         Parameter value = ObjectUtils.requireNonNull(item,"item cannot be null");
         return _params == null ? false : _params.remove(value);
       }
 
       public List<Property> getProps() {
         return _props;
       }
 
       public void setProps(List<Property> value) {
         _props = value;
       }
 
       /**
        * Add a new {@link Property} item to the underlying collection.
        * @param item the item to add
        * @return {@code true}
        */
       public boolean addProp(Property item) {
         Property value = ObjectUtils.requireNonNull(item,"item cannot be null");
         if (_props == null) {
           _props = new LinkedList<>();
         }
         return _props.add(value);
       }
 
       /**
        * Remove the first matching {@link Property} item from the underlying collection.
        * @param item the item to remove
        * @return {@code true} if the item was removed or {@code false} otherwise
        */
       public boolean removeProp(Property item) {
         Property value = ObjectUtils.requireNonNull(item,"item cannot be null");
         return _props == null ? false : _props.remove(value);
       }
 
       public List<Link> getLinks() {
         return _links;
       }
 
       public void setLinks(List<Link> value) {
         _links = value;
       }
 
       /**
        * Add a new {@link Link} item to the underlying collection.
        * @param item the item to add
        * @return {@code true}
        */
       public boolean addLink(Link item) {
         Link value = ObjectUtils.requireNonNull(item,"item cannot be null");
         if (_links == null) {
           _links = new LinkedList<>();
         }
         return _links.add(value);
       }
 
       /**
        * Remove the first matching {@link Link} item from the underlying collection.
        * @param item the item to remove
        * @return {@code true} if the item was removed or {@code false} otherwise
        */
       public boolean removeLink(Link item) {
         Link value = ObjectUtils.requireNonNull(item,"item cannot be null");
         return _links == null ? false : _links.remove(value);
       }
 
       public List<ControlPart> getParts() {
         return _parts;
       }
 
       public void setParts(List<ControlPart> value) {
         _parts = value;
       }
 
       /**
        * Add a new {@link ControlPart} item to the underlying collection.
        * @param item the item to add
        * @return {@code true}
        */
       public boolean addPart(ControlPart item) {
         ControlPart value = ObjectUtils.requireNonNull(item,"item cannot be null");
         if (_parts == null) {
           _parts = new LinkedList<>();
         }
         return _parts.add(value);
       }
 
       /**
        * Remove the first matching {@link ControlPart} item from the underlying collection.
        * @param item the item to remove
        * @return {@code true} if the item was removed or {@code false} otherwise
        */
       public boolean removePart(ControlPart item) {
         ControlPart value = ObjectUtils.requireNonNull(item,"item cannot be null");
         return _parts == null ? false : _parts.remove(value);
       }
 
       @Override
       public String toString() {
         return new ReflectionToStringBuilder(this, MultilineRecursiveToStringStyle.MULTI_LINE_STYLE).toString();
       }
     }
 
     /**
      * Specifies objects to be removed from a control based on specific aspects of the object that must all match.
      */
     @MetaschemaAssembly(
         formalName = "Removal",
         description = "Specifies objects to be removed from a control based on specific aspects of the object that must all match.",
         name = "remove",
         metaschema = OscalProfileMetaschema.class,
         remarks = "Use `by-name`, `by-class`, `by-id` or `by-item-name` to indicate class tokens or ID reference, or the formal name, of the component to be removed or erased from a control, when a catalog is resolved. The control affected is indicated by the pointer on the removal's parent (containing) `alter` element.\n"
                 + "\n"
                 + "To change an element, use `remove` to remove the element, then `add` to add it back again with changes."
     )
     public static class Remove {
       @BoundFlag(
           formalName = "Reference by (assigned) name",
           description = "Identify items remove by matching their assigned name.",
           useName = "by-name",
           typeAdapter = TokenAdapter.class
       )
       private String _byName;
 
       @BoundFlag(
           formalName = "Reference by class",
           description = "Identify items to remove by matching their `class`.",
           useName = "by-class",
           typeAdapter = TokenAdapter.class
       )
       private String _byClass;
 
       @BoundFlag(
           formalName = "Reference by ID",
           description = "Identify items to remove indicated by their `id`.",
           useName = "by-id",
           typeAdapter = TokenAdapter.class
       )
       private String _byId;
 
       @BoundFlag(
           formalName = "Item Name Reference",
           description = "Identify items to remove by the name of the item's information object name, e.g. `title` or `prop`.",
           useName = "by-item-name",
           typeAdapter = TokenAdapter.class
       )
       @ValueConstraints(
           allowedValues = @AllowedValues(level = IConstraint.Level.ERROR, values = {@AllowedValue(value = "param", description = "A descendant parameter and all of its descendants."), @AllowedValue(value = "prop", description = "A descendant property and all of its descendants."), @AllowedValue(value = "link", description = "A descendant link and all of its descendants."), @AllowedValue(value = "part", description = "A descendant parameter and all of its descendants."), @AllowedValue(value = "mapping", description = "A descendant mapping and all of its descendants."), @AllowedValue(value = "map", description = "A descendant mapping entry (map) and all of its descendants.")})
       )
       private String _byItemName;
 
       @BoundFlag(
           formalName = "Item Namespace Reference",
           description = "Identify items to remove by the item's `ns`, which is the namespace associated with a `part`, or `prop`.",
           useName = "by-ns",
           typeAdapter = TokenAdapter.class
       )
       private String _byNs;
 
       public Remove() {
       }
 
       public String getByName() {
         return _byName;
       }
 
       public void setByName(String value) {
         _byName = value;
       }
 
       public String getByClass() {
         return _byClass;
       }
 
       public void setByClass(String value) {
         _byClass = value;
       }
 
       public String getById() {
         return _byId;
       }
 
       public void setById(String value) {
         _byId = value;
       }
 
       public String getByItemName() {
         return _byItemName;
       }
 
       public void setByItemName(String value) {
         _byItemName = value;
       }
 
       public String getByNs() {
         return _byNs;
       }
 
       public void setByNs(String value) {
         _byNs = value;
       }
 
       @Override
       public String toString() {
         return new ReflectionToStringBuilder(this, MultilineRecursiveToStringStyle.MULTI_LINE_STYLE).toString();
       }
     }
   }
 
   /**
    * A parameter setting, to be propagated to points of insertion.
    */
   @MetaschemaAssembly(
       formalName = "Parameter Setting",
       description = "A parameter setting, to be propagated to points of insertion.",
       name = "set-parameter",
       metaschema = OscalProfileMetaschema.class
   )
   public static class ProfileSetParameter {
     @BoundFlag(
         formalName = "Parameter ID",
         description = "An identifier for the parameter.",
         useName = "param-id",
         required = true,
         typeAdapter = TokenAdapter.class
     )
     private String _paramId;
 
     @BoundFlag(
         formalName = "Parameter Class",
         description = "A textual label that provides a characterization of the parameter.",
         useName = "class",
         typeAdapter = TokenAdapter.class,
         remarks = "A `class` can be used in validation rules to express extra constraints over named items of a specific `class` value."
     )
     private String _clazz;
 
     @BoundFlag(
         formalName = "Depends On",
         description = "\\*\\*(deprecated)\\*\\* Another parameter invoking this one. This construct has been deprecated and should not be used.",
         useName = "depends-on",
         typeAdapter = TokenAdapter.class
     )
     private String _dependsOn;
 
     @BoundAssembly(
         formalName = "Property",
         description = "An attribute, characteristic, or quality of the containing object expressed as a namespace qualified name/value pair.",
         useName = "prop",
         maxOccurs = -1
     )
     @GroupAs(
         name = "props",
         inJson = JsonGroupAsBehavior.LIST
     )
     private List<Property> _props;
 
     @BoundAssembly(
         formalName = "Link",
         description = "A reference to a local or remote resource, that has a specific relation to the containing object.",
         useName = "link",
         maxOccurs = -1
     )
     @GroupAs(
         name = "links",
         inJson = JsonGroupAsBehavior.LIST
     )
     private List<Link> _links;
 
     /**
      * "A short, placeholder name for the parameter, which can be used as a substitute for a <code>value</code> if no value is assigned."
      */
     @BoundField(
         formalName = "Parameter Label",
         description = "A short, placeholder name for the parameter, which can be used as a substitute for a `value` if no value is assigned.",
         useName = "label",
         remarks = "The label value should be suitable for inline display in a rendered catalog."
     )
     @BoundFieldValue(
         typeAdapter = MarkupLineAdapter.class
     )
     private MarkupLine _label;
 
     /**
      * "Describes the purpose and use of a parameter."
      */
     @BoundField(
         formalName = "Parameter Usage Description",
         description = "Describes the purpose and use of a parameter.",
         useName = "usage"
     )
     @BoundFieldValue(
         typeAdapter = MarkupMultilineAdapter.class
     )
     private MarkupMultiline _usage;
 
     @BoundAssembly(
         formalName = "Constraint",
         description = "A formal or informal expression of a constraint or test.",
         useName = "constraint",
         maxOccurs = -1
     )
     @GroupAs(
         name = "constraints",
         inJson = JsonGroupAsBehavior.LIST
     )
     private List<ParameterConstraint> _constraints;
 
     @BoundAssembly(
         formalName = "Guideline",
         description = "A prose statement that provides a recommendation for the use of a parameter.",
         useName = "guideline",
         maxOccurs = -1
     )
     @GroupAs(
         name = "guidelines",
         inJson = JsonGroupAsBehavior.LIST
     )
     private List<ParameterGuideline> _guidelines;
 
     @BoundField(
         formalName = "Parameter Value",
         description = "A parameter value or set of values.",
         useName = "value",
         maxOccurs = -1,
         remarks = "Used to (re)define a parameter value."
     )
     @GroupAs(
         name = "values",
         inJson = JsonGroupAsBehavior.LIST
     )
     private List<String> _values;
 
     @BoundAssembly(
         formalName = "Selection",
         description = "Presenting a choice among alternatives.",
         useName = "select"
     )
     private ParameterSelection _select;
 
     public ProfileSetParameter() {
     }
 
     public String getParamId() {
       return _paramId;
     }
 
     public void setParamId(String value) {
       _paramId = value;
     }
 
     public String getClazz() {
       return _clazz;
     }
 
     public void setClazz(String value) {
       _clazz = value;
     }
 
     public String getDependsOn() {
       return _dependsOn;
     }
 
     public void setDependsOn(String value) {
       _dependsOn = value;
     }
 
     public List<Property> getProps() {
       return _props;
     }
 
     public void setProps(List<Property> value) {
       _props = value;
     }
 
     /**
      * Add a new {@link Property} item to the underlying collection.
      * @param item the item to add
      * @return {@code true}
      */
     public boolean addProp(Property item) {
       Property value = ObjectUtils.requireNonNull(item,"item cannot be null");
       if (_props == null) {
         _props = new LinkedList<>();
       }
       return _props.add(value);
     }
 
     /**
      * Remove the first matching {@link Property} item from the underlying collection.
      * @param item the item to remove
      * @return {@code true} if the item was removed or {@code false} otherwise
      */
     public boolean removeProp(Property item) {
       Property value = ObjectUtils.requireNonNull(item,"item cannot be null");
       return _props == null ? false : _props.remove(value);
     }
 
     public List<Link> getLinks() {
       return _links;
     }
 
     public void setLinks(List<Link> value) {
       _links = value;
     }
 
     /**
      * Add a new {@link Link} item to the underlying collection.
      * @param item the item to add
      * @return {@code true}
      */
     public boolean addLink(Link item) {
       Link value = ObjectUtils.requireNonNull(item,"item cannot be null");
       if (_links == null) {
         _links = new LinkedList<>();
       }
       return _links.add(value);
     }
 
     /**
      * Remove the first matching {@link Link} item from the underlying collection.
      * @param item the item to remove
      * @return {@code true} if the item was removed or {@code false} otherwise
      */
     public boolean removeLink(Link item) {
       Link value = ObjectUtils.requireNonNull(item,"item cannot be null");
       return _links == null ? false : _links.remove(value);
     }
 
     public MarkupLine getLabel() {
       return _label;
     }
 
     public void setLabel(MarkupLine value) {
       _label = value;
     }
 
     public MarkupMultiline getUsage() {
       return _usage;
     }
 
     public void setUsage(MarkupMultiline value) {
       _usage = value;
     }
 
     public List<ParameterConstraint> getConstraints() {
       return _constraints;
     }
 
     public void setConstraints(List<ParameterConstraint> value) {
       _constraints = value;
     }
 
     /**
      * Add a new {@link ParameterConstraint} item to the underlying collection.
      * @param item the item to add
      * @return {@code true}
      */
     public boolean addConstraint(ParameterConstraint item) {
       ParameterConstraint value = ObjectUtils.requireNonNull(item,"item cannot be null");
       if (_constraints == null) {
         _constraints = new LinkedList<>();
       }
       return _constraints.add(value);
     }
 
     /**
      * Remove the first matching {@link ParameterConstraint} item from the underlying collection.
      * @param item the item to remove
      * @return {@code true} if the item was removed or {@code false} otherwise
      */
     public boolean removeConstraint(ParameterConstraint item) {
       ParameterConstraint value = ObjectUtils.requireNonNull(item,"item cannot be null");
       return _constraints == null ? false : _constraints.remove(value);
     }
 
     public List<ParameterGuideline> getGuidelines() {
       return _guidelines;
     }
 
     public void setGuidelines(List<ParameterGuideline> value) {
       _guidelines = value;
     }
 
     /**
      * Add a new {@link ParameterGuideline} item to the underlying collection.
      * @param item the item to add
      * @return {@code true}
      */
     public boolean addGuideline(ParameterGuideline item) {
       ParameterGuideline value = ObjectUtils.requireNonNull(item,"item cannot be null");
       if (_guidelines == null) {
         _guidelines = new LinkedList<>();
       }
       return _guidelines.add(value);
     }
 
     /**
      * Remove the first matching {@link ParameterGuideline} item from the underlying collection.
      * @param item the item to remove
      * @return {@code true} if the item was removed or {@code false} otherwise
      */
     public boolean removeGuideline(ParameterGuideline item) {
       ParameterGuideline value = ObjectUtils.requireNonNull(item,"item cannot be null");
       return _guidelines == null ? false : _guidelines.remove(value);
     }
 
     public List<String> getValues() {
       return _values;
     }
 
     public void setValues(List<String> value) {
       _values = value;
     }
 
     /**
      * Add a new {@link String} item to the underlying collection.
      * @param item the item to add
      * @return {@code true}
      */
     public boolean addValue(String item) {
       String value = ObjectUtils.requireNonNull(item,"item cannot be null");
       if (_values == null) {
         _values = new LinkedList<>();
       }
       return _values.add(value);
     }
 
     /**
      * Remove the first matching {@link String} item from the underlying collection.
      * @param item the item to remove
      * @return {@code true} if the item was removed or {@code false} otherwise
      */
     public boolean removeValue(String item) {
       String value = ObjectUtils.requireNonNull(item,"item cannot be null");
       return _values == null ? false : _values.remove(value);
     }
 
     public ParameterSelection getSelect() {
       return _select;
     }
 
     public void setSelect(ParameterSelection value) {
       _select = value;
     }
 
     @Override
     public String toString() {
       return new ReflectionToStringBuilder(this, MultilineRecursiveToStringStyle.MULTI_LINE_STYLE).toString();
     }
   }
 }