Source code

001package gov.nist.secauto.oscal.lib.model;
002
003import gov.nist.secauto.metaschema.binding.model.annotations.AllowedValue;
004import gov.nist.secauto.metaschema.binding.model.annotations.AllowedValues;
005import gov.nist.secauto.metaschema.binding.model.annotations.AssemblyConstraints;
006import gov.nist.secauto.metaschema.binding.model.annotations.BoundAssembly;
007import gov.nist.secauto.metaschema.binding.model.annotations.BoundField;
008import gov.nist.secauto.metaschema.binding.model.annotations.BoundFieldValue;
009import gov.nist.secauto.metaschema.binding.model.annotations.BoundFlag;
010import gov.nist.secauto.metaschema.binding.model.annotations.GroupAs;
011import gov.nist.secauto.metaschema.binding.model.annotations.HasCardinality;
012import gov.nist.secauto.metaschema.binding.model.annotations.IndexHasKey;
013import gov.nist.secauto.metaschema.binding.model.annotations.IsUnique;
014import gov.nist.secauto.metaschema.binding.model.annotations.KeyField;
015import gov.nist.secauto.metaschema.binding.model.annotations.MetaschemaAssembly;
016import gov.nist.secauto.metaschema.binding.model.annotations.ValueConstraints;
017import gov.nist.secauto.metaschema.model.common.JsonGroupAsBehavior;
018import gov.nist.secauto.metaschema.model.common.constraint.IConstraint;
019import gov.nist.secauto.metaschema.model.common.datatype.adapter.UuidAdapter;
020import gov.nist.secauto.metaschema.model.common.datatype.markup.MarkupMultiline;
021import gov.nist.secauto.metaschema.model.common.datatype.markup.MarkupMultilineAdapter;
022import gov.nist.secauto.metaschema.model.common.util.ObjectUtils;
023import java.lang.Override;
024import java.lang.String;
025import java.util.LinkedList;
026import java.util.List;
027import java.util.UUID;
028import org.apache.commons.lang3.builder.MultilineRecursiveToStringStyle;
029import org.apache.commons.lang3.builder.ReflectionToStringBuilder;
030
031/**
032 * Defines how the referenced component implements a set of controls.
033 */
034@MetaschemaAssembly(
035    formalName = "Component Control Implementation",
036    description = "Defines how the referenced component implements a set of controls.",
037    name = "by-component",
038    metaschema = OscalSspMetaschema.class,
039    remarks = "Use of `set-parameter` in this context, sets the parameter for the control referenced in the containing `implemented-requirement` applied to the referenced component. If the `by-component` is used as a child of a `statement`, then the parameter value also applies only in the context of the referenced statement. If the same parameter is also set in the `control-implementation` or a specific `implemented-requirement`, then this `by-component/set-parameter` value will override the other value(s) in the context of the referenced component, control, and statement (if parent)."
040)
041@ValueConstraints(
042    allowedValues = {
043        @AllowedValues(level = IConstraint.Level.ERROR, target = "link/@rel", allowOthers = true, values = @AllowedValue(value = "imported-from", description = "The hyperlink identifies a URI pointing to the `component` in a `component-definition` that originally described the `component` this component was based on.")),
044        @AllowedValues(level = IConstraint.Level.ERROR, target = ".//responsible-role/@role-id", allowOthers = true, values = {@AllowedValue(value = "asset-owner", description = "Accountable for ensuring the asset is managed in accordance with organizational policies and procedures."), @AllowedValue(value = "asset-administrator", description = "Responsible for administering a set of assets."), @AllowedValue(value = "security-operations", description = "Members of the security operations center (SOC)."), @AllowedValue(value = "network-operations", description = "Members of the network operations center (NOC)."), @AllowedValue(value = "incident-response", description = "Responsible for responding to an event that could lead to loss of, or disruption to, an organization's operations, services or functions."), @AllowedValue(value = "help-desk", description = "Responsible for providing information and support to users."), @AllowedValue(value = "configuration-management", description = "Responsible for the configuration management processes governing changes to the asset."), @AllowedValue(value = "maintainer", description = "Responsible for the creation and maintenance of a component."), @AllowedValue(value = "provider", description = "Organization responsible for providing the component, if this is different from the \"maintainer\" (e.g., a reseller).")}),
045        @AllowedValues(level = IConstraint.Level.ERROR, target = "link/@rel", allowOthers = true, values = @AllowedValue(value = "provided-by", description = "A reference to the UUID of a control or statement `by-component` object that is used as evidence of implementation."))
046    },
047    indexHasKey = @IndexHasKey(level = IConstraint.Level.ERROR, target = "link[@rel='provided-by']", indexName = "by-component-uuid", keyFields = @KeyField(target = "@href", pattern = "#(.*)"))
048)
049@AssemblyConstraints(
050    isUnique = @IsUnique(id = "unique-ssp-by-component-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.")
051)
052public class ByComponent {
053  @BoundFlag(
054      formalName = "Component Universally Unique Identifier Reference",
055      description = "A [machine-oriented](https://pages.nist.gov/OSCAL/concepts/identifier-use/#machine-oriented) identifier reference to the `component` that is implemeting a given control.",
056      useName = "component-uuid",
057      required = true,
058      typeAdapter = UuidAdapter.class
059  )
060  private UUID _componentUuid;
061
062  @BoundFlag(
063      formalName = "By-Component Universally Unique Identifier",
064      description = "A [machine-oriented](https://pages.nist.gov/OSCAL/concepts/identifier-use/#machine-oriented), [globally unique](https://pages.nist.gov/OSCAL/concepts/identifier-use/#globally-unique) identifier with [cross-instance](https://pages.nist.gov/OSCAL/concepts/identifier-use/#cross-instance) scope that can be used to reference this by-component entry elsewhere in [this or other OSCAL instances](https://pages.nist.gov/OSCAL/concepts/identifier-use/#ssp-identifiers). The locally defined *UUID* of the `by-component` entry can be used to reference the data item locally or globally (e.g., in an imported OSCAL instance). This UUID should be assigned [per-subject](https://pages.nist.gov/OSCAL/concepts/identifier-use/#consistency), which means it should be consistently used to identify the same subject across revisions of the document.",
065      useName = "uuid",
066      required = true,
067      typeAdapter = UuidAdapter.class
068  )
069  private UUID _uuid;
070
071  /**
072   * "An implementation statement that describes how a control or a control statement is implemented within the referenced system component."
073   */
074  @BoundField(
075      formalName = "Control Implementation Description",
076      description = "An implementation statement that describes how a control or a control statement is implemented within the referenced system component.",
077      useName = "description",
078      minOccurs = 1
079  )
080  @BoundFieldValue(
081      typeAdapter = MarkupMultilineAdapter.class
082  )
083  private MarkupMultiline _description;
084
085  @BoundAssembly(
086      formalName = "Property",
087      description = "An attribute, characteristic, or quality of the containing object expressed as a namespace qualified name/value pair.",
088      useName = "prop",
089      maxOccurs = -1
090  )
091  @GroupAs(
092      name = "props",
093      inJson = JsonGroupAsBehavior.LIST
094  )
095  private List<Property> _props;
096
097  @BoundAssembly(
098      formalName = "Link",
099      description = "A reference to a local or remote resource, that has a specific relation to the containing object.",
100      useName = "link",
101      maxOccurs = -1
102  )
103  @GroupAs(
104      name = "links",
105      inJson = JsonGroupAsBehavior.LIST
106  )
107  private List<Link> _links;
108
109  @BoundAssembly(
110      formalName = "Set Parameter Value",
111      description = "Identifies the parameter that will be set by the enclosed value.",
112      useName = "set-parameter",
113      maxOccurs = -1
114  )
115  @GroupAs(
116      name = "set-parameters",
117      inJson = JsonGroupAsBehavior.LIST
118  )
119  private List<SetParameter> _setParameters;
120
121  @BoundAssembly(
122      formalName = "Implementation Status",
123      description = "Indicates the degree to which the a given control is implemented.",
124      useName = "implementation-status",
125      remarks = "The `implementation-status` is used to qualify the `status` value to indicate the degree to which the control is implemented."
126  )
127  private ImplementationStatus _implementationStatus;
128
129  /**
130   * "Identifies content intended for external consumption, such as with leveraged organizations."
131   */
132  @BoundAssembly(
133      formalName = "Export",
134      description = "Identifies content intended for external consumption, such as with leveraged organizations.",
135      useName = "export"
136  )
137  private Export _export;
138
139  /**
140   * "Describes a control implementation inherited by a leveraging system."
141   */
142  @BoundAssembly(
143      formalName = "Inherited Control Implementation",
144      description = "Describes a control implementation inherited by a leveraging system.",
145      useName = "inherited",
146      maxOccurs = -1
147  )
148  @GroupAs(
149      name = "inherited",
150      inJson = JsonGroupAsBehavior.LIST
151  )
152  private List<Inherited> _inherited;
153
154  /**
155   * "Describes how this system satisfies a responsibility imposed by a leveraged system."
156   */
157  @BoundAssembly(
158      formalName = "Satisfied Control Implementation Responsibility",
159      description = "Describes how this system satisfies a responsibility imposed by a leveraged system.",
160      useName = "satisfied",
161      maxOccurs = -1
162  )
163  @GroupAs(
164      name = "satisfied",
165      inJson = JsonGroupAsBehavior.LIST
166  )
167  private List<Satisfied> _satisfied;
168
169  @BoundAssembly(
170      formalName = "Responsible Role",
171      description = "A reference to a role with responsibility for performing a function relative to the containing object, optionally associated with a set of persons and/or organizations that perform that role.",
172      useName = "responsible-role",
173      maxOccurs = -1
174  )
175  @GroupAs(
176      name = "responsible-roles",
177      inJson = JsonGroupAsBehavior.LIST
178  )
179  private List<ResponsibleRole> _responsibleRoles;
180
181  @BoundField(
182      formalName = "Remarks",
183      description = "Additional commentary about the containing object.",
184      useName = "remarks"
185  )
186  @BoundFieldValue(
187      typeAdapter = MarkupMultilineAdapter.class
188  )
189  private MarkupMultiline _remarks;
190
191  public ByComponent() {
192  }
193
194  public UUID getComponentUuid() {
195    return _componentUuid;
196  }
197
198  public void setComponentUuid(UUID value) {
199    _componentUuid = value;
200  }
201
202  public UUID getUuid() {
203    return _uuid;
204  }
205
206  public void setUuid(UUID value) {
207    _uuid = value;
208  }
209
210  public MarkupMultiline getDescription() {
211    return _description;
212  }
213
214  public void setDescription(MarkupMultiline value) {
215    _description = value;
216  }
217
218  public List<Property> getProps() {
219    return _props;
220  }
221
222  public void setProps(List<Property> value) {
223    _props = value;
224  }
225
226  /**
227   * Add a new {@link Property} item to the underlying collection.
228   * @param item the item to add
229   * @return {@code true}
230   */
231  public boolean addProp(Property item) {
232    Property value = ObjectUtils.requireNonNull(item,"item cannot be null");
233    if (_props == null) {
234      _props = new LinkedList<>();
235    }
236    return _props.add(value);
237  }
238
239  /**
240   * Remove the first matching {@link Property} item from the underlying collection.
241   * @param item the item to remove
242   * @return {@code true} if the item was removed or {@code false} otherwise
243   */
244  public boolean removeProp(Property item) {
245    Property value = ObjectUtils.requireNonNull(item,"item cannot be null");
246    return _props == null ? false : _props.remove(value);
247  }
248
249  public List<Link> getLinks() {
250    return _links;
251  }
252
253  public void setLinks(List<Link> value) {
254    _links = value;
255  }
256
257  /**
258   * Add a new {@link Link} item to the underlying collection.
259   * @param item the item to add
260   * @return {@code true}
261   */
262  public boolean addLink(Link item) {
263    Link value = ObjectUtils.requireNonNull(item,"item cannot be null");
264    if (_links == null) {
265      _links = new LinkedList<>();
266    }
267    return _links.add(value);
268  }
269
270  /**
271   * Remove the first matching {@link Link} item from the underlying collection.
272   * @param item the item to remove
273   * @return {@code true} if the item was removed or {@code false} otherwise
274   */
275  public boolean removeLink(Link item) {
276    Link value = ObjectUtils.requireNonNull(item,"item cannot be null");
277    return _links == null ? false : _links.remove(value);
278  }
279
280  public List<SetParameter> getSetParameters() {
281    return _setParameters;
282  }
283
284  public void setSetParameters(List<SetParameter> value) {
285    _setParameters = value;
286  }
287
288  /**
289   * Add a new {@link SetParameter} item to the underlying collection.
290   * @param item the item to add
291   * @return {@code true}
292   */
293  public boolean addSetParameter(SetParameter item) {
294    SetParameter value = ObjectUtils.requireNonNull(item,"item cannot be null");
295    if (_setParameters == null) {
296      _setParameters = new LinkedList<>();
297    }
298    return _setParameters.add(value);
299  }
300
301  /**
302   * Remove the first matching {@link SetParameter} item from the underlying collection.
303   * @param item the item to remove
304   * @return {@code true} if the item was removed or {@code false} otherwise
305   */
306  public boolean removeSetParameter(SetParameter item) {
307    SetParameter value = ObjectUtils.requireNonNull(item,"item cannot be null");
308    return _setParameters == null ? false : _setParameters.remove(value);
309  }
310
311  public ImplementationStatus getImplementationStatus() {
312    return _implementationStatus;
313  }
314
315  public void setImplementationStatus(ImplementationStatus value) {
316    _implementationStatus = value;
317  }
318
319  public Export getExport() {
320    return _export;
321  }
322
323  public void setExport(Export value) {
324    _export = value;
325  }
326
327  public List<Inherited> getInherited() {
328    return _inherited;
329  }
330
331  public void setInherited(List<Inherited> value) {
332    _inherited = value;
333  }
334
335  /**
336   * Add a new {@link Inherited} item to the underlying collection.
337   * @param item the item to add
338   * @return {@code true}
339   */
340  public boolean addInherited(Inherited item) {
341    Inherited value = ObjectUtils.requireNonNull(item,"item cannot be null");
342    if (_inherited == null) {
343      _inherited = new LinkedList<>();
344    }
345    return _inherited.add(value);
346  }
347
348  /**
349   * Remove the first matching {@link Inherited} item from the underlying collection.
350   * @param item the item to remove
351   * @return {@code true} if the item was removed or {@code false} otherwise
352   */
353  public boolean removeInherited(Inherited item) {
354    Inherited value = ObjectUtils.requireNonNull(item,"item cannot be null");
355    return _inherited == null ? false : _inherited.remove(value);
356  }
357
358  public List<Satisfied> getSatisfied() {
359    return _satisfied;
360  }
361
362  public void setSatisfied(List<Satisfied> value) {
363    _satisfied = value;
364  }
365
366  /**
367   * Add a new {@link Satisfied} item to the underlying collection.
368   * @param item the item to add
369   * @return {@code true}
370   */
371  public boolean addSatisfied(Satisfied item) {
372    Satisfied value = ObjectUtils.requireNonNull(item,"item cannot be null");
373    if (_satisfied == null) {
374      _satisfied = new LinkedList<>();
375    }
376    return _satisfied.add(value);
377  }
378
379  /**
380   * Remove the first matching {@link Satisfied} item from the underlying collection.
381   * @param item the item to remove
382   * @return {@code true} if the item was removed or {@code false} otherwise
383   */
384  public boolean removeSatisfied(Satisfied item) {
385    Satisfied value = ObjectUtils.requireNonNull(item,"item cannot be null");
386    return _satisfied == null ? false : _satisfied.remove(value);
387  }
388
389  public List<ResponsibleRole> getResponsibleRoles() {
390    return _responsibleRoles;
391  }
392
393  public void setResponsibleRoles(List<ResponsibleRole> value) {
394    _responsibleRoles = value;
395  }
396
397  /**
398   * Add a new {@link ResponsibleRole} item to the underlying collection.
399   * @param item the item to add
400   * @return {@code true}
401   */
402  public boolean addResponsibleRole(ResponsibleRole item) {
403    ResponsibleRole value = ObjectUtils.requireNonNull(item,"item cannot be null");
404    if (_responsibleRoles == null) {
405      _responsibleRoles = new LinkedList<>();
406    }
407    return _responsibleRoles.add(value);
408  }
409
410  /**
411   * Remove the first matching {@link ResponsibleRole} item from the underlying collection.
412   * @param item the item to remove
413   * @return {@code true} if the item was removed or {@code false} otherwise
414   */
415  public boolean removeResponsibleRole(ResponsibleRole item) {
416    ResponsibleRole value = ObjectUtils.requireNonNull(item,"item cannot be null");
417    return _responsibleRoles == null ? false : _responsibleRoles.remove(value);
418  }
419
420  public MarkupMultiline getRemarks() {
421    return _remarks;
422  }
423
424  public void setRemarks(MarkupMultiline value) {
425    _remarks = value;
426  }
427
428  @Override
429  public String toString() {
430    return new ReflectionToStringBuilder(this, MultilineRecursiveToStringStyle.MULTI_LINE_STYLE).toString();
431  }
432
433  /**
434   * Describes a control implementation inherited by a leveraging system.
435   */
436  @MetaschemaAssembly(
437      formalName = "Inherited Control Implementation",
438      description = "Describes a control implementation inherited by a leveraging system.",
439      name = "inherited",
440      metaschema = OscalSspMetaschema.class
441  )
442  @AssemblyConstraints(
443      isUnique = @IsUnique(id = "unique-inherited-responsible-role", level = IConstraint.Level.ERROR, target = "responsible-role", keyFields = @KeyField(target = "@role-id"), remarks = "Since `responsible-role` associates multiple `party-uuid` entries with a single `role-id`, each role-id must be referenced only once.")
444  )
445  public static class Inherited {
446    @BoundFlag(
447        formalName = "Inherited Universally Unique Identifier",
448        description = "A [machine-oriented](https://pages.nist.gov/OSCAL/concepts/identifier-use/#machine-oriented), [globally unique](https://pages.nist.gov/OSCAL/concepts/identifier-use/#globally-unique) identifier with [cross-instance](https://pages.nist.gov/OSCAL/concepts/identifier-use/#cross-instance) scope that can be used to reference this inherited entry elsewhere in [this or other OSCAL instances](https://pages.nist.gov/OSCAL/concepts/identifier-use/#ssp-identifiers). The locally defined *UUID* of the `inherited control implementation` can be used to reference the data item locally or globally (e.g., in an imported OSCAL instance). This UUID should be assigned [per-subject](https://pages.nist.gov/OSCAL/concepts/identifier-use/#consistency), which means it should be consistently used to identify the same subject across revisions of the document.",
449        useName = "uuid",
450        required = true,
451        typeAdapter = UuidAdapter.class
452    )
453    private UUID _uuid;
454
455    @BoundFlag(
456        formalName = "Provided UUID",
457        description = "A [machine-oriented](https://pages.nist.gov/OSCAL/concepts/identifier-use/#machine-oriented) identifier reference to an inherited control implementation that a leveraging system is inheriting from a leveraged system.",
458        useName = "provided-uuid",
459        typeAdapter = UuidAdapter.class
460    )
461    private UUID _providedUuid;
462
463    /**
464     * "An implementation statement that describes the aspects of a control or control statement implementation that a leveraging system is inheriting from a leveraged system."
465     */
466    @BoundField(
467        formalName = "Inherited Control Implementation Description",
468        description = "An implementation statement that describes the aspects of a control or control statement implementation that a leveraging system is inheriting from a leveraged system.",
469        useName = "description",
470        minOccurs = 1
471    )
472    @BoundFieldValue(
473        typeAdapter = MarkupMultilineAdapter.class
474    )
475    private MarkupMultiline _description;
476
477    @BoundAssembly(
478        formalName = "Property",
479        description = "An attribute, characteristic, or quality of the containing object expressed as a namespace qualified name/value pair.",
480        useName = "prop",
481        maxOccurs = -1
482    )
483    @GroupAs(
484        name = "props",
485        inJson = JsonGroupAsBehavior.LIST
486    )
487    private List<Property> _props;
488
489    @BoundAssembly(
490        formalName = "Link",
491        description = "A reference to a local or remote resource, that has a specific relation to the containing object.",
492        useName = "link",
493        maxOccurs = -1
494    )
495    @GroupAs(
496        name = "links",
497        inJson = JsonGroupAsBehavior.LIST
498    )
499    private List<Link> _links;
500
501    @BoundAssembly(
502        formalName = "Responsible Role",
503        description = "A reference to a role with responsibility for performing a function relative to the containing object, optionally associated with a set of persons and/or organizations that perform that role.",
504        useName = "responsible-role",
505        maxOccurs = -1
506    )
507    @GroupAs(
508        name = "responsible-roles",
509        inJson = JsonGroupAsBehavior.LIST
510    )
511    private List<ResponsibleRole> _responsibleRoles;
512
513    public Inherited() {
514    }
515
516    public UUID getUuid() {
517      return _uuid;
518    }
519
520    public void setUuid(UUID value) {
521      _uuid = value;
522    }
523
524    public UUID getProvidedUuid() {
525      return _providedUuid;
526    }
527
528    public void setProvidedUuid(UUID value) {
529      _providedUuid = value;
530    }
531
532    public MarkupMultiline getDescription() {
533      return _description;
534    }
535
536    public void setDescription(MarkupMultiline value) {
537      _description = value;
538    }
539
540    public List<Property> getProps() {
541      return _props;
542    }
543
544    public void setProps(List<Property> value) {
545      _props = value;
546    }
547
548    /**
549     * Add a new {@link Property} item to the underlying collection.
550     * @param item the item to add
551     * @return {@code true}
552     */
553    public boolean addProp(Property item) {
554      Property value = ObjectUtils.requireNonNull(item,"item cannot be null");
555      if (_props == null) {
556        _props = new LinkedList<>();
557      }
558      return _props.add(value);
559    }
560
561    /**
562     * Remove the first matching {@link Property} item from the underlying collection.
563     * @param item the item to remove
564     * @return {@code true} if the item was removed or {@code false} otherwise
565     */
566    public boolean removeProp(Property item) {
567      Property value = ObjectUtils.requireNonNull(item,"item cannot be null");
568      return _props == null ? false : _props.remove(value);
569    }
570
571    public List<Link> getLinks() {
572      return _links;
573    }
574
575    public void setLinks(List<Link> value) {
576      _links = value;
577    }
578
579    /**
580     * Add a new {@link Link} item to the underlying collection.
581     * @param item the item to add
582     * @return {@code true}
583     */
584    public boolean addLink(Link item) {
585      Link value = ObjectUtils.requireNonNull(item,"item cannot be null");
586      if (_links == null) {
587        _links = new LinkedList<>();
588      }
589      return _links.add(value);
590    }
591
592    /**
593     * Remove the first matching {@link Link} item from the underlying collection.
594     * @param item the item to remove
595     * @return {@code true} if the item was removed or {@code false} otherwise
596     */
597    public boolean removeLink(Link item) {
598      Link value = ObjectUtils.requireNonNull(item,"item cannot be null");
599      return _links == null ? false : _links.remove(value);
600    }
601
602    public List<ResponsibleRole> getResponsibleRoles() {
603      return _responsibleRoles;
604    }
605
606    public void setResponsibleRoles(List<ResponsibleRole> value) {
607      _responsibleRoles = value;
608    }
609
610    /**
611     * Add a new {@link ResponsibleRole} item to the underlying collection.
612     * @param item the item to add
613     * @return {@code true}
614     */
615    public boolean addResponsibleRole(ResponsibleRole item) {
616      ResponsibleRole value = ObjectUtils.requireNonNull(item,"item cannot be null");
617      if (_responsibleRoles == null) {
618        _responsibleRoles = new LinkedList<>();
619      }
620      return _responsibleRoles.add(value);
621    }
622
623    /**
624     * Remove the first matching {@link ResponsibleRole} item from the underlying collection.
625     * @param item the item to remove
626     * @return {@code true} if the item was removed or {@code false} otherwise
627     */
628    public boolean removeResponsibleRole(ResponsibleRole item) {
629      ResponsibleRole value = ObjectUtils.requireNonNull(item,"item cannot be null");
630      return _responsibleRoles == null ? false : _responsibleRoles.remove(value);
631    }
632
633    @Override
634    public String toString() {
635      return new ReflectionToStringBuilder(this, MultilineRecursiveToStringStyle.MULTI_LINE_STYLE).toString();
636    }
637  }
638
639  /**
640   * Describes how this system satisfies a responsibility imposed by a leveraged system.
641   */
642  @MetaschemaAssembly(
643      formalName = "Satisfied Control Implementation Responsibility",
644      description = "Describes how this system satisfies a responsibility imposed by a leveraged system.",
645      name = "satisfied",
646      metaschema = OscalSspMetaschema.class
647  )
648  @AssemblyConstraints(
649      isUnique = @IsUnique(id = "unique-satisfied-responsible-role", level = IConstraint.Level.ERROR, target = "responsible-role", keyFields = @KeyField(target = "@role-id"), remarks = "Since `responsible-role` associates multiple `party-uuid` entries with a single `role-id`, each role-id must be referenced only once.")
650  )
651  public static class Satisfied {
652    @BoundFlag(
653        formalName = "Satisfied Universally Unique Identifier",
654        description = "A [machine-oriented](https://pages.nist.gov/OSCAL/concepts/identifier-use/#machine-oriented), [globally unique](https://pages.nist.gov/OSCAL/concepts/identifier-use/#globally-unique) identifier with [cross-instance](https://pages.nist.gov/OSCAL/concepts/identifier-use/#cross-instance) scope that can be used to reference this satisfied control implementation entry elsewhere in [this or other OSCAL instances](https://pages.nist.gov/OSCAL/concepts/identifier-use/#ssp-identifiers). The locally defined *UUID* of the `control implementation` can be used to reference the data item locally or globally (e.g., in an imported OSCAL instance). This UUID should be assigned [per-subject](https://pages.nist.gov/OSCAL/concepts/identifier-use/#consistency), which means it should be consistently used to identify the same subject across revisions of the document.",
655        useName = "uuid",
656        required = true,
657        typeAdapter = UuidAdapter.class
658    )
659    private UUID _uuid;
660
661    @BoundFlag(
662        formalName = "Responsibility UUID",
663        description = "A [machine-oriented](https://pages.nist.gov/OSCAL/concepts/identifier-use/#machine-oriented) identifier reference to a control implementation that satisfies a responsibility imposed by a leveraged system.",
664        useName = "responsibility-uuid",
665        typeAdapter = UuidAdapter.class
666    )
667    private UUID _responsibilityUuid;
668
669    /**
670     * "An implementation statement that describes the aspects of a control or control statement implementation that a leveraging system is implementing based on a requirement from a leveraged system."
671     */
672    @BoundField(
673        formalName = "Satisfied Control Implementation Responsibility Description",
674        description = "An implementation statement that describes the aspects of a control or control statement implementation that a leveraging system is implementing based on a requirement from a leveraged system.",
675        useName = "description",
676        minOccurs = 1
677    )
678    @BoundFieldValue(
679        typeAdapter = MarkupMultilineAdapter.class
680    )
681    private MarkupMultiline _description;
682
683    @BoundAssembly(
684        formalName = "Property",
685        description = "An attribute, characteristic, or quality of the containing object expressed as a namespace qualified name/value pair.",
686        useName = "prop",
687        maxOccurs = -1
688    )
689    @GroupAs(
690        name = "props",
691        inJson = JsonGroupAsBehavior.LIST
692    )
693    private List<Property> _props;
694
695    @BoundAssembly(
696        formalName = "Link",
697        description = "A reference to a local or remote resource, that has a specific relation to the containing object.",
698        useName = "link",
699        maxOccurs = -1
700    )
701    @GroupAs(
702        name = "links",
703        inJson = JsonGroupAsBehavior.LIST
704    )
705    private List<Link> _links;
706
707    @BoundAssembly(
708        formalName = "Responsible Role",
709        description = "A reference to a role with responsibility for performing a function relative to the containing object, optionally associated with a set of persons and/or organizations that perform that role.",
710        useName = "responsible-role",
711        maxOccurs = -1
712    )
713    @GroupAs(
714        name = "responsible-roles",
715        inJson = JsonGroupAsBehavior.LIST
716    )
717    private List<ResponsibleRole> _responsibleRoles;
718
719    @BoundField(
720        formalName = "Remarks",
721        description = "Additional commentary about the containing object.",
722        useName = "remarks"
723    )
724    @BoundFieldValue(
725        typeAdapter = MarkupMultilineAdapter.class
726    )
727    private MarkupMultiline _remarks;
728
729    public Satisfied() {
730    }
731
732    public UUID getUuid() {
733      return _uuid;
734    }
735
736    public void setUuid(UUID value) {
737      _uuid = value;
738    }
739
740    public UUID getResponsibilityUuid() {
741      return _responsibilityUuid;
742    }
743
744    public void setResponsibilityUuid(UUID value) {
745      _responsibilityUuid = value;
746    }
747
748    public MarkupMultiline getDescription() {
749      return _description;
750    }
751
752    public void setDescription(MarkupMultiline value) {
753      _description = value;
754    }
755
756    public List<Property> getProps() {
757      return _props;
758    }
759
760    public void setProps(List<Property> value) {
761      _props = value;
762    }
763
764    /**
765     * Add a new {@link Property} item to the underlying collection.
766     * @param item the item to add
767     * @return {@code true}
768     */
769    public boolean addProp(Property item) {
770      Property value = ObjectUtils.requireNonNull(item,"item cannot be null");
771      if (_props == null) {
772        _props = new LinkedList<>();
773      }
774      return _props.add(value);
775    }
776
777    /**
778     * Remove the first matching {@link Property} item from the underlying collection.
779     * @param item the item to remove
780     * @return {@code true} if the item was removed or {@code false} otherwise
781     */
782    public boolean removeProp(Property item) {
783      Property value = ObjectUtils.requireNonNull(item,"item cannot be null");
784      return _props == null ? false : _props.remove(value);
785    }
786
787    public List<Link> getLinks() {
788      return _links;
789    }
790
791    public void setLinks(List<Link> value) {
792      _links = value;
793    }
794
795    /**
796     * Add a new {@link Link} item to the underlying collection.
797     * @param item the item to add
798     * @return {@code true}
799     */
800    public boolean addLink(Link item) {
801      Link value = ObjectUtils.requireNonNull(item,"item cannot be null");
802      if (_links == null) {
803        _links = new LinkedList<>();
804      }
805      return _links.add(value);
806    }
807
808    /**
809     * Remove the first matching {@link Link} item from the underlying collection.
810     * @param item the item to remove
811     * @return {@code true} if the item was removed or {@code false} otherwise
812     */
813    public boolean removeLink(Link item) {
814      Link value = ObjectUtils.requireNonNull(item,"item cannot be null");
815      return _links == null ? false : _links.remove(value);
816    }
817
818    public List<ResponsibleRole> getResponsibleRoles() {
819      return _responsibleRoles;
820    }
821
822    public void setResponsibleRoles(List<ResponsibleRole> value) {
823      _responsibleRoles = value;
824    }
825
826    /**
827     * Add a new {@link ResponsibleRole} item to the underlying collection.
828     * @param item the item to add
829     * @return {@code true}
830     */
831    public boolean addResponsibleRole(ResponsibleRole item) {
832      ResponsibleRole value = ObjectUtils.requireNonNull(item,"item cannot be null");
833      if (_responsibleRoles == null) {
834        _responsibleRoles = new LinkedList<>();
835      }
836      return _responsibleRoles.add(value);
837    }
838
839    /**
840     * Remove the first matching {@link ResponsibleRole} item from the underlying collection.
841     * @param item the item to remove
842     * @return {@code true} if the item was removed or {@code false} otherwise
843     */
844    public boolean removeResponsibleRole(ResponsibleRole item) {
845      ResponsibleRole value = ObjectUtils.requireNonNull(item,"item cannot be null");
846      return _responsibleRoles == null ? false : _responsibleRoles.remove(value);
847    }
848
849    public MarkupMultiline getRemarks() {
850      return _remarks;
851    }
852
853    public void setRemarks(MarkupMultiline value) {
854      _remarks = value;
855    }
856
857    @Override
858    public String toString() {
859      return new ReflectionToStringBuilder(this, MultilineRecursiveToStringStyle.MULTI_LINE_STYLE).toString();
860    }
861  }
862
863  /**
864   * Identifies content intended for external consumption, such as with leveraged organizations.
865   */
866  @MetaschemaAssembly(
867      formalName = "Export",
868      description = "Identifies content intended for external consumption, such as with leveraged organizations.",
869      name = "export",
870      metaschema = OscalSspMetaschema.class
871  )
872  @ValueConstraints(
873      indexHasKey = @IndexHasKey(level = IConstraint.Level.ERROR, target = "responsibility", indexName = "by-component-export-provided-uuid", keyFields = @KeyField(target = "@provided-uuid"))
874  )
875  @AssemblyConstraints(
876      hasCardinality = @HasCardinality(level = IConstraint.Level.ERROR, target = "provided|responsibility", minOccurs = 1)
877  )
878  public static class Export {
879    /**
880     * "An implementation statement that describes the aspects of the control or control statement implementation that can be available to another system leveraging this system."
881     */
882    @BoundField(
883        formalName = "Control Implementation Export Description",
884        description = "An implementation statement that describes the aspects of the control or control statement implementation that can be available to another system leveraging this system.",
885        useName = "description"
886    )
887    @BoundFieldValue(
888        typeAdapter = MarkupMultilineAdapter.class
889    )
890    private MarkupMultiline _description;
891
892    @BoundAssembly(
893        formalName = "Property",
894        description = "An attribute, characteristic, or quality of the containing object expressed as a namespace qualified name/value pair.",
895        useName = "prop",
896        maxOccurs = -1
897    )
898    @GroupAs(
899        name = "props",
900        inJson = JsonGroupAsBehavior.LIST
901    )
902    private List<Property> _props;
903
904    @BoundAssembly(
905        formalName = "Link",
906        description = "A reference to a local or remote resource, that has a specific relation to the containing object.",
907        useName = "link",
908        maxOccurs = -1
909    )
910    @GroupAs(
911        name = "links",
912        inJson = JsonGroupAsBehavior.LIST
913    )
914    private List<Link> _links;
915
916    /**
917     * "Describes a capability which may be inherited by a leveraging system."
918     */
919    @BoundAssembly(
920        formalName = "Provided Control Implementation",
921        description = "Describes a capability which may be inherited by a leveraging system.",
922        useName = "provided",
923        maxOccurs = -1
924    )
925    @GroupAs(
926        name = "provided",
927        inJson = JsonGroupAsBehavior.LIST
928    )
929    private List<Provided> _provided;
930
931    /**
932     * "Describes a control implementation responsibility imposed on a leveraging system."
933     */
934    @BoundAssembly(
935        formalName = "Control Implementation Responsibility",
936        description = "Describes a control implementation responsibility imposed on a leveraging system.",
937        useName = "responsibility",
938        maxOccurs = -1
939    )
940    @GroupAs(
941        name = "responsibilities",
942        inJson = JsonGroupAsBehavior.LIST
943    )
944    private List<Responsibility> _responsibilities;
945
946    @BoundField(
947        formalName = "Remarks",
948        description = "Additional commentary about the containing object.",
949        useName = "remarks"
950    )
951    @BoundFieldValue(
952        typeAdapter = MarkupMultilineAdapter.class
953    )
954    private MarkupMultiline _remarks;
955
956    public Export() {
957    }
958
959    public MarkupMultiline getDescription() {
960      return _description;
961    }
962
963    public void setDescription(MarkupMultiline value) {
964      _description = value;
965    }
966
967    public List<Property> getProps() {
968      return _props;
969    }
970
971    public void setProps(List<Property> value) {
972      _props = value;
973    }
974
975    /**
976     * Add a new {@link Property} item to the underlying collection.
977     * @param item the item to add
978     * @return {@code true}
979     */
980    public boolean addProp(Property item) {
981      Property value = ObjectUtils.requireNonNull(item,"item cannot be null");
982      if (_props == null) {
983        _props = new LinkedList<>();
984      }
985      return _props.add(value);
986    }
987
988    /**
989     * Remove the first matching {@link Property} item from the underlying collection.
990     * @param item the item to remove
991     * @return {@code true} if the item was removed or {@code false} otherwise
992     */
993    public boolean removeProp(Property item) {
994      Property value = ObjectUtils.requireNonNull(item,"item cannot be null");
995      return _props == null ? false : _props.remove(value);
996    }
997
998    public List<Link> getLinks() {
999      return _links;
1000    }
1001
1002    public void setLinks(List<Link> value) {
1003      _links = value;
1004    }
1005
1006    /**
1007     * Add a new {@link Link} item to the underlying collection.
1008     * @param item the item to add
1009     * @return {@code true}
1010     */
1011    public boolean addLink(Link item) {
1012      Link value = ObjectUtils.requireNonNull(item,"item cannot be null");
1013      if (_links == null) {
1014        _links = new LinkedList<>();
1015      }
1016      return _links.add(value);
1017    }
1018
1019    /**
1020     * Remove the first matching {@link Link} item from the underlying collection.
1021     * @param item the item to remove
1022     * @return {@code true} if the item was removed or {@code false} otherwise
1023     */
1024    public boolean removeLink(Link item) {
1025      Link value = ObjectUtils.requireNonNull(item,"item cannot be null");
1026      return _links == null ? false : _links.remove(value);
1027    }
1028
1029    public List<Provided> getProvided() {
1030      return _provided;
1031    }
1032
1033    public void setProvided(List<Provided> value) {
1034      _provided = value;
1035    }
1036
1037    /**
1038     * Add a new {@link Provided} item to the underlying collection.
1039     * @param item the item to add
1040     * @return {@code true}
1041     */
1042    public boolean addProvided(Provided item) {
1043      Provided value = ObjectUtils.requireNonNull(item,"item cannot be null");
1044      if (_provided == null) {
1045        _provided = new LinkedList<>();
1046      }
1047      return _provided.add(value);
1048    }
1049
1050    /**
1051     * Remove the first matching {@link Provided} item from the underlying collection.
1052     * @param item the item to remove
1053     * @return {@code true} if the item was removed or {@code false} otherwise
1054     */
1055    public boolean removeProvided(Provided item) {
1056      Provided value = ObjectUtils.requireNonNull(item,"item cannot be null");
1057      return _provided == null ? false : _provided.remove(value);
1058    }
1059
1060    public List<Responsibility> getResponsibilities() {
1061      return _responsibilities;
1062    }
1063
1064    public void setResponsibilities(List<Responsibility> value) {
1065      _responsibilities = value;
1066    }
1067
1068    /**
1069     * Add a new {@link Responsibility} item to the underlying collection.
1070     * @param item the item to add
1071     * @return {@code true}
1072     */
1073    public boolean addResponsibility(Responsibility item) {
1074      Responsibility value = ObjectUtils.requireNonNull(item,"item cannot be null");
1075      if (_responsibilities == null) {
1076        _responsibilities = new LinkedList<>();
1077      }
1078      return _responsibilities.add(value);
1079    }
1080
1081    /**
1082     * Remove the first matching {@link Responsibility} item from the underlying collection.
1083     * @param item the item to remove
1084     * @return {@code true} if the item was removed or {@code false} otherwise
1085     */
1086    public boolean removeResponsibility(Responsibility item) {
1087      Responsibility value = ObjectUtils.requireNonNull(item,"item cannot be null");
1088      return _responsibilities == null ? false : _responsibilities.remove(value);
1089    }
1090
1091    public MarkupMultiline getRemarks() {
1092      return _remarks;
1093    }
1094
1095    public void setRemarks(MarkupMultiline value) {
1096      _remarks = value;
1097    }
1098
1099    @Override
1100    public String toString() {
1101      return new ReflectionToStringBuilder(this, MultilineRecursiveToStringStyle.MULTI_LINE_STYLE).toString();
1102    }
1103
1104    /**
1105     * Describes a capability which may be inherited by a leveraging system.
1106     */
1107    @MetaschemaAssembly(
1108        formalName = "Provided Control Implementation",
1109        description = "Describes a capability which may be inherited by a leveraging system.",
1110        name = "provided",
1111        metaschema = OscalSspMetaschema.class
1112    )
1113    @AssemblyConstraints(
1114        isUnique = @IsUnique(id = "unique-provided-responsible-role", level = IConstraint.Level.ERROR, target = "responsible-role", keyFields = @KeyField(target = "@role-id"), remarks = "Since `responsible-role` associates multiple `party-uuid` entries with a single `role-id`, each role-id must be referenced only once.")
1115    )
1116    public static class Provided {
1117      @BoundFlag(
1118          formalName = "Provided Universally Unique Identifier",
1119          description = "A [machine-oriented](https://pages.nist.gov/OSCAL/concepts/identifier-use/#machine-oriented), [globally unique](https://pages.nist.gov/OSCAL/concepts/identifier-use/#globally-unique) identifier with [cross-instance](https://pages.nist.gov/OSCAL/concepts/identifier-use/#cross-instance) scope that can be used to reference this provided entry elsewhere in [this or other OSCAL instances](https://pages.nist.gov/OSCAL/concepts/identifier-use/#ssp-identifiers). The locally defined *UUID* of the `provided` entry can be used to reference the data item locally or globally (e.g., in an imported OSCAL instance). This UUID should be assigned [per-subject](https://pages.nist.gov/OSCAL/concepts/identifier-use/#consistency), which means it should be consistently used to identify the same subject across revisions of the document.",
1120          useName = "uuid",
1121          required = true,
1122          typeAdapter = UuidAdapter.class
1123      )
1124      private UUID _uuid;
1125
1126      /**
1127       * "An implementation statement that describes the aspects of the control or control statement implementation that can be provided to another system leveraging this system."
1128       */
1129      @BoundField(
1130          formalName = "Provided Control Implementation Description",
1131          description = "An implementation statement that describes the aspects of the control or control statement implementation that can be provided to another system leveraging this system.",
1132          useName = "description",
1133          minOccurs = 1
1134      )
1135      @BoundFieldValue(
1136          typeAdapter = MarkupMultilineAdapter.class
1137      )
1138      private MarkupMultiline _description;
1139
1140      @BoundAssembly(
1141          formalName = "Property",
1142          description = "An attribute, characteristic, or quality of the containing object expressed as a namespace qualified name/value pair.",
1143          useName = "prop",
1144          maxOccurs = -1
1145      )
1146      @GroupAs(
1147          name = "props",
1148          inJson = JsonGroupAsBehavior.LIST
1149      )
1150      private List<Property> _props;
1151
1152      @BoundAssembly(
1153          formalName = "Link",
1154          description = "A reference to a local or remote resource, that has a specific relation to the containing object.",
1155          useName = "link",
1156          maxOccurs = -1
1157      )
1158      @GroupAs(
1159          name = "links",
1160          inJson = JsonGroupAsBehavior.LIST
1161      )
1162      private List<Link> _links;
1163
1164      @BoundAssembly(
1165          formalName = "Responsible Role",
1166          description = "A reference to a role with responsibility for performing a function relative to the containing object, optionally associated with a set of persons and/or organizations that perform that role.",
1167          useName = "responsible-role",
1168          maxOccurs = -1
1169      )
1170      @GroupAs(
1171          name = "responsible-roles",
1172          inJson = JsonGroupAsBehavior.LIST
1173      )
1174      private List<ResponsibleRole> _responsibleRoles;
1175
1176      @BoundField(
1177          formalName = "Remarks",
1178          description = "Additional commentary about the containing object.",
1179          useName = "remarks"
1180      )
1181      @BoundFieldValue(
1182          typeAdapter = MarkupMultilineAdapter.class
1183      )
1184      private MarkupMultiline _remarks;
1185
1186      public Provided() {
1187      }
1188
1189      public UUID getUuid() {
1190        return _uuid;
1191      }
1192
1193      public void setUuid(UUID value) {
1194        _uuid = value;
1195      }
1196
1197      public MarkupMultiline getDescription() {
1198        return _description;
1199      }
1200
1201      public void setDescription(MarkupMultiline value) {
1202        _description = value;
1203      }
1204
1205      public List<Property> getProps() {
1206        return _props;
1207      }
1208
1209      public void setProps(List<Property> value) {
1210        _props = value;
1211      }
1212
1213      /**
1214       * Add a new {@link Property} item to the underlying collection.
1215       * @param item the item to add
1216       * @return {@code true}
1217       */
1218      public boolean addProp(Property item) {
1219        Property value = ObjectUtils.requireNonNull(item,"item cannot be null");
1220        if (_props == null) {
1221          _props = new LinkedList<>();
1222        }
1223        return _props.add(value);
1224      }
1225
1226      /**
1227       * Remove the first matching {@link Property} item from the underlying collection.
1228       * @param item the item to remove
1229       * @return {@code true} if the item was removed or {@code false} otherwise
1230       */
1231      public boolean removeProp(Property item) {
1232        Property value = ObjectUtils.requireNonNull(item,"item cannot be null");
1233        return _props == null ? false : _props.remove(value);
1234      }
1235
1236      public List<Link> getLinks() {
1237        return _links;
1238      }
1239
1240      public void setLinks(List<Link> value) {
1241        _links = value;
1242      }
1243
1244      /**
1245       * Add a new {@link Link} item to the underlying collection.
1246       * @param item the item to add
1247       * @return {@code true}
1248       */
1249      public boolean addLink(Link item) {
1250        Link value = ObjectUtils.requireNonNull(item,"item cannot be null");
1251        if (_links == null) {
1252          _links = new LinkedList<>();
1253        }
1254        return _links.add(value);
1255      }
1256
1257      /**
1258       * Remove the first matching {@link Link} item from the underlying collection.
1259       * @param item the item to remove
1260       * @return {@code true} if the item was removed or {@code false} otherwise
1261       */
1262      public boolean removeLink(Link item) {
1263        Link value = ObjectUtils.requireNonNull(item,"item cannot be null");
1264        return _links == null ? false : _links.remove(value);
1265      }
1266
1267      public List<ResponsibleRole> getResponsibleRoles() {
1268        return _responsibleRoles;
1269      }
1270
1271      public void setResponsibleRoles(List<ResponsibleRole> value) {
1272        _responsibleRoles = value;
1273      }
1274
1275      /**
1276       * Add a new {@link ResponsibleRole} item to the underlying collection.
1277       * @param item the item to add
1278       * @return {@code true}
1279       */
1280      public boolean addResponsibleRole(ResponsibleRole item) {
1281        ResponsibleRole value = ObjectUtils.requireNonNull(item,"item cannot be null");
1282        if (_responsibleRoles == null) {
1283          _responsibleRoles = new LinkedList<>();
1284        }
1285        return _responsibleRoles.add(value);
1286      }
1287
1288      /**
1289       * Remove the first matching {@link ResponsibleRole} item from the underlying collection.
1290       * @param item the item to remove
1291       * @return {@code true} if the item was removed or {@code false} otherwise
1292       */
1293      public boolean removeResponsibleRole(ResponsibleRole item) {
1294        ResponsibleRole value = ObjectUtils.requireNonNull(item,"item cannot be null");
1295        return _responsibleRoles == null ? false : _responsibleRoles.remove(value);
1296      }
1297
1298      public MarkupMultiline getRemarks() {
1299        return _remarks;
1300      }
1301
1302      public void setRemarks(MarkupMultiline value) {
1303        _remarks = value;
1304      }
1305
1306      @Override
1307      public String toString() {
1308        return new ReflectionToStringBuilder(this, MultilineRecursiveToStringStyle.MULTI_LINE_STYLE).toString();
1309      }
1310    }
1311
1312    /**
1313     * Describes a control implementation responsibility imposed on a leveraging system.
1314     */
1315    @MetaschemaAssembly(
1316        formalName = "Control Implementation Responsibility",
1317        description = "Describes a control implementation responsibility imposed on a leveraging system.",
1318        name = "responsibility",
1319        metaschema = OscalSspMetaschema.class
1320    )
1321    @AssemblyConstraints(
1322        isUnique = @IsUnique(id = "unique-responsibility-responsible-role", level = IConstraint.Level.ERROR, target = "responsible-role", keyFields = @KeyField(target = "@role-id"), remarks = "Since `responsible-role` associates multiple `party-uuid` entries with a single `role-id`, each role-id must be referenced only once.")
1323    )
1324    public static class Responsibility {
1325      @BoundFlag(
1326          formalName = "Responsibility Universally Unique Identifier",
1327          description = "A [machine-oriented](https://pages.nist.gov/OSCAL/concepts/identifier-use/#machine-oriented), [globally unique](https://pages.nist.gov/OSCAL/concepts/identifier-use/#globally-unique) identifier with [cross-instance](https://pages.nist.gov/OSCAL/concepts/identifier-use/#cross-instance) scope that can be used to reference this responsibility elsewhere in [this or other OSCAL instances](https://pages.nist.gov/OSCAL/concepts/identifier-use/#ssp-identifiers). The locally defined *UUID* of the `responsibility` can be used to reference the data item locally or globally (e.g., in an imported OSCAL instance). This UUID should be assigned [per-subject](https://pages.nist.gov/OSCAL/concepts/identifier-use/#consistency), which means it should be consistently used to identify the same subject across revisions of the document.",
1328          useName = "uuid",
1329          required = true,
1330          typeAdapter = UuidAdapter.class
1331      )
1332      private UUID _uuid;
1333
1334      @BoundFlag(
1335          formalName = "Provided UUID",
1336          description = "A [machine-oriented](https://pages.nist.gov/OSCAL/concepts/identifier-use/#machine-oriented) identifier reference to an inherited control implementation that a leveraging system is inheriting from a leveraged system.",
1337          useName = "provided-uuid",
1338          typeAdapter = UuidAdapter.class
1339      )
1340      private UUID _providedUuid;
1341
1342      /**
1343       * "An implementation statement that describes the aspects of the control or control statement implementation that a leveraging system must implement to satisfy the control provided by a leveraged system."
1344       */
1345      @BoundField(
1346          formalName = "Control Implementation Responsibility Description",
1347          description = "An implementation statement that describes the aspects of the control or control statement implementation that a leveraging system must implement to satisfy the control provided by a leveraged system.",
1348          useName = "description",
1349          minOccurs = 1
1350      )
1351      @BoundFieldValue(
1352          typeAdapter = MarkupMultilineAdapter.class
1353      )
1354      private MarkupMultiline _description;
1355
1356      @BoundAssembly(
1357          formalName = "Property",
1358          description = "An attribute, characteristic, or quality of the containing object expressed as a namespace qualified name/value pair.",
1359          useName = "prop",
1360          maxOccurs = -1
1361      )
1362      @GroupAs(
1363          name = "props",
1364          inJson = JsonGroupAsBehavior.LIST
1365      )
1366      private List<Property> _props;
1367
1368      @BoundAssembly(
1369          formalName = "Link",
1370          description = "A reference to a local or remote resource, that has a specific relation to the containing object.",
1371          useName = "link",
1372          maxOccurs = -1
1373      )
1374      @GroupAs(
1375          name = "links",
1376          inJson = JsonGroupAsBehavior.LIST
1377      )
1378      private List<Link> _links;
1379
1380      @BoundAssembly(
1381          formalName = "Responsible Role",
1382          description = "A reference to a role with responsibility for performing a function relative to the containing object, optionally associated with a set of persons and/or organizations that perform that role.",
1383          useName = "responsible-role",
1384          maxOccurs = -1,
1385          remarks = "A role defined at the by-component level takes precedence over the same role defined on the parent implemented-requirement or on the referenced component."
1386      )
1387      @GroupAs(
1388          name = "responsible-roles",
1389          inJson = JsonGroupAsBehavior.LIST
1390      )
1391      private List<ResponsibleRole> _responsibleRoles;
1392
1393      @BoundField(
1394          formalName = "Remarks",
1395          description = "Additional commentary about the containing object.",
1396          useName = "remarks"
1397      )
1398      @BoundFieldValue(
1399          typeAdapter = MarkupMultilineAdapter.class
1400      )
1401      private MarkupMultiline _remarks;
1402
1403      public Responsibility() {
1404      }
1405
1406      public UUID getUuid() {
1407        return _uuid;
1408      }
1409
1410      public void setUuid(UUID value) {
1411        _uuid = value;
1412      }
1413
1414      public UUID getProvidedUuid() {
1415        return _providedUuid;
1416      }
1417
1418      public void setProvidedUuid(UUID value) {
1419        _providedUuid = value;
1420      }
1421
1422      public MarkupMultiline getDescription() {
1423        return _description;
1424      }
1425
1426      public void setDescription(MarkupMultiline value) {
1427        _description = value;
1428      }
1429
1430      public List<Property> getProps() {
1431        return _props;
1432      }
1433
1434      public void setProps(List<Property> value) {
1435        _props = value;
1436      }
1437
1438      /**
1439       * Add a new {@link Property} item to the underlying collection.
1440       * @param item the item to add
1441       * @return {@code true}
1442       */
1443      public boolean addProp(Property item) {
1444        Property value = ObjectUtils.requireNonNull(item,"item cannot be null");
1445        if (_props == null) {
1446          _props = new LinkedList<>();
1447        }
1448        return _props.add(value);
1449      }
1450
1451      /**
1452       * Remove the first matching {@link Property} item from the underlying collection.
1453       * @param item the item to remove
1454       * @return {@code true} if the item was removed or {@code false} otherwise
1455       */
1456      public boolean removeProp(Property item) {
1457        Property value = ObjectUtils.requireNonNull(item,"item cannot be null");
1458        return _props == null ? false : _props.remove(value);
1459      }
1460
1461      public List<Link> getLinks() {
1462        return _links;
1463      }
1464
1465      public void setLinks(List<Link> value) {
1466        _links = value;
1467      }
1468
1469      /**
1470       * Add a new {@link Link} item to the underlying collection.
1471       * @param item the item to add
1472       * @return {@code true}
1473       */
1474      public boolean addLink(Link item) {
1475        Link value = ObjectUtils.requireNonNull(item,"item cannot be null");
1476        if (_links == null) {
1477          _links = new LinkedList<>();
1478        }
1479        return _links.add(value);
1480      }
1481
1482      /**
1483       * Remove the first matching {@link Link} item from the underlying collection.
1484       * @param item the item to remove
1485       * @return {@code true} if the item was removed or {@code false} otherwise
1486       */
1487      public boolean removeLink(Link item) {
1488        Link value = ObjectUtils.requireNonNull(item,"item cannot be null");
1489        return _links == null ? false : _links.remove(value);
1490      }
1491
1492      public List<ResponsibleRole> getResponsibleRoles() {
1493        return _responsibleRoles;
1494      }
1495
1496      public void setResponsibleRoles(List<ResponsibleRole> value) {
1497        _responsibleRoles = value;
1498      }
1499
1500      /**
1501       * Add a new {@link ResponsibleRole} item to the underlying collection.
1502       * @param item the item to add
1503       * @return {@code true}
1504       */
1505      public boolean addResponsibleRole(ResponsibleRole item) {
1506        ResponsibleRole value = ObjectUtils.requireNonNull(item,"item cannot be null");
1507        if (_responsibleRoles == null) {
1508          _responsibleRoles = new LinkedList<>();
1509        }
1510        return _responsibleRoles.add(value);
1511      }
1512
1513      /**
1514       * Remove the first matching {@link ResponsibleRole} item from the underlying collection.
1515       * @param item the item to remove
1516       * @return {@code true} if the item was removed or {@code false} otherwise
1517       */
1518      public boolean removeResponsibleRole(ResponsibleRole item) {
1519        ResponsibleRole value = ObjectUtils.requireNonNull(item,"item cannot be null");
1520        return _responsibleRoles == null ? false : _responsibleRoles.remove(value);
1521      }
1522
1523      public MarkupMultiline getRemarks() {
1524        return _remarks;
1525      }
1526
1527      public void setRemarks(MarkupMultiline value) {
1528        _remarks = value;
1529      }
1530
1531      @Override
1532      public String toString() {
1533        return new ReflectionToStringBuilder(this, MultilineRecursiveToStringStyle.MULTI_LINE_STYLE).toString();
1534      }
1535    }
1536  }
1537}