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();
    }
  }
}