Run.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/devicefarm/DeviceFarm_EXPORTS.h>
#include <aws/devicefarm/model/BillingMethod.h>
#include <aws/devicefarm/model/Counters.h>
#include <aws/devicefarm/model/CustomerArtifactPaths.h>
#include <aws/devicefarm/model/DeviceMinutes.h>
#include <aws/devicefarm/model/DevicePlatform.h>
#include <aws/devicefarm/model/DeviceProxy.h>
#include <aws/devicefarm/model/DeviceSelectionResult.h>
#include <aws/devicefarm/model/EnvironmentVariable.h>
#include <aws/devicefarm/model/ExecutionResult.h>
#include <aws/devicefarm/model/ExecutionResultCode.h>
#include <aws/devicefarm/model/ExecutionStatus.h>
#include <aws/devicefarm/model/InsightsType.h>
#include <aws/devicefarm/model/Location.h>
#include <aws/devicefarm/model/NetworkProfile.h>
#include <aws/devicefarm/model/Radios.h>
#include <aws/devicefarm/model/RunInsights.h>
#include <aws/devicefarm/model/TestType.h>
#include <aws/devicefarm/model/VpcConfig.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace DeviceFarm {
namespace Model {
 
class Run {
 public:
  AWS_DEVICEFARM_API Run() = default;
  AWS_DEVICEFARM_API Run(Aws::Utils::Json::JsonView jsonValue);
  AWS_DEVICEFARM_API Run& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_DEVICEFARM_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetArn() const { return m_arn; }
  inline bool ArnHasBeenSet() const { return m_arnHasBeenSet; }
  template <typename ArnT = Aws::String>
  void SetArn(ArnT&& value) {
    m_arnHasBeenSet = true;
    m_arn = std::forward<ArnT>(value);
  }
  template <typename ArnT = Aws::String>
  Run& WithArn(ArnT&& value) {
    SetArn(std::forward<ArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetName() const { return m_name; }
  inline bool NameHasBeenSet() const { return m_nameHasBeenSet; }
  template <typename NameT = Aws::String>
  void SetName(NameT&& value) {
    m_nameHasBeenSet = true;
    m_name = std::forward<NameT>(value);
  }
  template <typename NameT = Aws::String>
  Run& WithName(NameT&& value) {
    SetName(std::forward<NameT>(value));
    return *this;
  }
 
 
  inline TestType GetType() const { return m_type; }
  inline bool TypeHasBeenSet() const { return m_typeHasBeenSet; }
  inline void SetType(TestType value) {
    m_typeHasBeenSet = true;
    m_type = value;
  }
  inline Run& WithType(TestType value) {
    SetType(value);
    return *this;
  }
 
 
  inline DevicePlatform GetPlatform() const { return m_platform; }
  inline bool PlatformHasBeenSet() const { return m_platformHasBeenSet; }
  inline void SetPlatform(DevicePlatform value) {
    m_platformHasBeenSet = true;
    m_platform = value;
  }
  inline Run& WithPlatform(DevicePlatform value) {
    SetPlatform(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetCreated() const { return m_created; }
  inline bool CreatedHasBeenSet() const { return m_createdHasBeenSet; }
  template <typename CreatedT = Aws::Utils::DateTime>
  void SetCreated(CreatedT&& value) {
    m_createdHasBeenSet = true;
    m_created = std::forward<CreatedT>(value);
  }
  template <typename CreatedT = Aws::Utils::DateTime>
  Run& WithCreated(CreatedT&& value) {
    SetCreated(std::forward<CreatedT>(value));
    return *this;
  }
 
 
  inline ExecutionStatus GetStatus() const { return m_status; }
  inline bool StatusHasBeenSet() const { return m_statusHasBeenSet; }
  inline void SetStatus(ExecutionStatus value) {
    m_statusHasBeenSet = true;
    m_status = value;
  }
  inline Run& WithStatus(ExecutionStatus value) {
    SetStatus(value);
    return *this;
  }
 
 
  inline ExecutionResult GetResult() const { return m_result; }
  inline bool ResultHasBeenSet() const { return m_resultHasBeenSet; }
  inline void SetResult(ExecutionResult value) {
    m_resultHasBeenSet = true;
    m_result = value;
  }
  inline Run& WithResult(ExecutionResult value) {
    SetResult(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetStarted() const { return m_started; }
  inline bool StartedHasBeenSet() const { return m_startedHasBeenSet; }
  template <typename StartedT = Aws::Utils::DateTime>
  void SetStarted(StartedT&& value) {
    m_startedHasBeenSet = true;
    m_started = std::forward<StartedT>(value);
  }
  template <typename StartedT = Aws::Utils::DateTime>
  Run& WithStarted(StartedT&& value) {
    SetStarted(std::forward<StartedT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetStopped() const { return m_stopped; }
  inline bool StoppedHasBeenSet() const { return m_stoppedHasBeenSet; }
  template <typename StoppedT = Aws::Utils::DateTime>
  void SetStopped(StoppedT&& value) {
    m_stoppedHasBeenSet = true;
    m_stopped = std::forward<StoppedT>(value);
  }
  template <typename StoppedT = Aws::Utils::DateTime>
  Run& WithStopped(StoppedT&& value) {
    SetStopped(std::forward<StoppedT>(value));
    return *this;
  }
 
 
  inline const Counters& GetCounters() const { return m_counters; }
  inline bool CountersHasBeenSet() const { return m_countersHasBeenSet; }
  template <typename CountersT = Counters>
  void SetCounters(CountersT&& value) {
    m_countersHasBeenSet = true;
    m_counters = std::forward<CountersT>(value);
  }
  template <typename CountersT = Counters>
  Run& WithCounters(CountersT&& value) {
    SetCounters(std::forward<CountersT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetMessage() const { return m_message; }
  inline bool MessageHasBeenSet() const { return m_messageHasBeenSet; }
  template <typename MessageT = Aws::String>
  void SetMessage(MessageT&& value) {
    m_messageHasBeenSet = true;
    m_message = std::forward<MessageT>(value);
  }
  template <typename MessageT = Aws::String>
  Run& WithMessage(MessageT&& value) {
    SetMessage(std::forward<MessageT>(value));
    return *this;
  }
 
 
  inline int GetTotalJobs() const { return m_totalJobs; }
  inline bool TotalJobsHasBeenSet() const { return m_totalJobsHasBeenSet; }
  inline void SetTotalJobs(int value) {
    m_totalJobsHasBeenSet = true;
    m_totalJobs = value;
  }
  inline Run& WithTotalJobs(int value) {
    SetTotalJobs(value);
    return *this;
  }
 
 
  inline int GetCompletedJobs() const { return m_completedJobs; }
  inline bool CompletedJobsHasBeenSet() const { return m_completedJobsHasBeenSet; }
  inline void SetCompletedJobs(int value) {
    m_completedJobsHasBeenSet = true;
    m_completedJobs = value;
  }
  inline Run& WithCompletedJobs(int value) {
    SetCompletedJobs(value);
    return *this;
  }
 
 
  inline BillingMethod GetBillingMethod() const { return m_billingMethod; }
  inline bool BillingMethodHasBeenSet() const { return m_billingMethodHasBeenSet; }
  inline void SetBillingMethod(BillingMethod value) {
    m_billingMethodHasBeenSet = true;
    m_billingMethod = value;
  }
  inline Run& WithBillingMethod(BillingMethod value) {
    SetBillingMethod(value);
    return *this;
  }
 
 
  inline const DeviceMinutes& GetDeviceMinutes() const { return m_deviceMinutes; }
  inline bool DeviceMinutesHasBeenSet() const { return m_deviceMinutesHasBeenSet; }
  template <typename DeviceMinutesT = DeviceMinutes>
  void SetDeviceMinutes(DeviceMinutesT&& value) {
    m_deviceMinutesHasBeenSet = true;
    m_deviceMinutes = std::forward<DeviceMinutesT>(value);
  }
  template <typename DeviceMinutesT = DeviceMinutes>
  Run& WithDeviceMinutes(DeviceMinutesT&& value) {
    SetDeviceMinutes(std::forward<DeviceMinutesT>(value));
    return *this;
  }
 
 
  inline const NetworkProfile& GetNetworkProfile() const { return m_networkProfile; }
  inline bool NetworkProfileHasBeenSet() const { return m_networkProfileHasBeenSet; }
  template <typename NetworkProfileT = NetworkProfile>
  void SetNetworkProfile(NetworkProfileT&& value) {
    m_networkProfileHasBeenSet = true;
    m_networkProfile = std::forward<NetworkProfileT>(value);
  }
  template <typename NetworkProfileT = NetworkProfile>
  Run& WithNetworkProfile(NetworkProfileT&& value) {
    SetNetworkProfile(std::forward<NetworkProfileT>(value));
    return *this;
  }
 
 
  inline const DeviceProxy& GetDeviceProxy() const { return m_deviceProxy; }
  inline bool DeviceProxyHasBeenSet() const { return m_deviceProxyHasBeenSet; }
  template <typename DeviceProxyT = DeviceProxy>
  void SetDeviceProxy(DeviceProxyT&& value) {
    m_deviceProxyHasBeenSet = true;
    m_deviceProxy = std::forward<DeviceProxyT>(value);
  }
  template <typename DeviceProxyT = DeviceProxy>
  Run& WithDeviceProxy(DeviceProxyT&& value) {
    SetDeviceProxy(std::forward<DeviceProxyT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetParsingResultUrl() const { return m_parsingResultUrl; }
  inline bool ParsingResultUrlHasBeenSet() const { return m_parsingResultUrlHasBeenSet; }
  template <typename ParsingResultUrlT = Aws::String>
  void SetParsingResultUrl(ParsingResultUrlT&& value) {
    m_parsingResultUrlHasBeenSet = true;
    m_parsingResultUrl = std::forward<ParsingResultUrlT>(value);
  }
  template <typename ParsingResultUrlT = Aws::String>
  Run& WithParsingResultUrl(ParsingResultUrlT&& value) {
    SetParsingResultUrl(std::forward<ParsingResultUrlT>(value));
    return *this;
  }
 
 
  inline ExecutionResultCode GetResultCode() const { return m_resultCode; }
  inline bool ResultCodeHasBeenSet() const { return m_resultCodeHasBeenSet; }
  inline void SetResultCode(ExecutionResultCode value) {
    m_resultCodeHasBeenSet = true;
    m_resultCode = value;
  }
  inline Run& WithResultCode(ExecutionResultCode value) {
    SetResultCode(value);
    return *this;
  }
 
 
  inline int GetSeed() const { return m_seed; }
  inline bool SeedHasBeenSet() const { return m_seedHasBeenSet; }
  inline void SetSeed(int value) {
    m_seedHasBeenSet = true;
    m_seed = value;
  }
  inline Run& WithSeed(int value) {
    SetSeed(value);
    return *this;
  }
 
 
  inline const Aws::String& GetAppUpload() const { return m_appUpload; }
  inline bool AppUploadHasBeenSet() const { return m_appUploadHasBeenSet; }
  template <typename AppUploadT = Aws::String>
  void SetAppUpload(AppUploadT&& value) {
    m_appUploadHasBeenSet = true;
    m_appUpload = std::forward<AppUploadT>(value);
  }
  template <typename AppUploadT = Aws::String>
  Run& WithAppUpload(AppUploadT&& value) {
    SetAppUpload(std::forward<AppUploadT>(value));
    return *this;
  }
 
 
  inline int GetEventCount() const { return m_eventCount; }
  inline bool EventCountHasBeenSet() const { return m_eventCountHasBeenSet; }
  inline void SetEventCount(int value) {
    m_eventCountHasBeenSet = true;
    m_eventCount = value;
  }
  inline Run& WithEventCount(int value) {
    SetEventCount(value);
    return *this;
  }
 
 
  inline int GetJobTimeoutMinutes() const { return m_jobTimeoutMinutes; }
  inline bool JobTimeoutMinutesHasBeenSet() const { return m_jobTimeoutMinutesHasBeenSet; }
  inline void SetJobTimeoutMinutes(int value) {
    m_jobTimeoutMinutesHasBeenSet = true;
    m_jobTimeoutMinutes = value;
  }
  inline Run& WithJobTimeoutMinutes(int value) {
    SetJobTimeoutMinutes(value);
    return *this;
  }
 
 
  inline const Aws::String& GetDevicePoolArn() const { return m_devicePoolArn; }
  inline bool DevicePoolArnHasBeenSet() const { return m_devicePoolArnHasBeenSet; }
  template <typename DevicePoolArnT = Aws::String>
  void SetDevicePoolArn(DevicePoolArnT&& value) {
    m_devicePoolArnHasBeenSet = true;
    m_devicePoolArn = std::forward<DevicePoolArnT>(value);
  }
  template <typename DevicePoolArnT = Aws::String>
  Run& WithDevicePoolArn(DevicePoolArnT&& value) {
    SetDevicePoolArn(std::forward<DevicePoolArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetLocale() const { return m_locale; }
  inline bool LocaleHasBeenSet() const { return m_localeHasBeenSet; }
  template <typename LocaleT = Aws::String>
  void SetLocale(LocaleT&& value) {
    m_localeHasBeenSet = true;
    m_locale = std::forward<LocaleT>(value);
  }
  template <typename LocaleT = Aws::String>
  Run& WithLocale(LocaleT&& value) {
    SetLocale(std::forward<LocaleT>(value));
    return *this;
  }
 
 
  inline const Radios& GetRadios() const { return m_radios; }
  inline bool RadiosHasBeenSet() const { return m_radiosHasBeenSet; }
  template <typename RadiosT = Radios>
  void SetRadios(RadiosT&& value) {
    m_radiosHasBeenSet = true;
    m_radios = std::forward<RadiosT>(value);
  }
  template <typename RadiosT = Radios>
  Run& WithRadios(RadiosT&& value) {
    SetRadios(std::forward<RadiosT>(value));
    return *this;
  }
 
 
  inline const Location& GetLocation() const { return m_location; }
  inline bool LocationHasBeenSet() const { return m_locationHasBeenSet; }
  template <typename LocationT = Location>
  void SetLocation(LocationT&& value) {
    m_locationHasBeenSet = true;
    m_location = std::forward<LocationT>(value);
  }
  template <typename LocationT = Location>
  Run& WithLocation(LocationT&& value) {
    SetLocation(std::forward<LocationT>(value));
    return *this;
  }
 
 
  inline const CustomerArtifactPaths& GetCustomerArtifactPaths() const { return m_customerArtifactPaths; }
  inline bool CustomerArtifactPathsHasBeenSet() const { return m_customerArtifactPathsHasBeenSet; }
  template <typename CustomerArtifactPathsT = CustomerArtifactPaths>
  void SetCustomerArtifactPaths(CustomerArtifactPathsT&& value) {
    m_customerArtifactPathsHasBeenSet = true;
    m_customerArtifactPaths = std::forward<CustomerArtifactPathsT>(value);
  }
  template <typename CustomerArtifactPathsT = CustomerArtifactPaths>
  Run& WithCustomerArtifactPaths(CustomerArtifactPathsT&& value) {
    SetCustomerArtifactPaths(std::forward<CustomerArtifactPathsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetWebUrl() const { return m_webUrl; }
  inline bool WebUrlHasBeenSet() const { return m_webUrlHasBeenSet; }
  template <typename WebUrlT = Aws::String>
  void SetWebUrl(WebUrlT&& value) {
    m_webUrlHasBeenSet = true;
    m_webUrl = std::forward<WebUrlT>(value);
  }
  template <typename WebUrlT = Aws::String>
  Run& WithWebUrl(WebUrlT&& value) {
    SetWebUrl(std::forward<WebUrlT>(value));
    return *this;
  }
 
 
  inline bool GetSkipAppResign() const { return m_skipAppResign; }
  inline bool SkipAppResignHasBeenSet() const { return m_skipAppResignHasBeenSet; }
  inline void SetSkipAppResign(bool value) {
    m_skipAppResignHasBeenSet = true;
    m_skipAppResign = value;
  }
  inline Run& WithSkipAppResign(bool value) {
    SetSkipAppResign(value);
    return *this;
  }
 
 
  inline const Aws::String& GetTestSpecArn() const { return m_testSpecArn; }
  inline bool TestSpecArnHasBeenSet() const { return m_testSpecArnHasBeenSet; }
  template <typename TestSpecArnT = Aws::String>
  void SetTestSpecArn(TestSpecArnT&& value) {
    m_testSpecArnHasBeenSet = true;
    m_testSpecArn = std::forward<TestSpecArnT>(value);
  }
  template <typename TestSpecArnT = Aws::String>
  Run& WithTestSpecArn(TestSpecArnT&& value) {
    SetTestSpecArn(std::forward<TestSpecArnT>(value));
    return *this;
  }
 
 
  inline const DeviceSelectionResult& GetDeviceSelectionResult() const { return m_deviceSelectionResult; }
  inline bool DeviceSelectionResultHasBeenSet() const { return m_deviceSelectionResultHasBeenSet; }
  template <typename DeviceSelectionResultT = DeviceSelectionResult>
  void SetDeviceSelectionResult(DeviceSelectionResultT&& value) {
    m_deviceSelectionResultHasBeenSet = true;
    m_deviceSelectionResult = std::forward<DeviceSelectionResultT>(value);
  }
  template <typename DeviceSelectionResultT = DeviceSelectionResult>
  Run& WithDeviceSelectionResult(DeviceSelectionResultT&& value) {
    SetDeviceSelectionResult(std::forward<DeviceSelectionResultT>(value));
    return *this;
  }
 
 
  inline const VpcConfig& GetVpcConfig() const { return m_vpcConfig; }
  inline bool VpcConfigHasBeenSet() const { return m_vpcConfigHasBeenSet; }
  template <typename VpcConfigT = VpcConfig>
  void SetVpcConfig(VpcConfigT&& value) {
    m_vpcConfigHasBeenSet = true;
    m_vpcConfig = std::forward<VpcConfigT>(value);
  }
  template <typename VpcConfigT = VpcConfig>
  Run& WithVpcConfig(VpcConfigT&& value) {
    SetVpcConfig(std::forward<VpcConfigT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetExecutionRoleArn() const { return m_executionRoleArn; }
  inline bool ExecutionRoleArnHasBeenSet() const { return m_executionRoleArnHasBeenSet; }
  template <typename ExecutionRoleArnT = Aws::String>
  void SetExecutionRoleArn(ExecutionRoleArnT&& value) {
    m_executionRoleArnHasBeenSet = true;
    m_executionRoleArn = std::forward<ExecutionRoleArnT>(value);
  }
  template <typename ExecutionRoleArnT = Aws::String>
  Run& WithExecutionRoleArn(ExecutionRoleArnT&& value) {
    SetExecutionRoleArn(std::forward<ExecutionRoleArnT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<EnvironmentVariable>& GetEnvironmentVariables() const { return m_environmentVariables; }
  inline bool EnvironmentVariablesHasBeenSet() const { return m_environmentVariablesHasBeenSet; }
  template <typename EnvironmentVariablesT = Aws::Vector<EnvironmentVariable>>
  void SetEnvironmentVariables(EnvironmentVariablesT&& value) {
    m_environmentVariablesHasBeenSet = true;
    m_environmentVariables = std::forward<EnvironmentVariablesT>(value);
  }
  template <typename EnvironmentVariablesT = Aws::Vector<EnvironmentVariable>>
  Run& WithEnvironmentVariables(EnvironmentVariablesT&& value) {
    SetEnvironmentVariables(std::forward<EnvironmentVariablesT>(value));
    return *this;
  }
  template <typename EnvironmentVariablesT = EnvironmentVariable>
  Run& AddEnvironmentVariables(EnvironmentVariablesT&& value) {
    m_environmentVariablesHasBeenSet = true;
    m_environmentVariables.emplace_back(std::forward<EnvironmentVariablesT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<InsightsType>& GetInsightsTypes() const { return m_insightsTypes; }
  inline bool InsightsTypesHasBeenSet() const { return m_insightsTypesHasBeenSet; }
  template <typename InsightsTypesT = Aws::Vector<InsightsType>>
  void SetInsightsTypes(InsightsTypesT&& value) {
    m_insightsTypesHasBeenSet = true;
    m_insightsTypes = std::forward<InsightsTypesT>(value);
  }
  template <typename InsightsTypesT = Aws::Vector<InsightsType>>
  Run& WithInsightsTypes(InsightsTypesT&& value) {
    SetInsightsTypes(std::forward<InsightsTypesT>(value));
    return *this;
  }
  inline Run& AddInsightsTypes(InsightsType value) {
    m_insightsTypesHasBeenSet = true;
    m_insightsTypes.push_back(value);
    return *this;
  }
 
 
  inline const RunInsights& GetInsights() const { return m_insights; }
  inline bool InsightsHasBeenSet() const { return m_insightsHasBeenSet; }
  template <typename InsightsT = RunInsights>
  void SetInsights(InsightsT&& value) {
    m_insightsHasBeenSet = true;
    m_insights = std::forward<InsightsT>(value);
  }
  template <typename InsightsT = RunInsights>
  Run& WithInsights(InsightsT&& value) {
    SetInsights(std::forward<InsightsT>(value));
    return *this;
  }
 private:
  Aws::String m_arn;
 
  Aws::String m_name;
 
  TestType m_type{TestType::NOT_SET};
 
  DevicePlatform m_platform{DevicePlatform::NOT_SET};
 
  Aws::Utils::DateTime m_created{};
 
  ExecutionStatus m_status{ExecutionStatus::NOT_SET};
 
  ExecutionResult m_result{ExecutionResult::NOT_SET};
 
  Aws::Utils::DateTime m_started{};
 
  Aws::Utils::DateTime m_stopped{};
 
  Counters m_counters;
 
  Aws::String m_message;
 
  int m_totalJobs{0};
 
  int m_completedJobs{0};
 
  BillingMethod m_billingMethod{BillingMethod::NOT_SET};
 
  DeviceMinutes m_deviceMinutes;
 
  NetworkProfile m_networkProfile;
 
  DeviceProxy m_deviceProxy;
 
  Aws::String m_parsingResultUrl;
 
  ExecutionResultCode m_resultCode{ExecutionResultCode::NOT_SET};
 
  int m_seed{0};
 
  Aws::String m_appUpload;
 
  int m_eventCount{0};
 
  int m_jobTimeoutMinutes{0};
 
  Aws::String m_devicePoolArn;
 
  Aws::String m_locale;
 
  Radios m_radios;
 
  Location m_location;
 
  CustomerArtifactPaths m_customerArtifactPaths;
 
  Aws::String m_webUrl;
 
  bool m_skipAppResign{false};
 
  Aws::String m_testSpecArn;
 
  DeviceSelectionResult m_deviceSelectionResult;
 
  VpcConfig m_vpcConfig;
 
  Aws::String m_executionRoleArn;
 
  Aws::Vector<EnvironmentVariable> m_environmentVariables;
 
  Aws::Vector<InsightsType> m_insightsTypes;
 
  RunInsights m_insights;
  bool m_arnHasBeenSet = false;
  bool m_nameHasBeenSet = false;
  bool m_typeHasBeenSet = false;
  bool m_platformHasBeenSet = false;
  bool m_createdHasBeenSet = false;
  bool m_statusHasBeenSet = false;
  bool m_resultHasBeenSet = false;
  bool m_startedHasBeenSet = false;
  bool m_stoppedHasBeenSet = false;
  bool m_countersHasBeenSet = false;
  bool m_messageHasBeenSet = false;
  bool m_totalJobsHasBeenSet = false;
  bool m_completedJobsHasBeenSet = false;
  bool m_billingMethodHasBeenSet = false;
  bool m_deviceMinutesHasBeenSet = false;
  bool m_networkProfileHasBeenSet = false;
  bool m_deviceProxyHasBeenSet = false;
  bool m_parsingResultUrlHasBeenSet = false;
  bool m_resultCodeHasBeenSet = false;
  bool m_seedHasBeenSet = false;
  bool m_appUploadHasBeenSet = false;
  bool m_eventCountHasBeenSet = false;
  bool m_jobTimeoutMinutesHasBeenSet = false;
  bool m_devicePoolArnHasBeenSet = false;
  bool m_localeHasBeenSet = false;
  bool m_radiosHasBeenSet = false;
  bool m_locationHasBeenSet = false;
  bool m_customerArtifactPathsHasBeenSet = false;
  bool m_webUrlHasBeenSet = false;
  bool m_skipAppResignHasBeenSet = false;
  bool m_testSpecArnHasBeenSet = false;
  bool m_deviceSelectionResultHasBeenSet = false;
  bool m_vpcConfigHasBeenSet = false;
  bool m_executionRoleArnHasBeenSet = false;
  bool m_environmentVariablesHasBeenSet = false;
  bool m_insightsTypesHasBeenSet = false;
  bool m_insightsHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace DeviceFarm
}  // namespace Aws