CreateFunctionResult.h

 
#pragma once
#include <aws/core/http/HttpResponse.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/lambda/Lambda_EXPORTS.h>
#include <aws/lambda/model/Architecture.h>
#include <aws/lambda/model/CapacityProviderConfig.h>
#include <aws/lambda/model/DeadLetterConfig.h>
#include <aws/lambda/model/DurableConfig.h>
#include <aws/lambda/model/EnvironmentResponse.h>
#include <aws/lambda/model/EphemeralStorage.h>
#include <aws/lambda/model/FileSystemConfig.h>
#include <aws/lambda/model/ImageConfigResponse.h>
#include <aws/lambda/model/LastUpdateStatus.h>
#include <aws/lambda/model/LastUpdateStatusReasonCode.h>
#include <aws/lambda/model/Layer.h>
#include <aws/lambda/model/LoggingConfig.h>
#include <aws/lambda/model/PackageType.h>
#include <aws/lambda/model/Runtime.h>
#include <aws/lambda/model/RuntimeVersionConfig.h>
#include <aws/lambda/model/SnapStartResponse.h>
#include <aws/lambda/model/State.h>
#include <aws/lambda/model/StateReasonCode.h>
#include <aws/lambda/model/TenancyConfig.h>
#include <aws/lambda/model/TracingConfigResponse.h>
#include <aws/lambda/model/VpcConfigResponse.h>
 
#include <utility>
 
namespace Aws {
template <typename RESULT_TYPE>
class AmazonWebServiceResult;
 
namespace Utils {
namespace Json {
class JsonValue;
}  // namespace Json
}  // namespace Utils
namespace Lambda {
namespace Model {
class CreateFunctionResult {
 public:
  AWS_LAMBDA_API CreateFunctionResult() = default;
  AWS_LAMBDA_API CreateFunctionResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
  AWS_LAMBDA_API CreateFunctionResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
 
 
  inline const Aws::String& GetFunctionName() const { return m_functionName; }
  template <typename FunctionNameT = Aws::String>
  void SetFunctionName(FunctionNameT&& value) {
    m_functionNameHasBeenSet = true;
    m_functionName = std::forward<FunctionNameT>(value);
  }
  template <typename FunctionNameT = Aws::String>
  CreateFunctionResult& WithFunctionName(FunctionNameT&& value) {
    SetFunctionName(std::forward<FunctionNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetFunctionArn() const { return m_functionArn; }
  template <typename FunctionArnT = Aws::String>
  void SetFunctionArn(FunctionArnT&& value) {
    m_functionArnHasBeenSet = true;
    m_functionArn = std::forward<FunctionArnT>(value);
  }
  template <typename FunctionArnT = Aws::String>
  CreateFunctionResult& WithFunctionArn(FunctionArnT&& value) {
    SetFunctionArn(std::forward<FunctionArnT>(value));
    return *this;
  }
 
 
  inline Runtime GetRuntime() const { return m_runtime; }
  inline void SetRuntime(Runtime value) {
    m_runtimeHasBeenSet = true;
    m_runtime = value;
  }
  inline CreateFunctionResult& WithRuntime(Runtime value) {
    SetRuntime(value);
    return *this;
  }
 
 
  inline const Aws::String& GetRole() const { return m_role; }
  template <typename RoleT = Aws::String>
  void SetRole(RoleT&& value) {
    m_roleHasBeenSet = true;
    m_role = std::forward<RoleT>(value);
  }
  template <typename RoleT = Aws::String>
  CreateFunctionResult& WithRole(RoleT&& value) {
    SetRole(std::forward<RoleT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetHandler() const { return m_handler; }
  template <typename HandlerT = Aws::String>
  void SetHandler(HandlerT&& value) {
    m_handlerHasBeenSet = true;
    m_handler = std::forward<HandlerT>(value);
  }
  template <typename HandlerT = Aws::String>
  CreateFunctionResult& WithHandler(HandlerT&& value) {
    SetHandler(std::forward<HandlerT>(value));
    return *this;
  }
 
 
  inline long long GetCodeSize() const { return m_codeSize; }
  inline void SetCodeSize(long long value) {
    m_codeSizeHasBeenSet = true;
    m_codeSize = value;
  }
  inline CreateFunctionResult& WithCodeSize(long long value) {
    SetCodeSize(value);
    return *this;
  }
 
 
  inline const Aws::String& GetDescription() const { return m_description; }
  template <typename DescriptionT = Aws::String>
  void SetDescription(DescriptionT&& value) {
    m_descriptionHasBeenSet = true;
    m_description = std::forward<DescriptionT>(value);
  }
  template <typename DescriptionT = Aws::String>
  CreateFunctionResult& WithDescription(DescriptionT&& value) {
    SetDescription(std::forward<DescriptionT>(value));
    return *this;
  }
 
 
  inline int GetTimeout() const { return m_timeout; }
  inline void SetTimeout(int value) {
    m_timeoutHasBeenSet = true;
    m_timeout = value;
  }
  inline CreateFunctionResult& WithTimeout(int value) {
    SetTimeout(value);
    return *this;
  }
 
 
  inline int GetMemorySize() const { return m_memorySize; }
  inline void SetMemorySize(int value) {
    m_memorySizeHasBeenSet = true;
    m_memorySize = value;
  }
  inline CreateFunctionResult& WithMemorySize(int value) {
    SetMemorySize(value);
    return *this;
  }
 
 
  inline const Aws::String& GetLastModified() const { return m_lastModified; }
  template <typename LastModifiedT = Aws::String>
  void SetLastModified(LastModifiedT&& value) {
    m_lastModifiedHasBeenSet = true;
    m_lastModified = std::forward<LastModifiedT>(value);
  }
  template <typename LastModifiedT = Aws::String>
  CreateFunctionResult& WithLastModified(LastModifiedT&& value) {
    SetLastModified(std::forward<LastModifiedT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCodeSha256() const { return m_codeSha256; }
  template <typename CodeSha256T = Aws::String>
  void SetCodeSha256(CodeSha256T&& value) {
    m_codeSha256HasBeenSet = true;
    m_codeSha256 = std::forward<CodeSha256T>(value);
  }
  template <typename CodeSha256T = Aws::String>
  CreateFunctionResult& WithCodeSha256(CodeSha256T&& value) {
    SetCodeSha256(std::forward<CodeSha256T>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetVersion() const { return m_version; }
  template <typename VersionT = Aws::String>
  void SetVersion(VersionT&& value) {
    m_versionHasBeenSet = true;
    m_version = std::forward<VersionT>(value);
  }
  template <typename VersionT = Aws::String>
  CreateFunctionResult& WithVersion(VersionT&& value) {
    SetVersion(std::forward<VersionT>(value));
    return *this;
  }
 
 
  inline const VpcConfigResponse& GetVpcConfig() const { return m_vpcConfig; }
  template <typename VpcConfigT = VpcConfigResponse>
  void SetVpcConfig(VpcConfigT&& value) {
    m_vpcConfigHasBeenSet = true;
    m_vpcConfig = std::forward<VpcConfigT>(value);
  }
  template <typename VpcConfigT = VpcConfigResponse>
  CreateFunctionResult& WithVpcConfig(VpcConfigT&& value) {
    SetVpcConfig(std::forward<VpcConfigT>(value));
    return *this;
  }
 
 
  inline const DeadLetterConfig& GetDeadLetterConfig() const { return m_deadLetterConfig; }
  template <typename DeadLetterConfigT = DeadLetterConfig>
  void SetDeadLetterConfig(DeadLetterConfigT&& value) {
    m_deadLetterConfigHasBeenSet = true;
    m_deadLetterConfig = std::forward<DeadLetterConfigT>(value);
  }
  template <typename DeadLetterConfigT = DeadLetterConfig>
  CreateFunctionResult& WithDeadLetterConfig(DeadLetterConfigT&& value) {
    SetDeadLetterConfig(std::forward<DeadLetterConfigT>(value));
    return *this;
  }
 
 
  inline const EnvironmentResponse& GetEnvironment() const { return m_environment; }
  template <typename EnvironmentT = EnvironmentResponse>
  void SetEnvironment(EnvironmentT&& value) {
    m_environmentHasBeenSet = true;
    m_environment = std::forward<EnvironmentT>(value);
  }
  template <typename EnvironmentT = EnvironmentResponse>
  CreateFunctionResult& WithEnvironment(EnvironmentT&& value) {
    SetEnvironment(std::forward<EnvironmentT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetKMSKeyArn() const { return m_kMSKeyArn; }
  template <typename KMSKeyArnT = Aws::String>
  void SetKMSKeyArn(KMSKeyArnT&& value) {
    m_kMSKeyArnHasBeenSet = true;
    m_kMSKeyArn = std::forward<KMSKeyArnT>(value);
  }
  template <typename KMSKeyArnT = Aws::String>
  CreateFunctionResult& WithKMSKeyArn(KMSKeyArnT&& value) {
    SetKMSKeyArn(std::forward<KMSKeyArnT>(value));
    return *this;
  }
 
 
  inline const TracingConfigResponse& GetTracingConfig() const { return m_tracingConfig; }
  template <typename TracingConfigT = TracingConfigResponse>
  void SetTracingConfig(TracingConfigT&& value) {
    m_tracingConfigHasBeenSet = true;
    m_tracingConfig = std::forward<TracingConfigT>(value);
  }
  template <typename TracingConfigT = TracingConfigResponse>
  CreateFunctionResult& WithTracingConfig(TracingConfigT&& value) {
    SetTracingConfig(std::forward<TracingConfigT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetMasterArn() const { return m_masterArn; }
  template <typename MasterArnT = Aws::String>
  void SetMasterArn(MasterArnT&& value) {
    m_masterArnHasBeenSet = true;
    m_masterArn = std::forward<MasterArnT>(value);
  }
  template <typename MasterArnT = Aws::String>
  CreateFunctionResult& WithMasterArn(MasterArnT&& value) {
    SetMasterArn(std::forward<MasterArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRevisionId() const { return m_revisionId; }
  template <typename RevisionIdT = Aws::String>
  void SetRevisionId(RevisionIdT&& value) {
    m_revisionIdHasBeenSet = true;
    m_revisionId = std::forward<RevisionIdT>(value);
  }
  template <typename RevisionIdT = Aws::String>
  CreateFunctionResult& WithRevisionId(RevisionIdT&& value) {
    SetRevisionId(std::forward<RevisionIdT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Layer>& GetLayers() const { return m_layers; }
  template <typename LayersT = Aws::Vector<Layer>>
  void SetLayers(LayersT&& value) {
    m_layersHasBeenSet = true;
    m_layers = std::forward<LayersT>(value);
  }
  template <typename LayersT = Aws::Vector<Layer>>
  CreateFunctionResult& WithLayers(LayersT&& value) {
    SetLayers(std::forward<LayersT>(value));
    return *this;
  }
  template <typename LayersT = Layer>
  CreateFunctionResult& AddLayers(LayersT&& value) {
    m_layersHasBeenSet = true;
    m_layers.emplace_back(std::forward<LayersT>(value));
    return *this;
  }
 
 
  inline State GetState() const { return m_state; }
  inline void SetState(State value) {
    m_stateHasBeenSet = true;
    m_state = value;
  }
  inline CreateFunctionResult& WithState(State value) {
    SetState(value);
    return *this;
  }
 
 
  inline const Aws::String& GetStateReason() const { return m_stateReason; }
  template <typename StateReasonT = Aws::String>
  void SetStateReason(StateReasonT&& value) {
    m_stateReasonHasBeenSet = true;
    m_stateReason = std::forward<StateReasonT>(value);
  }
  template <typename StateReasonT = Aws::String>
  CreateFunctionResult& WithStateReason(StateReasonT&& value) {
    SetStateReason(std::forward<StateReasonT>(value));
    return *this;
  }
 
 
  inline StateReasonCode GetStateReasonCode() const { return m_stateReasonCode; }
  inline void SetStateReasonCode(StateReasonCode value) {
    m_stateReasonCodeHasBeenSet = true;
    m_stateReasonCode = value;
  }
  inline CreateFunctionResult& WithStateReasonCode(StateReasonCode value) {
    SetStateReasonCode(value);
    return *this;
  }
 
 
  inline LastUpdateStatus GetLastUpdateStatus() const { return m_lastUpdateStatus; }
  inline void SetLastUpdateStatus(LastUpdateStatus value) {
    m_lastUpdateStatusHasBeenSet = true;
    m_lastUpdateStatus = value;
  }
  inline CreateFunctionResult& WithLastUpdateStatus(LastUpdateStatus value) {
    SetLastUpdateStatus(value);
    return *this;
  }
 
 
  inline const Aws::String& GetLastUpdateStatusReason() const { return m_lastUpdateStatusReason; }
  template <typename LastUpdateStatusReasonT = Aws::String>
  void SetLastUpdateStatusReason(LastUpdateStatusReasonT&& value) {
    m_lastUpdateStatusReasonHasBeenSet = true;
    m_lastUpdateStatusReason = std::forward<LastUpdateStatusReasonT>(value);
  }
  template <typename LastUpdateStatusReasonT = Aws::String>
  CreateFunctionResult& WithLastUpdateStatusReason(LastUpdateStatusReasonT&& value) {
    SetLastUpdateStatusReason(std::forward<LastUpdateStatusReasonT>(value));
    return *this;
  }
 
 
  inline LastUpdateStatusReasonCode GetLastUpdateStatusReasonCode() const { return m_lastUpdateStatusReasonCode; }
  inline void SetLastUpdateStatusReasonCode(LastUpdateStatusReasonCode value) {
    m_lastUpdateStatusReasonCodeHasBeenSet = true;
    m_lastUpdateStatusReasonCode = value;
  }
  inline CreateFunctionResult& WithLastUpdateStatusReasonCode(LastUpdateStatusReasonCode value) {
    SetLastUpdateStatusReasonCode(value);
    return *this;
  }
 
 
  inline const Aws::Vector<FileSystemConfig>& GetFileSystemConfigs() const { return m_fileSystemConfigs; }
  template <typename FileSystemConfigsT = Aws::Vector<FileSystemConfig>>
  void SetFileSystemConfigs(FileSystemConfigsT&& value) {
    m_fileSystemConfigsHasBeenSet = true;
    m_fileSystemConfigs = std::forward<FileSystemConfigsT>(value);
  }
  template <typename FileSystemConfigsT = Aws::Vector<FileSystemConfig>>
  CreateFunctionResult& WithFileSystemConfigs(FileSystemConfigsT&& value) {
    SetFileSystemConfigs(std::forward<FileSystemConfigsT>(value));
    return *this;
  }
  template <typename FileSystemConfigsT = FileSystemConfig>
  CreateFunctionResult& AddFileSystemConfigs(FileSystemConfigsT&& value) {
    m_fileSystemConfigsHasBeenSet = true;
    m_fileSystemConfigs.emplace_back(std::forward<FileSystemConfigsT>(value));
    return *this;
  }
 
 
  inline PackageType GetPackageType() const { return m_packageType; }
  inline void SetPackageType(PackageType value) {
    m_packageTypeHasBeenSet = true;
    m_packageType = value;
  }
  inline CreateFunctionResult& WithPackageType(PackageType value) {
    SetPackageType(value);
    return *this;
  }
 
 
  inline const ImageConfigResponse& GetImageConfigResponse() const { return m_imageConfigResponse; }
  template <typename ImageConfigResponseT = ImageConfigResponse>
  void SetImageConfigResponse(ImageConfigResponseT&& value) {
    m_imageConfigResponseHasBeenSet = true;
    m_imageConfigResponse = std::forward<ImageConfigResponseT>(value);
  }
  template <typename ImageConfigResponseT = ImageConfigResponse>
  CreateFunctionResult& WithImageConfigResponse(ImageConfigResponseT&& value) {
    SetImageConfigResponse(std::forward<ImageConfigResponseT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSigningProfileVersionArn() const { return m_signingProfileVersionArn; }
  template <typename SigningProfileVersionArnT = Aws::String>
  void SetSigningProfileVersionArn(SigningProfileVersionArnT&& value) {
    m_signingProfileVersionArnHasBeenSet = true;
    m_signingProfileVersionArn = std::forward<SigningProfileVersionArnT>(value);
  }
  template <typename SigningProfileVersionArnT = Aws::String>
  CreateFunctionResult& WithSigningProfileVersionArn(SigningProfileVersionArnT&& value) {
    SetSigningProfileVersionArn(std::forward<SigningProfileVersionArnT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetSigningJobArn() const { return m_signingJobArn; }
  template <typename SigningJobArnT = Aws::String>
  void SetSigningJobArn(SigningJobArnT&& value) {
    m_signingJobArnHasBeenSet = true;
    m_signingJobArn = std::forward<SigningJobArnT>(value);
  }
  template <typename SigningJobArnT = Aws::String>
  CreateFunctionResult& WithSigningJobArn(SigningJobArnT&& value) {
    SetSigningJobArn(std::forward<SigningJobArnT>(value));
    return *this;
  }
 
 
  inline const Aws::Vector<Architecture>& GetArchitectures() const { return m_architectures; }
  template <typename ArchitecturesT = Aws::Vector<Architecture>>
  void SetArchitectures(ArchitecturesT&& value) {
    m_architecturesHasBeenSet = true;
    m_architectures = std::forward<ArchitecturesT>(value);
  }
  template <typename ArchitecturesT = Aws::Vector<Architecture>>
  CreateFunctionResult& WithArchitectures(ArchitecturesT&& value) {
    SetArchitectures(std::forward<ArchitecturesT>(value));
    return *this;
  }
  inline CreateFunctionResult& AddArchitectures(Architecture value) {
    m_architecturesHasBeenSet = true;
    m_architectures.push_back(value);
    return *this;
  }
 
 
  inline const EphemeralStorage& GetEphemeralStorage() const { return m_ephemeralStorage; }
  template <typename EphemeralStorageT = EphemeralStorage>
  void SetEphemeralStorage(EphemeralStorageT&& value) {
    m_ephemeralStorageHasBeenSet = true;
    m_ephemeralStorage = std::forward<EphemeralStorageT>(value);
  }
  template <typename EphemeralStorageT = EphemeralStorage>
  CreateFunctionResult& WithEphemeralStorage(EphemeralStorageT&& value) {
    SetEphemeralStorage(std::forward<EphemeralStorageT>(value));
    return *this;
  }
 
 
  inline const SnapStartResponse& GetSnapStart() const { return m_snapStart; }
  template <typename SnapStartT = SnapStartResponse>
  void SetSnapStart(SnapStartT&& value) {
    m_snapStartHasBeenSet = true;
    m_snapStart = std::forward<SnapStartT>(value);
  }
  template <typename SnapStartT = SnapStartResponse>
  CreateFunctionResult& WithSnapStart(SnapStartT&& value) {
    SetSnapStart(std::forward<SnapStartT>(value));
    return *this;
  }
 
 
  inline const RuntimeVersionConfig& GetRuntimeVersionConfig() const { return m_runtimeVersionConfig; }
  template <typename RuntimeVersionConfigT = RuntimeVersionConfig>
  void SetRuntimeVersionConfig(RuntimeVersionConfigT&& value) {
    m_runtimeVersionConfigHasBeenSet = true;
    m_runtimeVersionConfig = std::forward<RuntimeVersionConfigT>(value);
  }
  template <typename RuntimeVersionConfigT = RuntimeVersionConfig>
  CreateFunctionResult& WithRuntimeVersionConfig(RuntimeVersionConfigT&& value) {
    SetRuntimeVersionConfig(std::forward<RuntimeVersionConfigT>(value));
    return *this;
  }
 
 
  inline const LoggingConfig& GetLoggingConfig() const { return m_loggingConfig; }
  template <typename LoggingConfigT = LoggingConfig>
  void SetLoggingConfig(LoggingConfigT&& value) {
    m_loggingConfigHasBeenSet = true;
    m_loggingConfig = std::forward<LoggingConfigT>(value);
  }
  template <typename LoggingConfigT = LoggingConfig>
  CreateFunctionResult& WithLoggingConfig(LoggingConfigT&& value) {
    SetLoggingConfig(std::forward<LoggingConfigT>(value));
    return *this;
  }
 
 
  inline const CapacityProviderConfig& GetCapacityProviderConfig() const { return m_capacityProviderConfig; }
  template <typename CapacityProviderConfigT = CapacityProviderConfig>
  void SetCapacityProviderConfig(CapacityProviderConfigT&& value) {
    m_capacityProviderConfigHasBeenSet = true;
    m_capacityProviderConfig = std::forward<CapacityProviderConfigT>(value);
  }
  template <typename CapacityProviderConfigT = CapacityProviderConfig>
  CreateFunctionResult& WithCapacityProviderConfig(CapacityProviderConfigT&& value) {
    SetCapacityProviderConfig(std::forward<CapacityProviderConfigT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetConfigSha256() const { return m_configSha256; }
  template <typename ConfigSha256T = Aws::String>
  void SetConfigSha256(ConfigSha256T&& value) {
    m_configSha256HasBeenSet = true;
    m_configSha256 = std::forward<ConfigSha256T>(value);
  }
  template <typename ConfigSha256T = Aws::String>
  CreateFunctionResult& WithConfigSha256(ConfigSha256T&& value) {
    SetConfigSha256(std::forward<ConfigSha256T>(value));
    return *this;
  }
 
 
  inline const DurableConfig& GetDurableConfig() const { return m_durableConfig; }
  template <typename DurableConfigT = DurableConfig>
  void SetDurableConfig(DurableConfigT&& value) {
    m_durableConfigHasBeenSet = true;
    m_durableConfig = std::forward<DurableConfigT>(value);
  }
  template <typename DurableConfigT = DurableConfig>
  CreateFunctionResult& WithDurableConfig(DurableConfigT&& value) {
    SetDurableConfig(std::forward<DurableConfigT>(value));
    return *this;
  }
 
 
  inline const TenancyConfig& GetTenancyConfig() const { return m_tenancyConfig; }
  template <typename TenancyConfigT = TenancyConfig>
  void SetTenancyConfig(TenancyConfigT&& value) {
    m_tenancyConfigHasBeenSet = true;
    m_tenancyConfig = std::forward<TenancyConfigT>(value);
  }
  template <typename TenancyConfigT = TenancyConfig>
  CreateFunctionResult& WithTenancyConfig(TenancyConfigT&& value) {
    SetTenancyConfig(std::forward<TenancyConfigT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetRequestId() const { return m_requestId; }
  template <typename RequestIdT = Aws::String>
  void SetRequestId(RequestIdT&& value) {
    m_requestIdHasBeenSet = true;
    m_requestId = std::forward<RequestIdT>(value);
  }
  template <typename RequestIdT = Aws::String>
  CreateFunctionResult& WithRequestId(RequestIdT&& value) {
    SetRequestId(std::forward<RequestIdT>(value));
    return *this;
  }
  inline Aws::Http::HttpResponseCode GetHttpResponseCode() const { return m_HttpResponseCode; }
 
 private:
  Aws::String m_functionName;
 
  Aws::String m_functionArn;
 
  Runtime m_runtime{Runtime::NOT_SET};
 
  Aws::String m_role;
 
  Aws::String m_handler;
 
  long long m_codeSize{0};
 
  Aws::String m_description;
 
  int m_timeout{0};
 
  int m_memorySize{0};
 
  Aws::String m_lastModified;
 
  Aws::String m_codeSha256;
 
  Aws::String m_version;
 
  VpcConfigResponse m_vpcConfig;
 
  DeadLetterConfig m_deadLetterConfig;
 
  EnvironmentResponse m_environment;
 
  Aws::String m_kMSKeyArn;
 
  TracingConfigResponse m_tracingConfig;
 
  Aws::String m_masterArn;
 
  Aws::String m_revisionId;
 
  Aws::Vector<Layer> m_layers;
 
  State m_state{State::NOT_SET};
 
  Aws::String m_stateReason;
 
  StateReasonCode m_stateReasonCode{StateReasonCode::NOT_SET};
 
  LastUpdateStatus m_lastUpdateStatus{LastUpdateStatus::NOT_SET};
 
  Aws::String m_lastUpdateStatusReason;
 
  LastUpdateStatusReasonCode m_lastUpdateStatusReasonCode{LastUpdateStatusReasonCode::NOT_SET};
 
  Aws::Vector<FileSystemConfig> m_fileSystemConfigs;
 
  PackageType m_packageType{PackageType::NOT_SET};
 
  ImageConfigResponse m_imageConfigResponse;
 
  Aws::String m_signingProfileVersionArn;
 
  Aws::String m_signingJobArn;
 
  Aws::Vector<Architecture> m_architectures;
 
  EphemeralStorage m_ephemeralStorage;
 
  SnapStartResponse m_snapStart;
 
  RuntimeVersionConfig m_runtimeVersionConfig;
 
  LoggingConfig m_loggingConfig;
 
  CapacityProviderConfig m_capacityProviderConfig;
 
  Aws::String m_configSha256;
 
  DurableConfig m_durableConfig;
 
  TenancyConfig m_tenancyConfig;
 
  Aws::String m_requestId;
  Aws::Http::HttpResponseCode m_HttpResponseCode;
  bool m_functionNameHasBeenSet = false;
  bool m_functionArnHasBeenSet = false;
  bool m_runtimeHasBeenSet = false;
  bool m_roleHasBeenSet = false;
  bool m_handlerHasBeenSet = false;
  bool m_codeSizeHasBeenSet = false;
  bool m_descriptionHasBeenSet = false;
  bool m_timeoutHasBeenSet = false;
  bool m_memorySizeHasBeenSet = false;
  bool m_lastModifiedHasBeenSet = false;
  bool m_codeSha256HasBeenSet = false;
  bool m_versionHasBeenSet = false;
  bool m_vpcConfigHasBeenSet = false;
  bool m_deadLetterConfigHasBeenSet = false;
  bool m_environmentHasBeenSet = false;
  bool m_kMSKeyArnHasBeenSet = false;
  bool m_tracingConfigHasBeenSet = false;
  bool m_masterArnHasBeenSet = false;
  bool m_revisionIdHasBeenSet = false;
  bool m_layersHasBeenSet = false;
  bool m_stateHasBeenSet = false;
  bool m_stateReasonHasBeenSet = false;
  bool m_stateReasonCodeHasBeenSet = false;
  bool m_lastUpdateStatusHasBeenSet = false;
  bool m_lastUpdateStatusReasonHasBeenSet = false;
  bool m_lastUpdateStatusReasonCodeHasBeenSet = false;
  bool m_fileSystemConfigsHasBeenSet = false;
  bool m_packageTypeHasBeenSet = false;
  bool m_imageConfigResponseHasBeenSet = false;
  bool m_signingProfileVersionArnHasBeenSet = false;
  bool m_signingJobArnHasBeenSet = false;
  bool m_architecturesHasBeenSet = false;
  bool m_ephemeralStorageHasBeenSet = false;
  bool m_snapStartHasBeenSet = false;
  bool m_runtimeVersionConfigHasBeenSet = false;
  bool m_loggingConfigHasBeenSet = false;
  bool m_capacityProviderConfigHasBeenSet = false;
  bool m_configSha256HasBeenSet = false;
  bool m_durableConfigHasBeenSet = false;
  bool m_tenancyConfigHasBeenSet = false;
  bool m_requestIdHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Lambda
}  // namespace Aws