text: ﻿/**
   * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
   * SPDX-License-Identifier: Apache-2.0.
   */
  
  #pragma once
  #include <aws/imagebuilder/Imagebuilder_EXPORTS.h>
  #include <aws/core/utils/memory/stl/AWSString.h>
  #include <aws/imagebuilder/model/Platform.h>
  #include <aws/core/utils/memory/stl/AWSVector.h>
  #include <aws/imagebuilder/model/ComponentType.h>
  #include <utility>
  
  namespace Aws
  {
  namespace Utils
  {
  namespace Json
  {
    class JsonValue;
    class JsonView;
  } // namespace Json
  } // namespace Utils
  namespace imagebuilder
  {
  namespace Model
  {
  
    /**
     * <p>The defining characteristics of a specific version of an Amazon Web Services
     * TOE component.</p><p><h3>See Also:</h3>   <a
     * href="http://docs.aws.amazon.com/goto/WebAPI/imagebuilder-2019-12-02/ComponentVersion">AWS
     * API Reference</a></p>
     */
    class AWS_IMAGEBUILDER_API ComponentVersion
    {
    public:
      ComponentVersion();
      ComponentVersion(Aws::Utils::Json::JsonView jsonValue);
      ComponentVersion& operator=(Aws::Utils::Json::JsonView jsonValue);
      Aws::Utils::Json::JsonValue Jsonize() const;
  
  
      /**
       * <p>The Amazon Resource Name (ARN) of the component.</p>  <p>Semantic
       * versioning is included in each object's Amazon Resource Name (ARN), at the level
       * that applies to that object as follows:</p> <ol> <li> <p>Versionless ARNs and
       * Name ARNs do not include specific values in any of the nodes. The nodes are
       * either left off entirely, or they are specified as wildcards, for example:
       * x.x.x.</p> </li> <li> <p>Version ARNs have only the first three nodes:
       * &lt;major&gt;.&lt;minor&gt;.&lt;patch&gt;</p> </li> <li> <p>Build version ARNs
       * have all four nodes, and point to a specific build for a specific version of an
       * object.</p> </li> </ol> 
       */
      inline const Aws::String& GetArn() const{ return m_arn; }
  
      /**
       * <p>The Amazon Resource Name (ARN) of the component.</p>  <p>Semantic
       * versioning is included in each object's Amazon Resource Name (ARN), at the level
       * that applies to that object as follows:</p> <ol> <li> <p>Versionless ARNs and
       * Name ARNs do not include specific values in any of the nodes. The nodes are
       * either left off entirely, or they are specified as wildcards, for example:
       * x.x.x.</p> </li> <li> <p>Version ARNs have only the first three nodes:
       * &lt;major&gt;.&lt;minor&gt;.&lt;patch&gt;</p> </li> <li> <p>Build version ARNs
       * have all four nodes, and point to a specific build for a specific version of an
       * object.</p> </li> </ol> 
       */
      inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
  
      /**
       * <p>The Amazon Resource Name (ARN) of the component.</p>  <p>Semantic
       * versioning is included in each object's Amazon Resource Name (ARN), at the level
       * that applies to that object as follows:</p> <ol> <li> <p>Versionless ARNs and
       * Name ARNs do not include specific values in any of the nodes. The nodes are
       * either left off entirely, or they are specified as wildcards, for example:
       * x.x.x.</p> </li> <li> <p>Version ARNs have only the first three nodes:
       * &lt;major&gt;.&lt;minor&gt;.&lt;patch&gt;</p> </li> <li> <p>Build version ARNs
       * have all four nodes, and point to a specific build for a specific version of an
       * object.</p> </li> </ol> 
       */
      inline void SetArn(const Aws::String& value) { m_arnHasBeenSet = true; m_arn = value; }
  
      /**
       * <p>The Amazon Resource Name (ARN) of the component.</p>  <p>Semantic
       * versioning is included in each object's Amazon Resource Name (ARN), at the level
       * that applies to that object as follows:</p> <ol> <li> <p>Versionless ARNs and
       * Name ARNs do not include specific values in any of the nodes. The nodes are
       * either left off entirely, or they are specified as wildcards, for example:
       * x.x.x.</p> </li> <li> <p>Version ARNs have only the first three nodes:
       * &lt;major&gt;.&lt;minor&gt;.&lt;patch&gt;</p> </li> <li> <p>Build version ARNs
       * have all four nodes, and point to a specific build for a specific version of an
       * object.</p> </li> </ol> 
       */
      inline void SetArn(Aws::String&& value) { m_arnHasBeenSet = true; m_arn = std::move(value); }
  
      /**
       * <p>The Amazon Resource Name (ARN) of the component.</p>  <p>Semantic
       * versioning is included in each object's Amazon Resource Name (ARN), at the level
       * that applies to that object as follows:</p> <ol> <li> <p>Versionless ARNs and
       * Name ARNs do not include specific values in any of the nodes. The nodes are
       * either left off entirely, or they are specified as wildcards, for example:
       * x.x.x.</p> </li> <li> <p>Version ARNs have only the first three nodes:
       * &lt;major&gt;.&lt;minor&gt;.&lt;patch&gt;</p> </li> <li> <p>Build version ARNs
       * have all four nodes, and point to a specific build for a specific version of an
       * object.</p> </li> </ol> 
       */
      inline void SetArn(const char* value) { m_arnHasBeenSet = true; m_arn.assign(value); }
  
      /**
       * <p>The Amazon Resource Name (ARN) of the component.</p>  <p>Semantic
       * versioning is included in each object's Amazon Resource Name (ARN), at the level
       * that applies to that object as follows:</p> <ol> <li> <p>Versionless ARNs and
       * Name ARNs do not include specific values in any of the nodes. The nodes are
       * either left off entirely, or they are specified as wildcards, for example:
       * x.x.x.</p> </li> <li> <p>Version ARNs have only the first three nodes:
       * &lt;major&gt;.&lt;minor&gt;.&lt;patch&gt;</p> </li> <li> <p>Build version ARNs
       * have all four nodes, and point to a specific build for a specific version of an
       * object.</p> </li> </ol> 
       */
      inline ComponentVersion& WithArn(const Aws::String& value) { SetArn(value); return *this;}
  
      /**
       * <p>The Amazon Resource Name (ARN) of the component.</p>  <p>Semantic
       * versioning is included in each object's Amazon Resource Name (ARN), at the level
       * that applies to that object as follows:</p> <ol> <li> <p>Versionless ARNs and
       * Name ARNs do not include specific values in any of the nodes. The nodes are
       * either left off entirely, or they are specified as wildcards, for example:
       * x.x.x.</p> </li> <li> <p>Version ARNs have only the first three nodes:
       * &lt;major&gt;.&lt;minor&gt;.&lt;patch&gt;</p> </li> <li> <p>Build version ARNs
       * have all four nodes, and point to a specific build for a specific version of an
       * object.</p> </li> </ol> 
       */
      inline ComponentVersion& WithArn(Aws::String&& value) { SetArn(std::move(value)); return *this;}
  
      /**
       * <p>The Amazon Resource Name (ARN) of the component.</p>  <p>Semantic
       * versioning is included in each object's Amazon Resource Name (ARN), at the level
       * that applies to that object as follows:</p> <ol> <li> <p>Versionless ARNs and
       * Name ARNs do not include specific values in any of the nodes. The nodes are
       * either left off entirely, or they are specified as wildcards, for example:
       * x.x.x.</p> </li> <li> <p>Version ARNs have only the first three nodes:
       * &lt;major&gt;.&lt;minor&gt;.&lt;patch&gt;</p> </li> <li> <p>Build version ARNs
       * have all four nodes, and point to a specific build for a specific version of an
       * object.</p> </li> </ol> 
       */
      inline ComponentVersion& WithArn(const char* value) { SetArn(value); return *this;}
  
  
      /**
       * <p>The name of the component.</p>
       */
      inline const Aws::String& GetName() const{ return m_name; }
  
      /**
       * <p>The name of the component.</p>
       */
      inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
  
      /**
       * <p>The name of the component.</p>
       */
      inline void SetName(const Aws::String& value) { m_nameHasBeenSet = true; m_name = value; }
  
      /**
       * <p>The name of the component.</p>
       */
      inline void SetName(Aws::String&& value) { m_nameHasBeenSet = true; m_name = std::move(value); }
  
      /**
       * <p>The name of the component.</p>
       */
      inline void SetName(const char* value) { m_nameHasBeenSet = true; m_name.assign(value); }
  
      /**
       * <p>The name of the component.</p>
       */
      inline ComponentVersion& WithName(const Aws::String& value) { SetName(value); return *this;}
  
      /**
       * <p>The name of the component.</p>
       */
      inline ComponentVersion& WithName(Aws::String&& value) { SetName(std::move(value)); return *this;}
  
      /**
       * <p>The name of the component.</p>
       */
      inline ComponentVersion& WithName(const char* value) { SetName(value); return *this;}
  
  
      /**
       * <p>The semantic version of the component.</p>  <p>The semantic version has
       * four nodes: &lt;major&gt;.&lt;minor&gt;.&lt;patch&gt;/&lt;build&gt;. You can
       * assign values for the first three, and can filter on all of them.</p> <p>
       * <b>Assignment:</b> For the first three nodes you can assign any positive integer
       * value, including zero, with an upper limit of 2^30-1, or 1073741823 for each
       * node. Image Builder automatically assigns the build number to the fourth
       * node.</p> <p> <b>Patterns:</b> You can use any numeric pattern that adheres to
       * the assignment requirements for the nodes that you can assign. For example, you
       * might choose a software version pattern, such as 1.0.0, or a date, such as
       * 2021.01.01.</p> <p> <b>Filtering:</b> With semantic versioning, you have the
       * flexibility to use wildcards (x) to specify the most recent versions or nodes
       * when selecting the source image or components for your recipe. When you use a
       * wildcard in any node, all nodes to the right of the first wildcard must also be
       * wildcards.</p> 
       */
      inline const Aws::String& GetVersion() const{ return m_version; }
  
      /**
       * <p>The semantic version of the component.</p>  <p>The semantic version has
       * four nodes: &lt;major&gt;.&lt;minor&gt;.&lt;patch&gt;/&lt;build&gt;. You can
       * assign values for the first three, and can filter on all of them.</p> <p>
       * <b>Assignment:</b> For the first three nodes you can assign any positive integer
       * value, including zero, with an upper limit of 2^30-1, or 1073741823 for each
       * node. Image Builder automatically assigns the build number to the fourth
       * node.</p> <p> <b>Patterns:</b> You can use any numeric pattern that adheres to
       * the assignment requirements for the nodes that you can assign. For example, you
       * might choose a software version pattern, such as 1.0.0, or a date, such as
       * 2021.01.01.</p> <p> <b>Filtering:</b> With semantic versioning, you have the
       * flexibility to use wildcards (x) to specify the most recent versions or nodes
       * when selecting the source image or components for your recipe. When you use a
       * wildcard in any node, all nodes to the right of the first wildcard must also be
       * wildcards.</p> 
       */
      inline bool VersionHasBeenSet() const { return m_versionHasBeenSet; }
  
      /**
       * <p>The semantic version of the component.</p>  <p>The semantic version has
       * four nodes: &lt;major&gt;.&lt;minor&gt;.&lt;patch&gt;/&lt;build&gt;. You can
       * assign values for the first three, and can filter on all of them.</p> <p>
       * <b>Assignment:</b> For the first three nodes you can assign any positive integer
       * value, including zero, with an upper limit of 2^30-1, or 1073741823 for each
       * node. Image Builder automatically assigns the build number to the fourth
       * node.</p> <p> <b>Patterns:</b> You can use any numeric pattern that adheres to
       * the assignment requirements for the nodes that you can assign. For example, you
       * might choose a software version pattern, such as 1.0.0, or a date, such as
       * 2021.01.01.</p> <p> <b>Filtering:</b> With semantic versioning, you have the
       * flexibility to use wildcards (x) to specify the most recent versions or nodes
       * when selecting the source image or components for your recipe. When you use a
       * wildcard in any node, all nodes to the right of the first wildcard must also be
       * wildcards.</p> 
       */
      inline void SetVersion(const Aws::String& value) { m_versionHasBeenSet = true; m_version = value; }
  
      /**
       * <p>The semantic version of the component.</p>  <p>The semantic version has
       * four nodes: &lt;major&gt;.&lt;minor&gt;.&lt;patch&gt;/&lt;build&gt;. You can
       * assign values for the first three, and can filter on all of them.</p> <p>
       * <b>Assignment:</b> For the first three nodes you can assign any positive integer
       * value, including zero, with an upper limit of 2^30-1, or 1073741823 for each
       * node. Image Builder automatically assigns the build number to the fourth
       * node.</p> <p> <b>Patterns:</b> You can use any numeric pattern that adheres to
       * the assignment requirements for the nodes that you can assign. For example, you
       * might choose a software version pattern, such as 1.0.0, or a date, such as
       * 2021.01.01.</p> <p> <b>Filtering:</b> With semantic versioning, you have the
       * flexibility to use wildcards (x) to specify the most recent versions or nodes
       * when selecting the source image or components for your recipe. When you use a
       * wildcard in any node, all nodes to the right of the first wildcard must also be
       * wildcards.</p> 
       */
      inline void SetVersion(Aws::String&& value) { m_versionHasBeenSet = true; m_version = std::move(value); }
  
      /**
       * <p>The semantic version of the component.</p>  <p>The semantic version has
       * four nodes: &lt;major&gt;.&lt;minor&gt;.&lt;patch&gt;/&lt;build&gt;. You can
       * assign values for the first three, and can filter on all of them.</p> <p>
       * <b>Assignment:</b> For the first three nodes you can assign any positive integer
       * value, including zero, with an upper limit of 2^30-1, or 1073741823 for each
       * node. Image Builder automatically assigns the build number to the fourth
       * node.</p> <p> <b>Patterns:</b> You can use any numeric pattern that adheres to
       * the assignment requirements for the nodes that you can assign. For example, you
       * might choose a software version pattern, such as 1.0.0, or a date, such as
       * 2021.01.01.</p> <p> <b>Filtering:</b> With semantic versioning, you have the
       * flexibility to use wildcards (x) to specify the most recent versions or nodes
       * when selecting the source image or components for your recipe. When you use a
       * wildcard in any node, all nodes to the right of the first wildcard must also be
       * wildcards.</p> 
       */
      inline void SetVersion(const char* value) { m_versionHasBeenSet = true; m_version.assign(value); }
  
      /**
       * <p>The semantic version of the component.</p>  <p>The semantic version has
       * four nodes: &lt;major&gt;.&lt;minor&gt;.&lt;patch&gt;/&lt;build&gt;. You can
       * assign values for the first three, and can filter on all of them.</p> <p>
       * <b>Assignment:</b> For the first three nodes you can assign any positive integer
       * value, including zero, with an upper limit of 2^30-1, or 1073741823 for each
       * node. Image Builder automatically assigns the build number to the fourth
       * node.</p> <p> <b>Patterns:</b> You can use any numeric pattern that adheres to
       * the assignment requirements for the nodes that you can assign. For example, you
       * might choose a software version pattern, such as 1.0.0, or a date, such as
       * 2021.01.01.</p> <p> <b>Filtering:</b> With semantic versioning, you have the
       * flexibility to use wildcards (x) to specify the most recent versions or nodes
       * when selecting the source image or components for your recipe. When you use a
       * wildcard in any node, all nodes to the right of the first wildcard must also be
       * wildcards.</p> 
       */
      inline ComponentVersion& WithVersion(const Aws::String& value) { SetVersion(value); return *this;}
  
      /**
       * <p>The semantic version of the component.</p>  <p>The semantic version has
       * four nodes: &lt;major&gt;.&lt;minor&gt;.&lt;patch&gt;/&lt;build&gt;. You can
       * assign values for the first three, and can filter on all of them.</p> <p>
       * <b>Assignment:</b> For the first three nodes you can assign any positive integer
       * value, including zero, with an upper limit of 2^30-1, or 1073741823 for each
       * node. Image Builder automatically assigns the build number to the fourth
       * node.</p> <p> <b>Patterns:</b> You can use any numeric pattern that adheres to
       * the assignment requirements for the nodes that you can assign. For example, you
       * might choose a software version pattern, such as 1.0.0, or a date, such as
       * 2021.01.01.</p> <p> <b>Filtering:</b> With semantic versioning, you have the
       * flexibility to use wildcards (x) to specify the most recent versions or nodes
       * when selecting the source image or components for your recipe. When you use a
       * wildcard in any node, all nodes to the right of the first wildcard must also be
       * wildcards.</p> 
       */
      inline ComponentVersion& WithVersion(Aws::String&& value) { SetVersion(std::move(value)); return *this;}
  
      /**
       * <p>The semantic version of the component.</p>  <p>The semantic version has
       * four nodes: &lt;major&gt;.&lt;minor&gt;.&lt;patch&gt;/&lt;build&gt;. You can
       * assign values for the first three, and can filter on all of them.</p> <p>
       * <b>Assignment:</b> For the first three nodes you can assign any positive integer
       * value, including zero, with an upper limit of 2^30-1, or 1073741823 for each
       * node. Image Builder automatically assigns the build number to the fourth
       * node.</p> <p> <b>Patterns:</b> You can use any numeric pattern that adheres to
       * the assignment requirements for the nodes that you can assign. For example, you
       * might choose a software version pattern, such as 1.0.0, or a date, such as
       * 2021.01.01.</p> <p> <b>Filtering:</b> With semantic versioning, you have the
       * flexibility to use wildcards (x) to specify the most recent versions or nodes
       * when selecting the source image or components for your recipe. When you use a
       * wildcard in any node, all nodes to the right of the first wildcard must also be
       * wildcards.</p> 
       */
      inline ComponentVersion& WithVersion(const char* value) { SetVersion(value); return *this;}
  
  
      /**
       * <p>The description of the component.</p>
       */
      inline const Aws::String& GetDescription() const{ return m_description; }
  
      /**
       * <p>The description of the component.</p>
       */
      inline bool DescriptionHasBeenSet() const { return m_descriptionHasBeenSet; }
  
      /**
       * <p>The description of the component.</p>
       */
      inline void SetDescription(const Aws::String& value) { m_descriptionHasBeenSet = true; m_description = value; }
  
      /**
       * <p>The description of the component.</p>
       */
      inline void SetDescription(Aws::String&& value) { m_descriptionHasBeenSet = true; m_description = std::move(value); }
  
      /**
       * <p>The description of the component.</p>
       */
      inline void SetDescription(const char* value) { m_descriptionHasBeenSet = true; m_description.assign(value); }
  
      /**
       * <p>The description of the component.</p>
       */
      inline ComponentVersion& WithDescription(const Aws::String& value) { SetDescription(value); return *this;}
  
      /**
       * <p>The description of the component.</p>
       */
      inline ComponentVersion& WithDescription(Aws::String&& value) { SetDescription(std::move(value)); return *this;}
  
      /**
       * <p>The description of the component.</p>
       */
      inline ComponentVersion& WithDescription(const char* value) { SetDescription(value); return *this;}
  
  
      /**
       * <p>The platform of the component.</p>
       */
      inline const Platform& GetPlatform() const{ return m_platform; }
  
      /**
       * <p>The platform of the component.</p>
       */
      inline bool PlatformHasBeenSet() const { return m_platformHasBeenSet; }
  
      /**
       * <p>The platform of the component.</p>
       */
      inline void SetPlatform(const Platform& value) { m_platformHasBeenSet = true; m_platform = value; }
  
      /**
       * <p>The platform of the component.</p>
       */
      inline void SetPlatform(Platform&& value) { m_platformHasBeenSet = true; m_platform = std::move(value); }
  
      /**
       * <p>The platform of the component.</p>
       */
      inline ComponentVersion& WithPlatform(const Platform& value) { SetPlatform(value); return *this;}
  
      /**
       * <p>The platform of the component.</p>
       */
      inline ComponentVersion& WithPlatform(Platform&& value) { SetPlatform(std::move(value)); return *this;}
  
  
      /**
       * <p>he operating system (OS) version supported by the component. If the OS
       * information is available, a prefix match is performed against the parent image
       * OS version during image recipe creation.</p>
       */
      inline const Aws::Vector<Aws::String>& GetSupportedOsVersions() const{ return m_supportedOsVersions; }
  
      /**
       * <p>he operating system (OS) version supported by the component. If the OS
       * information is available, a prefix match is performed against the parent image
       * OS version during image recipe creation.</p>
       */
      inline bool SupportedOsVersionsHasBeenSet() const { return m_supportedOsVersionsHasBeenSet; }
  
      /**
       * <p>he operating system (OS) version supported by the component. If the OS
       * information is available, a prefix match is performed against the parent image
       * OS version during image recipe creation.</p>
       */
      inline void SetSupportedOsVersions(const Aws::Vector<Aws::String>& value) { m_supportedOsVersionsHasBeenSet = true; m_supportedOsVersions = value; }
  
      /**
       * <p>he operating system (OS) version supported by the component. If the OS
       * information is available, a prefix match is performed against the parent image
       * OS version during image recipe creation.</p>
       */
      inline void SetSupportedOsVersions(Aws::Vector<Aws::String>&& value) { m_supportedOsVersionsHasBeenSet = true; m_supportedOsVersions = std::move(value); }
  
      /**
       * <p>he operating system (OS) version supported by the component. If the OS
       * information is available, a prefix match is performed against the parent image
       * OS version during image recipe creation.</p>
       */
      inline ComponentVersion& WithSupportedOsVersions(const Aws::Vector<Aws::String>& value) { SetSupportedOsVersions(value); return *this;}
  
      /**
       * <p>he operating system (OS) version supported by the component. If the OS
       * information is available, a prefix match is performed against the parent image
       * OS version during image recipe creation.</p>
       */
      inline ComponentVersion& WithSupportedOsVersions(Aws::Vector<Aws::String>&& value) { SetSupportedOsVersions(std::move(value)); return *this;}
  
      /**
       * <p>he operating system (OS) version supported by the component. If the OS
       * information is available, a prefix match is performed against the parent image
       * OS version during image recipe creation.</p>
       */
      inline ComponentVersion& AddSupportedOsVersions(const Aws::String& value) { m_supportedOsVersionsHasBeenSet = true; m_supportedOsVersions.push_back(value); return *this; }
  
      /**
       * <p>he operating system (OS) version supported by the component. If the OS
       * information is available, a prefix match is performed against the parent image
       * OS version during image recipe creation.</p>
       */
      inline ComponentVersion& AddSupportedOsVersions(Aws::String&& value) { m_supportedOsVersionsHasBeenSet = true; m_supportedOsVersions.push_back(std::move(value)); return *this; }
  
      /**
       * <p>he operating system (OS) version supported by the component. If the OS
       * information is available, a prefix match is performed against the parent image
       * OS version during image recipe creation.</p>
       */
      inline ComponentVersion& AddSupportedOsVersions(const char* value) { m_supportedOsVersionsHasBeenSet = true; m_supportedOsVersions.push_back(value); return *this; }
  
  
      /**
       * <p>The type of the component denotes whether the component is used to build the
       * image or only to test it.</p>
       */
      inline const ComponentType& GetType() const{ return m_type; }
  
      /**
       * <p>The type of the component denotes whether the component is used to build the
       * image or only to test it.</p>
       */
      inline bool TypeHasBeenSet() const { return m_typeHasBeenSet; }
  
      /**
       * <p>The type of the component denotes whether the component is used to build the
       * image or only to test it.</p>
       */
      inline void SetType(const ComponentType& value) { m_typeHasBeenSet = true; m_type = value; }
  
      /**
       * <p>The type of the component denotes whether the component is used to build the
       * image or only to test it.</p>
       */
      inline void SetType(ComponentType&& value) { m_typeHasBeenSet = true; m_type = std::move(value); }
  
      /**
       * <p>The type of the component denotes whether the component is used to build the
       * image or only to test it.</p>
       */
      inline ComponentVersion& WithType(const ComponentType& value) { SetType(value); return *this;}
  
      /**
       * <p>The type of the component denotes whether the component is used to build the
       * image or only to test it.</p>
       */
      inline ComponentVersion& WithType(ComponentType&& value) { SetType(std::move(value)); return *this;}
  
  
      /**
       * <p>The owner of the component.</p>
       */
      inline const Aws::String& GetOwner() const{ return m_owner; }
  
      /**
       * <p>The owner of the component.</p>
       */
      inline bool OwnerHasBeenSet() const { return m_ownerHasBeenSet; }
  
      /**
       * <p>The owner of the component.</p>
       */
      inline void SetOwner(const Aws::String& value) { m_ownerHasBeenSet = true; m_owner = value; }
  
      /**
       * <p>The owner of the component.</p>
       */
      inline void SetOwner(Aws::String&& value) { m_ownerHasBeenSet = true; m_owner = std::move(value); }
  
      /**
       * <p>The owner of the component.</p>
       */
      inline void SetOwner(const char* value) { m_ownerHasBeenSet = true; m_owner.assign(value); }
  
      /**
       * <p>The owner of the component.</p>
       */
      inline ComponentVersion& WithOwner(const Aws::String& value) { SetOwner(value); return *this;}
  
      /**
       * <p>The owner of the component.</p>
       */
      inline ComponentVersion& WithOwner(Aws::String&& value) { SetOwner(std::move(value)); return *this;}
  
      /**
       * <p>The owner of the component.</p>
       */
      inline ComponentVersion& WithOwner(const char* value) { SetOwner(value); return *this;}
  
  
      /**
       * <p>The date that the component was created.</p>
       */
      inline const Aws::String& GetDateCreated() const{ return m_dateCreated; }
  
      /**
       * <p>The date that the component was created.</p>
       */
      inline bool DateCreatedHasBeenSet() const { return m_dateCreatedHasBeenSet; }
  
      /**
       * <p>The date that the component was created.</p>
       */
      inline void SetDateCreated(const Aws::String& value) { m_dateCreatedHasBeenSet = true; m_dateCreated = value; }
  
      /**
       * <p>The date that the component was created.</p>
       */
      inline void SetDateCreated(Aws::String&& value) { m_dateCreatedHasBeenSet = true; m_dateCreated = std::move(value); }
  
      /**
       * <p>The date that the component was created.</p>
       */
      inline void SetDateCreated(const char* value) { m_dateCreatedHasBeenSet = true; m_dateCreated.assign(value); }
  
      /**
       * <p>The date that the component was created.</p>
       */
      inline ComponentVersion& WithDateCreated(const Aws::String& value) { SetDateCreated(value); return *this;}
  
      /**
       * <p>The date that the component was created.</p>
       */
      inline ComponentVersion& WithDateCreated(Aws::String&& value) { SetDateCreated(std::move(value)); return *this;}
  
      /**
       * <p>The date that the component was created.</p>
       */
      inline ComponentVersion& WithDateCreated(const char* value) { SetDateCreated(value); return *this;}
  
    private:
  
      Aws::String m_arn;
      bool m_arnHasBeenSet;
  
      Aws::String m_name;
      bool m_nameHasBeenSet;
  
      Aws::String m_version;
      bool m_versionHasBeenSet;
  
      Aws::String m_description;
      bool m_descriptionHasBeenSet;
  
      Platform m_platform;
      bool m_platformHasBeenSet;
  
      Aws::Vector<Aws::String> m_supportedOsVersions;
      bool m_supportedOsVersionsHasBeenSet;
  
      ComponentType m_type;
      bool m_typeHasBeenSet;
  
      Aws::String m_owner;
      bool m_ownerHasBeenSet;
  
      Aws::String m_dateCreated;
      bool m_dateCreatedHasBeenSet;
    };
  
  } // namespace Model
  } // namespace imagebuilder
  } // namespace Aws
  