AWS SDK for C++

AWS SDK for C++ Version 1.11.440

Loading...
Searching...
No Matches
Public Types | Public Member Functions | Static Public Member Functions | Friends | List of all members
Aws::Proton::ProtonClient Class Reference

#include <ProtonClient.h>

Inheritance diagram for Aws::Proton::ProtonClient:
[legend]

Public Types

 
 
 

Public Types inherited from Aws::Client::AWSJsonClient

 

Public Member Functions

 ProtonClient (const Aws::Proton::ProtonClientConfiguration &clientConfiguration=Aws::Proton::ProtonClientConfiguration(), std::shared_ptr< ProtonEndpointProviderBase > endpointProvider=nullptr)
 
 ProtonClient (const Aws::Auth::AWSCredentials &credentials, std::shared_ptr< ProtonEndpointProviderBase > endpointProvider=nullptr, const Aws::Proton::ProtonClientConfiguration &clientConfiguration=Aws::Proton::ProtonClientConfiguration())
 
 ProtonClient (const std::shared_ptr< Aws::Auth::AWSCredentialsProvider > &credentialsProvider, std::shared_ptr< ProtonEndpointProviderBase > endpointProvider=nullptr, const Aws::Proton::ProtonClientConfiguration &clientConfiguration=Aws::Proton::ProtonClientConfiguration())
 
 ProtonClient (const Aws::Client::ClientConfiguration &clientConfiguration)
 
 ProtonClient (const Aws::Auth::AWSCredentials &credentials, const Aws::Client::ClientConfiguration &clientConfiguration)
 
 ProtonClient (const std::shared_ptr< Aws::Auth::AWSCredentialsProvider > &credentialsProvider, const Aws::Client::ClientConfiguration &clientConfiguration)
 
virtual ~ProtonClient ()
 
 
template<typename AcceptEnvironmentAccountConnectionRequestT = Model::AcceptEnvironmentAccountConnectionRequest>
Model::AcceptEnvironmentAccountConnectionOutcomeCallable AcceptEnvironmentAccountConnectionCallable (const AcceptEnvironmentAccountConnectionRequestT &request) const
 
template<typename AcceptEnvironmentAccountConnectionRequestT = Model::AcceptEnvironmentAccountConnectionRequest>
void AcceptEnvironmentAccountConnectionAsync (const AcceptEnvironmentAccountConnectionRequestT &request, const AcceptEnvironmentAccountConnectionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CancelComponentDeploymentRequestT = Model::CancelComponentDeploymentRequest>
Model::CancelComponentDeploymentOutcomeCallable CancelComponentDeploymentCallable (const CancelComponentDeploymentRequestT &request) const
 
template<typename CancelComponentDeploymentRequestT = Model::CancelComponentDeploymentRequest>
void CancelComponentDeploymentAsync (const CancelComponentDeploymentRequestT &request, const CancelComponentDeploymentResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CancelEnvironmentDeploymentRequestT = Model::CancelEnvironmentDeploymentRequest>
Model::CancelEnvironmentDeploymentOutcomeCallable CancelEnvironmentDeploymentCallable (const CancelEnvironmentDeploymentRequestT &request) const
 
template<typename CancelEnvironmentDeploymentRequestT = Model::CancelEnvironmentDeploymentRequest>
void CancelEnvironmentDeploymentAsync (const CancelEnvironmentDeploymentRequestT &request, const CancelEnvironmentDeploymentResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CancelServiceInstanceDeploymentRequestT = Model::CancelServiceInstanceDeploymentRequest>
Model::CancelServiceInstanceDeploymentOutcomeCallable CancelServiceInstanceDeploymentCallable (const CancelServiceInstanceDeploymentRequestT &request) const
 
template<typename CancelServiceInstanceDeploymentRequestT = Model::CancelServiceInstanceDeploymentRequest>
void CancelServiceInstanceDeploymentAsync (const CancelServiceInstanceDeploymentRequestT &request, const CancelServiceInstanceDeploymentResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CancelServicePipelineDeploymentRequestT = Model::CancelServicePipelineDeploymentRequest>
Model::CancelServicePipelineDeploymentOutcomeCallable CancelServicePipelineDeploymentCallable (const CancelServicePipelineDeploymentRequestT &request) const
 
template<typename CancelServicePipelineDeploymentRequestT = Model::CancelServicePipelineDeploymentRequest>
void CancelServicePipelineDeploymentAsync (const CancelServicePipelineDeploymentRequestT &request, const CancelServicePipelineDeploymentResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateComponentRequestT = Model::CreateComponentRequest>
Model::CreateComponentOutcomeCallable CreateComponentCallable (const CreateComponentRequestT &request) const
 
template<typename CreateComponentRequestT = Model::CreateComponentRequest>
void CreateComponentAsync (const CreateComponentRequestT &request, const CreateComponentResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateEnvironmentRequestT = Model::CreateEnvironmentRequest>
Model::CreateEnvironmentOutcomeCallable CreateEnvironmentCallable (const CreateEnvironmentRequestT &request) const
 
template<typename CreateEnvironmentRequestT = Model::CreateEnvironmentRequest>
void CreateEnvironmentAsync (const CreateEnvironmentRequestT &request, const CreateEnvironmentResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateEnvironmentAccountConnectionRequestT = Model::CreateEnvironmentAccountConnectionRequest>
Model::CreateEnvironmentAccountConnectionOutcomeCallable CreateEnvironmentAccountConnectionCallable (const CreateEnvironmentAccountConnectionRequestT &request) const
 
template<typename CreateEnvironmentAccountConnectionRequestT = Model::CreateEnvironmentAccountConnectionRequest>
void CreateEnvironmentAccountConnectionAsync (const CreateEnvironmentAccountConnectionRequestT &request, const CreateEnvironmentAccountConnectionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateEnvironmentTemplateRequestT = Model::CreateEnvironmentTemplateRequest>
Model::CreateEnvironmentTemplateOutcomeCallable CreateEnvironmentTemplateCallable (const CreateEnvironmentTemplateRequestT &request) const
 
template<typename CreateEnvironmentTemplateRequestT = Model::CreateEnvironmentTemplateRequest>
void CreateEnvironmentTemplateAsync (const CreateEnvironmentTemplateRequestT &request, const CreateEnvironmentTemplateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateEnvironmentTemplateVersionRequestT = Model::CreateEnvironmentTemplateVersionRequest>
Model::CreateEnvironmentTemplateVersionOutcomeCallable CreateEnvironmentTemplateVersionCallable (const CreateEnvironmentTemplateVersionRequestT &request) const
 
template<typename CreateEnvironmentTemplateVersionRequestT = Model::CreateEnvironmentTemplateVersionRequest>
void CreateEnvironmentTemplateVersionAsync (const CreateEnvironmentTemplateVersionRequestT &request, const CreateEnvironmentTemplateVersionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateRepositoryRequestT = Model::CreateRepositoryRequest>
Model::CreateRepositoryOutcomeCallable CreateRepositoryCallable (const CreateRepositoryRequestT &request) const
 
template<typename CreateRepositoryRequestT = Model::CreateRepositoryRequest>
void CreateRepositoryAsync (const CreateRepositoryRequestT &request, const CreateRepositoryResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateServiceRequestT = Model::CreateServiceRequest>
Model::CreateServiceOutcomeCallable CreateServiceCallable (const CreateServiceRequestT &request) const
 
template<typename CreateServiceRequestT = Model::CreateServiceRequest>
void CreateServiceAsync (const CreateServiceRequestT &request, const CreateServiceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateServiceInstanceRequestT = Model::CreateServiceInstanceRequest>
Model::CreateServiceInstanceOutcomeCallable CreateServiceInstanceCallable (const CreateServiceInstanceRequestT &request) const
 
template<typename CreateServiceInstanceRequestT = Model::CreateServiceInstanceRequest>
void CreateServiceInstanceAsync (const CreateServiceInstanceRequestT &request, const CreateServiceInstanceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateServiceSyncConfigRequestT = Model::CreateServiceSyncConfigRequest>
Model::CreateServiceSyncConfigOutcomeCallable CreateServiceSyncConfigCallable (const CreateServiceSyncConfigRequestT &request) const
 
template<typename CreateServiceSyncConfigRequestT = Model::CreateServiceSyncConfigRequest>
void CreateServiceSyncConfigAsync (const CreateServiceSyncConfigRequestT &request, const CreateServiceSyncConfigResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateServiceTemplateRequestT = Model::CreateServiceTemplateRequest>
Model::CreateServiceTemplateOutcomeCallable CreateServiceTemplateCallable (const CreateServiceTemplateRequestT &request) const
 
template<typename CreateServiceTemplateRequestT = Model::CreateServiceTemplateRequest>
void CreateServiceTemplateAsync (const CreateServiceTemplateRequestT &request, const CreateServiceTemplateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateServiceTemplateVersionRequestT = Model::CreateServiceTemplateVersionRequest>
Model::CreateServiceTemplateVersionOutcomeCallable CreateServiceTemplateVersionCallable (const CreateServiceTemplateVersionRequestT &request) const
 
template<typename CreateServiceTemplateVersionRequestT = Model::CreateServiceTemplateVersionRequest>
void CreateServiceTemplateVersionAsync (const CreateServiceTemplateVersionRequestT &request, const CreateServiceTemplateVersionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename CreateTemplateSyncConfigRequestT = Model::CreateTemplateSyncConfigRequest>
Model::CreateTemplateSyncConfigOutcomeCallable CreateTemplateSyncConfigCallable (const CreateTemplateSyncConfigRequestT &request) const
 
template<typename CreateTemplateSyncConfigRequestT = Model::CreateTemplateSyncConfigRequest>
void CreateTemplateSyncConfigAsync (const CreateTemplateSyncConfigRequestT &request, const CreateTemplateSyncConfigResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteComponentRequestT = Model::DeleteComponentRequest>
Model::DeleteComponentOutcomeCallable DeleteComponentCallable (const DeleteComponentRequestT &request) const
 
template<typename DeleteComponentRequestT = Model::DeleteComponentRequest>
void DeleteComponentAsync (const DeleteComponentRequestT &request, const DeleteComponentResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteDeploymentRequestT = Model::DeleteDeploymentRequest>
Model::DeleteDeploymentOutcomeCallable DeleteDeploymentCallable (const DeleteDeploymentRequestT &request) const
 
template<typename DeleteDeploymentRequestT = Model::DeleteDeploymentRequest>
void DeleteDeploymentAsync (const DeleteDeploymentRequestT &request, const DeleteDeploymentResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteEnvironmentRequestT = Model::DeleteEnvironmentRequest>
Model::DeleteEnvironmentOutcomeCallable DeleteEnvironmentCallable (const DeleteEnvironmentRequestT &request) const
 
template<typename DeleteEnvironmentRequestT = Model::DeleteEnvironmentRequest>
void DeleteEnvironmentAsync (const DeleteEnvironmentRequestT &request, const DeleteEnvironmentResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteEnvironmentAccountConnectionRequestT = Model::DeleteEnvironmentAccountConnectionRequest>
Model::DeleteEnvironmentAccountConnectionOutcomeCallable DeleteEnvironmentAccountConnectionCallable (const DeleteEnvironmentAccountConnectionRequestT &request) const
 
template<typename DeleteEnvironmentAccountConnectionRequestT = Model::DeleteEnvironmentAccountConnectionRequest>
void DeleteEnvironmentAccountConnectionAsync (const DeleteEnvironmentAccountConnectionRequestT &request, const DeleteEnvironmentAccountConnectionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteEnvironmentTemplateRequestT = Model::DeleteEnvironmentTemplateRequest>
Model::DeleteEnvironmentTemplateOutcomeCallable DeleteEnvironmentTemplateCallable (const DeleteEnvironmentTemplateRequestT &request) const
 
template<typename DeleteEnvironmentTemplateRequestT = Model::DeleteEnvironmentTemplateRequest>
void DeleteEnvironmentTemplateAsync (const DeleteEnvironmentTemplateRequestT &request, const DeleteEnvironmentTemplateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteEnvironmentTemplateVersionRequestT = Model::DeleteEnvironmentTemplateVersionRequest>
Model::DeleteEnvironmentTemplateVersionOutcomeCallable DeleteEnvironmentTemplateVersionCallable (const DeleteEnvironmentTemplateVersionRequestT &request) const
 
template<typename DeleteEnvironmentTemplateVersionRequestT = Model::DeleteEnvironmentTemplateVersionRequest>
void DeleteEnvironmentTemplateVersionAsync (const DeleteEnvironmentTemplateVersionRequestT &request, const DeleteEnvironmentTemplateVersionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteRepositoryRequestT = Model::DeleteRepositoryRequest>
Model::DeleteRepositoryOutcomeCallable DeleteRepositoryCallable (const DeleteRepositoryRequestT &request) const
 
template<typename DeleteRepositoryRequestT = Model::DeleteRepositoryRequest>
void DeleteRepositoryAsync (const DeleteRepositoryRequestT &request, const DeleteRepositoryResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteServiceRequestT = Model::DeleteServiceRequest>
Model::DeleteServiceOutcomeCallable DeleteServiceCallable (const DeleteServiceRequestT &request) const
 
template<typename DeleteServiceRequestT = Model::DeleteServiceRequest>
void DeleteServiceAsync (const DeleteServiceRequestT &request, const DeleteServiceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteServiceSyncConfigRequestT = Model::DeleteServiceSyncConfigRequest>
Model::DeleteServiceSyncConfigOutcomeCallable DeleteServiceSyncConfigCallable (const DeleteServiceSyncConfigRequestT &request) const
 
template<typename DeleteServiceSyncConfigRequestT = Model::DeleteServiceSyncConfigRequest>
void DeleteServiceSyncConfigAsync (const DeleteServiceSyncConfigRequestT &request, const DeleteServiceSyncConfigResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteServiceTemplateRequestT = Model::DeleteServiceTemplateRequest>
Model::DeleteServiceTemplateOutcomeCallable DeleteServiceTemplateCallable (const DeleteServiceTemplateRequestT &request) const
 
template<typename DeleteServiceTemplateRequestT = Model::DeleteServiceTemplateRequest>
void DeleteServiceTemplateAsync (const DeleteServiceTemplateRequestT &request, const DeleteServiceTemplateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteServiceTemplateVersionRequestT = Model::DeleteServiceTemplateVersionRequest>
Model::DeleteServiceTemplateVersionOutcomeCallable DeleteServiceTemplateVersionCallable (const DeleteServiceTemplateVersionRequestT &request) const
 
template<typename DeleteServiceTemplateVersionRequestT = Model::DeleteServiceTemplateVersionRequest>
void DeleteServiceTemplateVersionAsync (const DeleteServiceTemplateVersionRequestT &request, const DeleteServiceTemplateVersionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename DeleteTemplateSyncConfigRequestT = Model::DeleteTemplateSyncConfigRequest>
Model::DeleteTemplateSyncConfigOutcomeCallable DeleteTemplateSyncConfigCallable (const DeleteTemplateSyncConfigRequestT &request) const
 
template<typename DeleteTemplateSyncConfigRequestT = Model::DeleteTemplateSyncConfigRequest>
void DeleteTemplateSyncConfigAsync (const DeleteTemplateSyncConfigRequestT &request, const DeleteTemplateSyncConfigResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetAccountSettingsRequestT = Model::GetAccountSettingsRequest>
Model::GetAccountSettingsOutcomeCallable GetAccountSettingsCallable (const GetAccountSettingsRequestT &request={}) const
 
template<typename GetAccountSettingsRequestT = Model::GetAccountSettingsRequest>
void GetAccountSettingsAsync (const GetAccountSettingsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetAccountSettingsRequestT &request={}) const
 
 
template<typename GetComponentRequestT = Model::GetComponentRequest>
Model::GetComponentOutcomeCallable GetComponentCallable (const GetComponentRequestT &request) const
 
template<typename GetComponentRequestT = Model::GetComponentRequest>
void GetComponentAsync (const GetComponentRequestT &request, const GetComponentResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetDeploymentRequestT = Model::GetDeploymentRequest>
Model::GetDeploymentOutcomeCallable GetDeploymentCallable (const GetDeploymentRequestT &request) const
 
template<typename GetDeploymentRequestT = Model::GetDeploymentRequest>
void GetDeploymentAsync (const GetDeploymentRequestT &request, const GetDeploymentResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetEnvironmentRequestT = Model::GetEnvironmentRequest>
Model::GetEnvironmentOutcomeCallable GetEnvironmentCallable (const GetEnvironmentRequestT &request) const
 
template<typename GetEnvironmentRequestT = Model::GetEnvironmentRequest>
void GetEnvironmentAsync (const GetEnvironmentRequestT &request, const GetEnvironmentResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetEnvironmentAccountConnectionRequestT = Model::GetEnvironmentAccountConnectionRequest>
Model::GetEnvironmentAccountConnectionOutcomeCallable GetEnvironmentAccountConnectionCallable (const GetEnvironmentAccountConnectionRequestT &request) const
 
template<typename GetEnvironmentAccountConnectionRequestT = Model::GetEnvironmentAccountConnectionRequest>
void GetEnvironmentAccountConnectionAsync (const GetEnvironmentAccountConnectionRequestT &request, const GetEnvironmentAccountConnectionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetEnvironmentTemplateRequestT = Model::GetEnvironmentTemplateRequest>
Model::GetEnvironmentTemplateOutcomeCallable GetEnvironmentTemplateCallable (const GetEnvironmentTemplateRequestT &request) const
 
template<typename GetEnvironmentTemplateRequestT = Model::GetEnvironmentTemplateRequest>
void GetEnvironmentTemplateAsync (const GetEnvironmentTemplateRequestT &request, const GetEnvironmentTemplateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetEnvironmentTemplateVersionRequestT = Model::GetEnvironmentTemplateVersionRequest>
Model::GetEnvironmentTemplateVersionOutcomeCallable GetEnvironmentTemplateVersionCallable (const GetEnvironmentTemplateVersionRequestT &request) const
 
template<typename GetEnvironmentTemplateVersionRequestT = Model::GetEnvironmentTemplateVersionRequest>
void GetEnvironmentTemplateVersionAsync (const GetEnvironmentTemplateVersionRequestT &request, const GetEnvironmentTemplateVersionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetRepositoryRequestT = Model::GetRepositoryRequest>
Model::GetRepositoryOutcomeCallable GetRepositoryCallable (const GetRepositoryRequestT &request) const
 
template<typename GetRepositoryRequestT = Model::GetRepositoryRequest>
void GetRepositoryAsync (const GetRepositoryRequestT &request, const GetRepositoryResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetRepositorySyncStatusRequestT = Model::GetRepositorySyncStatusRequest>
Model::GetRepositorySyncStatusOutcomeCallable GetRepositorySyncStatusCallable (const GetRepositorySyncStatusRequestT &request) const
 
template<typename GetRepositorySyncStatusRequestT = Model::GetRepositorySyncStatusRequest>
void GetRepositorySyncStatusAsync (const GetRepositorySyncStatusRequestT &request, const GetRepositorySyncStatusResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetResourcesSummaryRequestT = Model::GetResourcesSummaryRequest>
Model::GetResourcesSummaryOutcomeCallable GetResourcesSummaryCallable (const GetResourcesSummaryRequestT &request={}) const
 
template<typename GetResourcesSummaryRequestT = Model::GetResourcesSummaryRequest>
void GetResourcesSummaryAsync (const GetResourcesSummaryResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const GetResourcesSummaryRequestT &request={}) const
 
 
template<typename GetServiceRequestT = Model::GetServiceRequest>
Model::GetServiceOutcomeCallable GetServiceCallable (const GetServiceRequestT &request) const
 
template<typename GetServiceRequestT = Model::GetServiceRequest>
void GetServiceAsync (const GetServiceRequestT &request, const GetServiceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetServiceInstanceRequestT = Model::GetServiceInstanceRequest>
Model::GetServiceInstanceOutcomeCallable GetServiceInstanceCallable (const GetServiceInstanceRequestT &request) const
 
template<typename GetServiceInstanceRequestT = Model::GetServiceInstanceRequest>
void GetServiceInstanceAsync (const GetServiceInstanceRequestT &request, const GetServiceInstanceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetServiceInstanceSyncStatusRequestT = Model::GetServiceInstanceSyncStatusRequest>
Model::GetServiceInstanceSyncStatusOutcomeCallable GetServiceInstanceSyncStatusCallable (const GetServiceInstanceSyncStatusRequestT &request) const
 
template<typename GetServiceInstanceSyncStatusRequestT = Model::GetServiceInstanceSyncStatusRequest>
void GetServiceInstanceSyncStatusAsync (const GetServiceInstanceSyncStatusRequestT &request, const GetServiceInstanceSyncStatusResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetServiceSyncBlockerSummaryRequestT = Model::GetServiceSyncBlockerSummaryRequest>
Model::GetServiceSyncBlockerSummaryOutcomeCallable GetServiceSyncBlockerSummaryCallable (const GetServiceSyncBlockerSummaryRequestT &request) const
 
template<typename GetServiceSyncBlockerSummaryRequestT = Model::GetServiceSyncBlockerSummaryRequest>
void GetServiceSyncBlockerSummaryAsync (const GetServiceSyncBlockerSummaryRequestT &request, const GetServiceSyncBlockerSummaryResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetServiceSyncConfigRequestT = Model::GetServiceSyncConfigRequest>
Model::GetServiceSyncConfigOutcomeCallable GetServiceSyncConfigCallable (const GetServiceSyncConfigRequestT &request) const
 
template<typename GetServiceSyncConfigRequestT = Model::GetServiceSyncConfigRequest>
void GetServiceSyncConfigAsync (const GetServiceSyncConfigRequestT &request, const GetServiceSyncConfigResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetServiceTemplateRequestT = Model::GetServiceTemplateRequest>
Model::GetServiceTemplateOutcomeCallable GetServiceTemplateCallable (const GetServiceTemplateRequestT &request) const
 
template<typename GetServiceTemplateRequestT = Model::GetServiceTemplateRequest>
void GetServiceTemplateAsync (const GetServiceTemplateRequestT &request, const GetServiceTemplateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetServiceTemplateVersionRequestT = Model::GetServiceTemplateVersionRequest>
Model::GetServiceTemplateVersionOutcomeCallable GetServiceTemplateVersionCallable (const GetServiceTemplateVersionRequestT &request) const
 
template<typename GetServiceTemplateVersionRequestT = Model::GetServiceTemplateVersionRequest>
void GetServiceTemplateVersionAsync (const GetServiceTemplateVersionRequestT &request, const GetServiceTemplateVersionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetTemplateSyncConfigRequestT = Model::GetTemplateSyncConfigRequest>
Model::GetTemplateSyncConfigOutcomeCallable GetTemplateSyncConfigCallable (const GetTemplateSyncConfigRequestT &request) const
 
template<typename GetTemplateSyncConfigRequestT = Model::GetTemplateSyncConfigRequest>
void GetTemplateSyncConfigAsync (const GetTemplateSyncConfigRequestT &request, const GetTemplateSyncConfigResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename GetTemplateSyncStatusRequestT = Model::GetTemplateSyncStatusRequest>
Model::GetTemplateSyncStatusOutcomeCallable GetTemplateSyncStatusCallable (const GetTemplateSyncStatusRequestT &request) const
 
template<typename GetTemplateSyncStatusRequestT = Model::GetTemplateSyncStatusRequest>
void GetTemplateSyncStatusAsync (const GetTemplateSyncStatusRequestT &request, const GetTemplateSyncStatusResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListComponentOutputsRequestT = Model::ListComponentOutputsRequest>
Model::ListComponentOutputsOutcomeCallable ListComponentOutputsCallable (const ListComponentOutputsRequestT &request) const
 
template<typename ListComponentOutputsRequestT = Model::ListComponentOutputsRequest>
void ListComponentOutputsAsync (const ListComponentOutputsRequestT &request, const ListComponentOutputsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListComponentProvisionedResourcesRequestT = Model::ListComponentProvisionedResourcesRequest>
Model::ListComponentProvisionedResourcesOutcomeCallable ListComponentProvisionedResourcesCallable (const ListComponentProvisionedResourcesRequestT &request) const
 
template<typename ListComponentProvisionedResourcesRequestT = Model::ListComponentProvisionedResourcesRequest>
void ListComponentProvisionedResourcesAsync (const ListComponentProvisionedResourcesRequestT &request, const ListComponentProvisionedResourcesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListComponentsRequestT = Model::ListComponentsRequest>
Model::ListComponentsOutcomeCallable ListComponentsCallable (const ListComponentsRequestT &request={}) const
 
template<typename ListComponentsRequestT = Model::ListComponentsRequest>
void ListComponentsAsync (const ListComponentsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const ListComponentsRequestT &request={}) const
 
 
template<typename ListDeploymentsRequestT = Model::ListDeploymentsRequest>
Model::ListDeploymentsOutcomeCallable ListDeploymentsCallable (const ListDeploymentsRequestT &request={}) const
 
template<typename ListDeploymentsRequestT = Model::ListDeploymentsRequest>
void ListDeploymentsAsync (const ListDeploymentsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const ListDeploymentsRequestT &request={}) const
 
 
template<typename ListEnvironmentAccountConnectionsRequestT = Model::ListEnvironmentAccountConnectionsRequest>
Model::ListEnvironmentAccountConnectionsOutcomeCallable ListEnvironmentAccountConnectionsCallable (const ListEnvironmentAccountConnectionsRequestT &request) const
 
template<typename ListEnvironmentAccountConnectionsRequestT = Model::ListEnvironmentAccountConnectionsRequest>
void ListEnvironmentAccountConnectionsAsync (const ListEnvironmentAccountConnectionsRequestT &request, const ListEnvironmentAccountConnectionsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListEnvironmentOutputsRequestT = Model::ListEnvironmentOutputsRequest>
Model::ListEnvironmentOutputsOutcomeCallable ListEnvironmentOutputsCallable (const ListEnvironmentOutputsRequestT &request) const
 
template<typename ListEnvironmentOutputsRequestT = Model::ListEnvironmentOutputsRequest>
void ListEnvironmentOutputsAsync (const ListEnvironmentOutputsRequestT &request, const ListEnvironmentOutputsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListEnvironmentProvisionedResourcesRequestT = Model::ListEnvironmentProvisionedResourcesRequest>
Model::ListEnvironmentProvisionedResourcesOutcomeCallable ListEnvironmentProvisionedResourcesCallable (const ListEnvironmentProvisionedResourcesRequestT &request) const
 
template<typename ListEnvironmentProvisionedResourcesRequestT = Model::ListEnvironmentProvisionedResourcesRequest>
void ListEnvironmentProvisionedResourcesAsync (const ListEnvironmentProvisionedResourcesRequestT &request, const ListEnvironmentProvisionedResourcesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListEnvironmentTemplateVersionsRequestT = Model::ListEnvironmentTemplateVersionsRequest>
Model::ListEnvironmentTemplateVersionsOutcomeCallable ListEnvironmentTemplateVersionsCallable (const ListEnvironmentTemplateVersionsRequestT &request) const
 
template<typename ListEnvironmentTemplateVersionsRequestT = Model::ListEnvironmentTemplateVersionsRequest>
void ListEnvironmentTemplateVersionsAsync (const ListEnvironmentTemplateVersionsRequestT &request, const ListEnvironmentTemplateVersionsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListEnvironmentTemplatesRequestT = Model::ListEnvironmentTemplatesRequest>
Model::ListEnvironmentTemplatesOutcomeCallable ListEnvironmentTemplatesCallable (const ListEnvironmentTemplatesRequestT &request={}) const
 
template<typename ListEnvironmentTemplatesRequestT = Model::ListEnvironmentTemplatesRequest>
void ListEnvironmentTemplatesAsync (const ListEnvironmentTemplatesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const ListEnvironmentTemplatesRequestT &request={}) const
 
 
template<typename ListEnvironmentsRequestT = Model::ListEnvironmentsRequest>
Model::ListEnvironmentsOutcomeCallable ListEnvironmentsCallable (const ListEnvironmentsRequestT &request={}) const
 
template<typename ListEnvironmentsRequestT = Model::ListEnvironmentsRequest>
void ListEnvironmentsAsync (const ListEnvironmentsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const ListEnvironmentsRequestT &request={}) const
 
 
template<typename ListRepositoriesRequestT = Model::ListRepositoriesRequest>
Model::ListRepositoriesOutcomeCallable ListRepositoriesCallable (const ListRepositoriesRequestT &request={}) const
 
template<typename ListRepositoriesRequestT = Model::ListRepositoriesRequest>
void ListRepositoriesAsync (const ListRepositoriesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const ListRepositoriesRequestT &request={}) const
 
 
template<typename ListRepositorySyncDefinitionsRequestT = Model::ListRepositorySyncDefinitionsRequest>
Model::ListRepositorySyncDefinitionsOutcomeCallable ListRepositorySyncDefinitionsCallable (const ListRepositorySyncDefinitionsRequestT &request) const
 
template<typename ListRepositorySyncDefinitionsRequestT = Model::ListRepositorySyncDefinitionsRequest>
void ListRepositorySyncDefinitionsAsync (const ListRepositorySyncDefinitionsRequestT &request, const ListRepositorySyncDefinitionsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListServiceInstanceOutputsRequestT = Model::ListServiceInstanceOutputsRequest>
Model::ListServiceInstanceOutputsOutcomeCallable ListServiceInstanceOutputsCallable (const ListServiceInstanceOutputsRequestT &request) const
 
template<typename ListServiceInstanceOutputsRequestT = Model::ListServiceInstanceOutputsRequest>
void ListServiceInstanceOutputsAsync (const ListServiceInstanceOutputsRequestT &request, const ListServiceInstanceOutputsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListServiceInstanceProvisionedResourcesRequestT = Model::ListServiceInstanceProvisionedResourcesRequest>
Model::ListServiceInstanceProvisionedResourcesOutcomeCallable ListServiceInstanceProvisionedResourcesCallable (const ListServiceInstanceProvisionedResourcesRequestT &request) const
 
template<typename ListServiceInstanceProvisionedResourcesRequestT = Model::ListServiceInstanceProvisionedResourcesRequest>
void ListServiceInstanceProvisionedResourcesAsync (const ListServiceInstanceProvisionedResourcesRequestT &request, const ListServiceInstanceProvisionedResourcesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListServiceInstancesRequestT = Model::ListServiceInstancesRequest>
Model::ListServiceInstancesOutcomeCallable ListServiceInstancesCallable (const ListServiceInstancesRequestT &request={}) const
 
template<typename ListServiceInstancesRequestT = Model::ListServiceInstancesRequest>
void ListServiceInstancesAsync (const ListServiceInstancesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const ListServiceInstancesRequestT &request={}) const
 
 
template<typename ListServicePipelineOutputsRequestT = Model::ListServicePipelineOutputsRequest>
Model::ListServicePipelineOutputsOutcomeCallable ListServicePipelineOutputsCallable (const ListServicePipelineOutputsRequestT &request) const
 
template<typename ListServicePipelineOutputsRequestT = Model::ListServicePipelineOutputsRequest>
void ListServicePipelineOutputsAsync (const ListServicePipelineOutputsRequestT &request, const ListServicePipelineOutputsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListServicePipelineProvisionedResourcesRequestT = Model::ListServicePipelineProvisionedResourcesRequest>
Model::ListServicePipelineProvisionedResourcesOutcomeCallable ListServicePipelineProvisionedResourcesCallable (const ListServicePipelineProvisionedResourcesRequestT &request) const
 
template<typename ListServicePipelineProvisionedResourcesRequestT = Model::ListServicePipelineProvisionedResourcesRequest>
void ListServicePipelineProvisionedResourcesAsync (const ListServicePipelineProvisionedResourcesRequestT &request, const ListServicePipelineProvisionedResourcesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListServiceTemplateVersionsRequestT = Model::ListServiceTemplateVersionsRequest>
Model::ListServiceTemplateVersionsOutcomeCallable ListServiceTemplateVersionsCallable (const ListServiceTemplateVersionsRequestT &request) const
 
template<typename ListServiceTemplateVersionsRequestT = Model::ListServiceTemplateVersionsRequest>
void ListServiceTemplateVersionsAsync (const ListServiceTemplateVersionsRequestT &request, const ListServiceTemplateVersionsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename ListServiceTemplatesRequestT = Model::ListServiceTemplatesRequest>
Model::ListServiceTemplatesOutcomeCallable ListServiceTemplatesCallable (const ListServiceTemplatesRequestT &request={}) const
 
template<typename ListServiceTemplatesRequestT = Model::ListServiceTemplatesRequest>
void ListServiceTemplatesAsync (const ListServiceTemplatesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const ListServiceTemplatesRequestT &request={}) const
 
 
template<typename ListServicesRequestT = Model::ListServicesRequest>
Model::ListServicesOutcomeCallable ListServicesCallable (const ListServicesRequestT &request={}) const
 
template<typename ListServicesRequestT = Model::ListServicesRequest>
void ListServicesAsync (const ListServicesResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const ListServicesRequestT &request={}) const
 
 
template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable (const ListTagsForResourceRequestT &request) const
 
template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
void ListTagsForResourceAsync (const ListTagsForResourceRequestT &request, const ListTagsForResourceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename NotifyResourceDeploymentStatusChangeRequestT = Model::NotifyResourceDeploymentStatusChangeRequest>
Model::NotifyResourceDeploymentStatusChangeOutcomeCallable NotifyResourceDeploymentStatusChangeCallable (const NotifyResourceDeploymentStatusChangeRequestT &request) const
 
template<typename NotifyResourceDeploymentStatusChangeRequestT = Model::NotifyResourceDeploymentStatusChangeRequest>
void NotifyResourceDeploymentStatusChangeAsync (const NotifyResourceDeploymentStatusChangeRequestT &request, const NotifyResourceDeploymentStatusChangeResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename RejectEnvironmentAccountConnectionRequestT = Model::RejectEnvironmentAccountConnectionRequest>
Model::RejectEnvironmentAccountConnectionOutcomeCallable RejectEnvironmentAccountConnectionCallable (const RejectEnvironmentAccountConnectionRequestT &request) const
 
template<typename RejectEnvironmentAccountConnectionRequestT = Model::RejectEnvironmentAccountConnectionRequest>
void RejectEnvironmentAccountConnectionAsync (const RejectEnvironmentAccountConnectionRequestT &request, const RejectEnvironmentAccountConnectionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename TagResourceRequestT = Model::TagResourceRequest>
Model::TagResourceOutcomeCallable TagResourceCallable (const TagResourceRequestT &request) const
 
template<typename TagResourceRequestT = Model::TagResourceRequest>
void TagResourceAsync (const TagResourceRequestT &request, const TagResourceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UntagResourceRequestT = Model::UntagResourceRequest>
Model::UntagResourceOutcomeCallable UntagResourceCallable (const UntagResourceRequestT &request) const
 
template<typename UntagResourceRequestT = Model::UntagResourceRequest>
void UntagResourceAsync (const UntagResourceRequestT &request, const UntagResourceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateAccountSettingsRequestT = Model::UpdateAccountSettingsRequest>
Model::UpdateAccountSettingsOutcomeCallable UpdateAccountSettingsCallable (const UpdateAccountSettingsRequestT &request={}) const
 
template<typename UpdateAccountSettingsRequestT = Model::UpdateAccountSettingsRequest>
void UpdateAccountSettingsAsync (const UpdateAccountSettingsResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr, const UpdateAccountSettingsRequestT &request={}) const
 
 
template<typename UpdateComponentRequestT = Model::UpdateComponentRequest>
Model::UpdateComponentOutcomeCallable UpdateComponentCallable (const UpdateComponentRequestT &request) const
 
template<typename UpdateComponentRequestT = Model::UpdateComponentRequest>
void UpdateComponentAsync (const UpdateComponentRequestT &request, const UpdateComponentResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateEnvironmentRequestT = Model::UpdateEnvironmentRequest>
Model::UpdateEnvironmentOutcomeCallable UpdateEnvironmentCallable (const UpdateEnvironmentRequestT &request) const
 
template<typename UpdateEnvironmentRequestT = Model::UpdateEnvironmentRequest>
void UpdateEnvironmentAsync (const UpdateEnvironmentRequestT &request, const UpdateEnvironmentResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateEnvironmentAccountConnectionRequestT = Model::UpdateEnvironmentAccountConnectionRequest>
Model::UpdateEnvironmentAccountConnectionOutcomeCallable UpdateEnvironmentAccountConnectionCallable (const UpdateEnvironmentAccountConnectionRequestT &request) const
 
template<typename UpdateEnvironmentAccountConnectionRequestT = Model::UpdateEnvironmentAccountConnectionRequest>
void UpdateEnvironmentAccountConnectionAsync (const UpdateEnvironmentAccountConnectionRequestT &request, const UpdateEnvironmentAccountConnectionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateEnvironmentTemplateRequestT = Model::UpdateEnvironmentTemplateRequest>
Model::UpdateEnvironmentTemplateOutcomeCallable UpdateEnvironmentTemplateCallable (const UpdateEnvironmentTemplateRequestT &request) const
 
template<typename UpdateEnvironmentTemplateRequestT = Model::UpdateEnvironmentTemplateRequest>
void UpdateEnvironmentTemplateAsync (const UpdateEnvironmentTemplateRequestT &request, const UpdateEnvironmentTemplateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateEnvironmentTemplateVersionRequestT = Model::UpdateEnvironmentTemplateVersionRequest>
Model::UpdateEnvironmentTemplateVersionOutcomeCallable UpdateEnvironmentTemplateVersionCallable (const UpdateEnvironmentTemplateVersionRequestT &request) const
 
template<typename UpdateEnvironmentTemplateVersionRequestT = Model::UpdateEnvironmentTemplateVersionRequest>
void UpdateEnvironmentTemplateVersionAsync (const UpdateEnvironmentTemplateVersionRequestT &request, const UpdateEnvironmentTemplateVersionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateServiceRequestT = Model::UpdateServiceRequest>
Model::UpdateServiceOutcomeCallable UpdateServiceCallable (const UpdateServiceRequestT &request) const
 
template<typename UpdateServiceRequestT = Model::UpdateServiceRequest>
void UpdateServiceAsync (const UpdateServiceRequestT &request, const UpdateServiceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateServiceInstanceRequestT = Model::UpdateServiceInstanceRequest>
Model::UpdateServiceInstanceOutcomeCallable UpdateServiceInstanceCallable (const UpdateServiceInstanceRequestT &request) const
 
template<typename UpdateServiceInstanceRequestT = Model::UpdateServiceInstanceRequest>
void UpdateServiceInstanceAsync (const UpdateServiceInstanceRequestT &request, const UpdateServiceInstanceResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateServicePipelineRequestT = Model::UpdateServicePipelineRequest>
Model::UpdateServicePipelineOutcomeCallable UpdateServicePipelineCallable (const UpdateServicePipelineRequestT &request) const
 
template<typename UpdateServicePipelineRequestT = Model::UpdateServicePipelineRequest>
void UpdateServicePipelineAsync (const UpdateServicePipelineRequestT &request, const UpdateServicePipelineResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateServiceSyncBlockerRequestT = Model::UpdateServiceSyncBlockerRequest>
Model::UpdateServiceSyncBlockerOutcomeCallable UpdateServiceSyncBlockerCallable (const UpdateServiceSyncBlockerRequestT &request) const
 
template<typename UpdateServiceSyncBlockerRequestT = Model::UpdateServiceSyncBlockerRequest>
void UpdateServiceSyncBlockerAsync (const UpdateServiceSyncBlockerRequestT &request, const UpdateServiceSyncBlockerResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateServiceSyncConfigRequestT = Model::UpdateServiceSyncConfigRequest>
Model::UpdateServiceSyncConfigOutcomeCallable UpdateServiceSyncConfigCallable (const UpdateServiceSyncConfigRequestT &request) const
 
template<typename UpdateServiceSyncConfigRequestT = Model::UpdateServiceSyncConfigRequest>
void UpdateServiceSyncConfigAsync (const UpdateServiceSyncConfigRequestT &request, const UpdateServiceSyncConfigResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateServiceTemplateRequestT = Model::UpdateServiceTemplateRequest>
Model::UpdateServiceTemplateOutcomeCallable UpdateServiceTemplateCallable (const UpdateServiceTemplateRequestT &request) const
 
template<typename UpdateServiceTemplateRequestT = Model::UpdateServiceTemplateRequest>
void UpdateServiceTemplateAsync (const UpdateServiceTemplateRequestT &request, const UpdateServiceTemplateResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateServiceTemplateVersionRequestT = Model::UpdateServiceTemplateVersionRequest>
Model::UpdateServiceTemplateVersionOutcomeCallable UpdateServiceTemplateVersionCallable (const UpdateServiceTemplateVersionRequestT &request) const
 
template<typename UpdateServiceTemplateVersionRequestT = Model::UpdateServiceTemplateVersionRequest>
void UpdateServiceTemplateVersionAsync (const UpdateServiceTemplateVersionRequestT &request, const UpdateServiceTemplateVersionResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
 
template<typename UpdateTemplateSyncConfigRequestT = Model::UpdateTemplateSyncConfigRequest>
Model::UpdateTemplateSyncConfigOutcomeCallable UpdateTemplateSyncConfigCallable (const UpdateTemplateSyncConfigRequestT &request) const
 
template<typename UpdateTemplateSyncConfigRequestT = Model::UpdateTemplateSyncConfigRequest>
void UpdateTemplateSyncConfigAsync (const UpdateTemplateSyncConfigRequestT &request, const UpdateTemplateSyncConfigResponseReceivedHandler &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
void OverrideEndpoint (const Aws::String &endpoint)
 
 

Public Member Functions inherited from Aws::Client::AWSJsonClient

 AWSJsonClient (const Aws::Client::ClientConfiguration &configuration, const std::shared_ptr< Aws::Client::AWSAuthSigner > &signer, const std::shared_ptr< AWSErrorMarshaller > &errorMarshaller)
 
 AWSJsonClient (const Aws::Client::ClientConfiguration &configuration, const std::shared_ptr< Aws::Auth::AWSAuthSignerProvider > &signerProvider, const std::shared_ptr< AWSErrorMarshaller > &errorMarshaller)
 
virtual ~AWSJsonClient ()=default
 

Public Member Functions inherited from Aws::Client::AWSClient

 AWSClient (const Aws::Client::ClientConfiguration &configuration, const std::shared_ptr< Aws::Client::AWSAuthSigner > &signer, const std::shared_ptr< AWSErrorMarshaller > &errorMarshaller)
 
 AWSClient (const Aws::Client::ClientConfiguration &configuration, const std::shared_ptr< Aws::Auth::AWSAuthSignerProvider > &signerProvider, const std::shared_ptr< AWSErrorMarshaller > &errorMarshaller)
 
virtual ~AWSClient ()
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={})
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const Aws::Http::HeaderValueCollection &customizedHeaders, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={})
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={}) const
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const Aws::Http::HeaderValueCollection &customizedHeaders, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={})
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const char *serviceName, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={}) const
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const char *serviceName, const Aws::Http::HeaderValueCollection &customizedHeaders, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={})
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const char *serviceName, const char *signerName, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={}) const
 
Aws::String GeneratePresignedUrl (const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const char *serviceName, const char *signerName, const Aws::Http::HeaderValueCollection &customizedHeaders, long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={})
 
Aws::String GeneratePresignedUrl (const Aws::Endpoint::AWSEndpoint &endpoint, Aws::Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const Aws::Http::HeaderValueCollection &customizedHeaders={}, uint64_t expirationInSeconds=0, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={})
 
Aws::String GeneratePresignedUrl (const Aws::AmazonWebServiceRequest &request, const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const Aws::Http::QueryStringParameterCollection &extraParams=Aws::Http::QueryStringParameterCollection(), long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={}) const
 
Aws::String GeneratePresignedUrl (const Aws::AmazonWebServiceRequest &request, const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const char *serviceName, const char *signerName, const Aws::Http::QueryStringParameterCollection &extraParams=Aws::Http::QueryStringParameterCollection(), long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={}) const
 
Aws::String GeneratePresignedUrl (const Aws::AmazonWebServiceRequest &request, const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const char *serviceName, const Aws::Http::QueryStringParameterCollection &extraParams=Aws::Http::QueryStringParameterCollection(), long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={}) const
 
Aws::String GeneratePresignedUrl (const Aws::AmazonWebServiceRequest &request, const Aws::Http::URI &uri, Aws::Http::HttpMethod method, const char *region, const Aws::Http::QueryStringParameterCollection &extraParams=Aws::Http::QueryStringParameterCollection(), long long expirationInSeconds=0, const std::shared_ptr< Aws::Http::ServiceSpecificParameters > serviceSpecificParameter={}) const
 
const std::shared_ptr< Aws::Http::HttpClient > & GetHttpClient () const
 
 
 
virtual const char * GetServiceClientName () const
 
virtual void SetServiceClientName (const Aws::String &name)
 
void AppendToUserAgent (const Aws::String &valueToAppend)
 
 
 
 
 
void SubmitAsync (OperationFuncT operationFunc, const RequestT &request, const HandlerT &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
void SubmitAsync (OperationFuncT operationFunc, RequestT &request, const HandlerT &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
void SubmitAsync (OperationFuncT operationFunc, const HandlerT &handler, const std::shared_ptr< const Aws::Client::AsyncCallerContext > &context=nullptr) const
 
auto SubmitCallable (OperationFuncT operationFunc, const RequestT &request) const -> std::future< decltype((static_cast< const AwsServiceClientT * >(nullptr) -> *operationFunc)(request))>
 
auto SubmitCallable (OperationFuncT operationFunc, RequestT &request) const -> std::future< decltype((static_cast< const AwsServiceClientT * >(nullptr) -> *operationFunc)(request))>
 
auto SubmitCallable (OperationFuncT operationFunc) const -> std::future< decltype((static_cast< const AwsServiceClientT * >(nullptr) -> *operationFunc)())>
 

Static Public Member Functions

static const char * GetServiceName ()
 
static const char * GetAllocationTag ()
 

Static Public Member Functions inherited from Aws::Client::ClientWithAsyncTemplateMethods< ProtonClient >

static void ShutdownSdkClient (void *pThis, int64_t timeoutMs=-1)
 

Friends

 

Additional Inherited Members

Protected Member Functions inherited from Aws::Client::AWSJsonClient

virtual AWSError< CoreErrorsBuildAWSError (const std::shared_ptr< Aws::Http::HttpResponse > &response) const override
 
JsonOutcome MakeRequest (const Aws::AmazonWebServiceRequest &request, const Aws::Endpoint::AWSEndpoint &endpoint, Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
JsonOutcome MakeRequest (const Aws::Endpoint::AWSEndpoint &endpoint, Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
JsonOutcome MakeRequest (const Aws::Http::URI &uri, const Aws::AmazonWebServiceRequest &request, Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
JsonOutcome MakeRequest (const Aws::Http::URI &uri, Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *requestName="", const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
JsonOutcome MakeEventStreamRequest (std::shared_ptr< Aws::Http::HttpRequest > &request) const
 

Protected Member Functions inherited from Aws::Client::AWSClient

HttpResponseOutcome AttemptExhaustively (const Aws::Http::URI &uri, const Aws::AmazonWebServiceRequest &request, Http::HttpMethod httpMethod, const char *signerName, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
HttpResponseOutcome AttemptExhaustively (const Aws::Http::URI &uri, Http::HttpMethod httpMethod, const char *signerName, const char *requestName="", const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
HttpResponseOutcome AttemptOneRequest (const std::shared_ptr< Http::HttpRequest > &httpRequest, const Aws::AmazonWebServiceRequest &request, const char *signerName, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
HttpResponseOutcome AttemptOneRequest (const std::shared_ptr< Http::HttpRequest > &httpRequest, const char *signerName, const char *requestName="", const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
StreamOutcome MakeRequestWithUnparsedResponse (const Aws::Http::URI &uri, const Aws::AmazonWebServiceRequest &request, Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
StreamOutcome MakeRequestWithUnparsedResponse (const Aws::Http::URI &uri, Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *requestName="", const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
StreamOutcome MakeRequestWithUnparsedResponse (const Aws::AmazonWebServiceRequest &request, const Aws::Endpoint::AWSEndpoint &endpoint, Http::HttpMethod method=Http::HttpMethod::HTTP_POST, const char *signerName=Aws::Auth::SIGV4_SIGNER, const char *signerRegionOverride=nullptr, const char *signerServiceNameOverride=nullptr) const
 
virtual void BuildHttpRequest (const Aws::AmazonWebServiceRequest &request, const std::shared_ptr< Aws::Http::HttpRequest > &httpRequest) const
 
const std::shared_ptr< AWSErrorMarshaller > & GetErrorMarshaller () const
 
Aws::Client::AWSAuthSignerGetSignerByName (const char *name) const
 
 
std::shared_ptr< Aws::Http::HttpRequestBuildAndSignHttpRequest (const Aws::Http::URI &uri, const Aws::AmazonWebServiceRequest &request, Http::HttpMethod method, const char *signerName) const
 
std::shared_ptr< Aws::Http::HttpResponseMakeHttpRequest (std::shared_ptr< Aws::Http::HttpRequest > &request) const
 

Static Protected Member Functions inherited from Aws::Client::AWSClient

static void AppendRecursionDetectionHeader (std::shared_ptr< Aws::Http::HttpRequest > ioRequest)
 
 
static bool DoesResponseGenerateError (const std::shared_ptr< Aws::Http::HttpResponse > &response)
 

Protected Attributes inherited from Aws::Client::AWSClient

 
 
 
std::atomic< bool > m_isInitialized
 
std::atomic< size_t > m_operationsProcessed
 
std::condition_variable m_shutdownSignal
 
std::mutex m_shutdownMutex
 

Detailed Description

This is the Proton Service API Reference. It provides descriptions, syntax and usage examples for each of the actions and data types for the Proton service.

The documentation for each action shows the Query API request parameters and the XML response.

Alternatively, you can use the Amazon Web Services CLI to access an API. For more information, see the Amazon Web Services Command Line Interface User Guide.

The Proton service is a two-pronged automation framework. Administrators create service templates to provide standardized infrastructure and deployment tooling for serverless and container based applications. Developers, in turn, select from the available service templates to automate their application or service deployments.

Because administrators define the infrastructure and tooling that Proton deploys and manages, they need permissions to use all of the listed API operations.

When developers select a specific infrastructure and tooling set, Proton deploys their applications. To monitor their applications that are running on Proton, developers need permissions to the service create, list, update and delete API operations and the service instance list and update API operations.

To learn more about Proton, see the Proton User Guide.

Ensuring Idempotency

When you make a mutating API request, the request typically returns a result before the asynchronous workflows of the operation are complete. Operations might also time out or encounter other server issues before they're complete, even if the request already returned a result. This might make it difficult to determine whether the request succeeded. Moreover, you might need to retry the request multiple times to ensure that the operation completes successfully. However, if the original request and the subsequent retries are successful, the operation occurs multiple times. This means that you might create more resources than you intended.

Idempotency ensures that an API request action completes no more than one time. With an idempotent request, if the original request action completes successfully, any subsequent retries complete successfully without performing any further actions. However, the result might contain updated information, such as the current creation status.

The following lists of APIs are grouped according to methods that ensure idempotency.

Idempotent create APIs with a client token

The API actions in this list support idempotency with the use of a client token. The corresponding Amazon Web Services CLI commands also support idempotency using a client token. A client token is a unique, case-sensitive string of up to 64 ASCII characters. To make an idempotent API request using one of these actions, specify a client token in the request. We recommend that you don't reuse the same client token for other API requests. If you don’t provide a client token for these APIs, a default client token is automatically provided by SDKs.

Given a request action that has succeeded:

If you retry the request using the same client token and the same parameters, the retry succeeds without performing any further actions other than returning the original resource detail data in the response.

If you retry the request using the same client token, but one or more of the parameters are different, the retry throws a ValidationException with an IdempotentParameterMismatch error.

Client tokens expire eight hours after a request is made. If you retry the request with the expired token, a new resource is created.

If the original resource is deleted and you retry the request, a new resource is created.

Idempotent create APIs with a client token:

Idempotent create APIs

Given a request action that has succeeded:

If you retry the request with an API from this group, and the original resource hasn't been modified, the retry succeeds without performing any further actions other than returning the original resource detail data in the response.

If the original resource has been modified, the retry throws a ConflictException.

If you retry with different input parameters, the retry throws a ValidationException with an IdempotentParameterMismatch error.

Idempotent create APIs:

Idempotent delete APIs

Given a request action that has succeeded:

When you retry the request with an API from this group and the resource was deleted, its metadata is returned in the response.

If you retry and the resource doesn't exist, the response is empty.

In both cases, the retry succeeds.

Idempotent delete APIs:

Asynchronous idempotent delete APIs

Given a request action that has succeeded:

If you retry the request with an API from this group, if the original request delete operation status is DELETE_IN_PROGRESS, the retry returns the resource detail data in the response without performing any further actions.

If the original request delete operation is complete, a retry returns an empty response.

Asynchronous idempotent delete APIs:

Definition at line 106 of file ProtonClient.h.

Member Typedef Documentation

◆ BASECLASS

Definition at line 109 of file ProtonClient.h.

◆ ClientConfigurationType

Definition at line 113 of file ProtonClient.h.

◆ EndpointProviderType

Definition at line 114 of file ProtonClient.h.

Constructor & Destructor Documentation

◆ ProtonClient() [1/6]

Aws::Proton::ProtonClient::ProtonClient ( const Aws::Proton::ProtonClientConfiguration clientConfiguration = Aws::Proton::ProtonClientConfiguration(),
std::shared_ptr< ProtonEndpointProviderBase endpointProvider = nullptr 
)

Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config is not specified, it will be initialized to default values.

◆ ProtonClient() [2/6]

Aws::Proton::ProtonClient::ProtonClient ( const Aws::Auth::AWSCredentials credentials,
std::shared_ptr< ProtonEndpointProviderBase endpointProvider = nullptr,
const Aws::Proton::ProtonClientConfiguration clientConfiguration = Aws::Proton::ProtonClientConfiguration() 
)

Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config is not specified, it will be initialized to default values.

◆ ProtonClient() [3/6]

Aws::Proton::ProtonClient::ProtonClient ( const std::shared_ptr< Aws::Auth::AWSCredentialsProvider > &  credentialsProvider,
std::shared_ptr< ProtonEndpointProviderBase endpointProvider = nullptr,
const Aws::Proton::ProtonClientConfiguration clientConfiguration = Aws::Proton::ProtonClientConfiguration() 
)

Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, the default http client factory will be used

◆ ProtonClient() [4/6]

Aws::Proton::ProtonClient::ProtonClient ( const Aws::Client::ClientConfiguration clientConfiguration)

Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config is not specified, it will be initialized to default values.

◆ ProtonClient() [5/6]

Aws::Proton::ProtonClient::ProtonClient ( const Aws::Auth::AWSCredentials credentials,
const Aws::Client::ClientConfiguration clientConfiguration 
)

Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config is not specified, it will be initialized to default values.

◆ ProtonClient() [6/6]

Aws::Proton::ProtonClient::ProtonClient ( const std::shared_ptr< Aws::Auth::AWSCredentialsProvider > &  credentialsProvider,
const Aws::Client::ClientConfiguration clientConfiguration 
)

Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, the default http client factory will be used

◆ ~ProtonClient()

virtual Aws::Proton::ProtonClient::~ProtonClient ( )
virtual

Member Function Documentation

◆ AcceptEnvironmentAccountConnection()

virtual Model::AcceptEnvironmentAccountConnectionOutcome Aws::Proton::ProtonClient::AcceptEnvironmentAccountConnection ( const Model::AcceptEnvironmentAccountConnectionRequest request) const
virtual

In a management account, an environment account connection request is accepted. When the environment account connection request is accepted, Proton can use the associated IAM role to provision environment infrastructure resources in the associated environment account.

For more information, see Environment account connections in the Proton User guide.

See Also:

AWS API Reference

◆ AcceptEnvironmentAccountConnectionAsync()

template<typename AcceptEnvironmentAccountConnectionRequestT = Model::AcceptEnvironmentAccountConnectionRequest>
void Aws::Proton::ProtonClient::AcceptEnvironmentAccountConnectionAsync ( const AcceptEnvironmentAccountConnectionRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for AcceptEnvironmentAccountConnection that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 191 of file ProtonClient.h.

◆ AcceptEnvironmentAccountConnectionCallable()

template<typename AcceptEnvironmentAccountConnectionRequestT = Model::AcceptEnvironmentAccountConnectionRequest>
Model::AcceptEnvironmentAccountConnectionOutcomeCallable Aws::Proton::ProtonClient::AcceptEnvironmentAccountConnectionCallable ( const AcceptEnvironmentAccountConnectionRequestT &  request) const
inline

A Callable wrapper for AcceptEnvironmentAccountConnection that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 182 of file ProtonClient.h.

◆ accessEndpointProvider()

std::shared_ptr< ProtonEndpointProviderBase > & Aws::Proton::ProtonClient::accessEndpointProvider ( )

◆ CancelComponentDeployment()

virtual Model::CancelComponentDeploymentOutcome Aws::Proton::ProtonClient::CancelComponentDeployment ( const Model::CancelComponentDeploymentRequest request) const
virtual

Attempts to cancel a component deployment (for a component that is in the IN_PROGRESS deployment status).

For more information about components, see Proton components in the Proton User Guide.

See Also:

AWS API Reference

◆ CancelComponentDeploymentAsync()

template<typename CancelComponentDeploymentRequestT = Model::CancelComponentDeploymentRequest>
void Aws::Proton::ProtonClient::CancelComponentDeploymentAsync ( const CancelComponentDeploymentRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CancelComponentDeployment that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 220 of file ProtonClient.h.

◆ CancelComponentDeploymentCallable()

template<typename CancelComponentDeploymentRequestT = Model::CancelComponentDeploymentRequest>
Model::CancelComponentDeploymentOutcomeCallable Aws::Proton::ProtonClient::CancelComponentDeploymentCallable ( const CancelComponentDeploymentRequestT &  request) const
inline

A Callable wrapper for CancelComponentDeployment that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 211 of file ProtonClient.h.

◆ CancelEnvironmentDeployment()

virtual Model::CancelEnvironmentDeploymentOutcome Aws::Proton::ProtonClient::CancelEnvironmentDeployment ( const Model::CancelEnvironmentDeploymentRequest request) const
virtual

Attempts to cancel an environment deployment on an UpdateEnvironment action, if the deployment is IN_PROGRESS. For more information, see Update an environment in the Proton User guide.

The following list includes potential cancellation scenarios.

  • If the cancellation attempt succeeds, the resulting deployment state is CANCELLED.

  • If the cancellation attempt fails, the resulting deployment state is FAILED.

  • If the current UpdateEnvironment action succeeds before the cancellation attempt starts, the resulting deployment state is SUCCEEDED and the cancellation attempt has no effect.

See Also:

AWS API Reference

◆ CancelEnvironmentDeploymentAsync()

template<typename CancelEnvironmentDeploymentRequestT = Model::CancelEnvironmentDeploymentRequest>
void Aws::Proton::ProtonClient::CancelEnvironmentDeploymentAsync ( const CancelEnvironmentDeploymentRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CancelEnvironmentDeployment that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 256 of file ProtonClient.h.

◆ CancelEnvironmentDeploymentCallable()

template<typename CancelEnvironmentDeploymentRequestT = Model::CancelEnvironmentDeploymentRequest>
Model::CancelEnvironmentDeploymentOutcomeCallable Aws::Proton::ProtonClient::CancelEnvironmentDeploymentCallable ( const CancelEnvironmentDeploymentRequestT &  request) const
inline

A Callable wrapper for CancelEnvironmentDeployment that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 247 of file ProtonClient.h.

◆ CancelServiceInstanceDeployment()

virtual Model::CancelServiceInstanceDeploymentOutcome Aws::Proton::ProtonClient::CancelServiceInstanceDeployment ( const Model::CancelServiceInstanceDeploymentRequest request) const
virtual

Attempts to cancel a service instance deployment on an UpdateServiceInstance action, if the deployment is IN_PROGRESS. For more information, see Update a service instance in the Proton User guide.

The following list includes potential cancellation scenarios.

  • If the cancellation attempt succeeds, the resulting deployment state is CANCELLED.

  • If the cancellation attempt fails, the resulting deployment state is FAILED.

  • If the current UpdateServiceInstance action succeeds before the cancellation attempt starts, the resulting deployment state is SUCCEEDED and the cancellation attempt has no effect.

See Also:

AWS API Reference

◆ CancelServiceInstanceDeploymentAsync()

template<typename CancelServiceInstanceDeploymentRequestT = Model::CancelServiceInstanceDeploymentRequest>
void Aws::Proton::ProtonClient::CancelServiceInstanceDeploymentAsync ( const CancelServiceInstanceDeploymentRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CancelServiceInstanceDeployment that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 292 of file ProtonClient.h.

◆ CancelServiceInstanceDeploymentCallable()

template<typename CancelServiceInstanceDeploymentRequestT = Model::CancelServiceInstanceDeploymentRequest>
Model::CancelServiceInstanceDeploymentOutcomeCallable Aws::Proton::ProtonClient::CancelServiceInstanceDeploymentCallable ( const CancelServiceInstanceDeploymentRequestT &  request) const
inline

A Callable wrapper for CancelServiceInstanceDeployment that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 283 of file ProtonClient.h.

◆ CancelServicePipelineDeployment()

virtual Model::CancelServicePipelineDeploymentOutcome Aws::Proton::ProtonClient::CancelServicePipelineDeployment ( const Model::CancelServicePipelineDeploymentRequest request) const
virtual

Attempts to cancel a service pipeline deployment on an UpdateServicePipeline action, if the deployment is IN_PROGRESS. For more information, see Update a service pipeline in the Proton User guide.

The following list includes potential cancellation scenarios.

  • If the cancellation attempt succeeds, the resulting deployment state is CANCELLED.

  • If the cancellation attempt fails, the resulting deployment state is FAILED.

  • If the current UpdateServicePipeline action succeeds before the cancellation attempt starts, the resulting deployment state is SUCCEEDED and the cancellation attempt has no effect.

See Also:

AWS API Reference

◆ CancelServicePipelineDeploymentAsync()

template<typename CancelServicePipelineDeploymentRequestT = Model::CancelServicePipelineDeploymentRequest>
void Aws::Proton::ProtonClient::CancelServicePipelineDeploymentAsync ( const CancelServicePipelineDeploymentRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CancelServicePipelineDeployment that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 328 of file ProtonClient.h.

◆ CancelServicePipelineDeploymentCallable()

template<typename CancelServicePipelineDeploymentRequestT = Model::CancelServicePipelineDeploymentRequest>
Model::CancelServicePipelineDeploymentOutcomeCallable Aws::Proton::ProtonClient::CancelServicePipelineDeploymentCallable ( const CancelServicePipelineDeploymentRequestT &  request) const
inline

A Callable wrapper for CancelServicePipelineDeployment that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 319 of file ProtonClient.h.

◆ CreateComponent()

virtual Model::CreateComponentOutcome Aws::Proton::ProtonClient::CreateComponent ( const Model::CreateComponentRequest request) const
virtual

Create an Proton component. A component is an infrastructure extension for a service instance.

For more information about components, see Proton components in the Proton User Guide.

See Also:

AWS API Reference

◆ CreateComponentAsync()

template<typename CreateComponentRequestT = Model::CreateComponentRequest>
void Aws::Proton::ProtonClient::CreateComponentAsync ( const CreateComponentRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateComponent that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 356 of file ProtonClient.h.

◆ CreateComponentCallable()

template<typename CreateComponentRequestT = Model::CreateComponentRequest>
Model::CreateComponentOutcomeCallable Aws::Proton::ProtonClient::CreateComponentCallable ( const CreateComponentRequestT &  request) const
inline

A Callable wrapper for CreateComponent that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 347 of file ProtonClient.h.

◆ CreateEnvironment()

virtual Model::CreateEnvironmentOutcome Aws::Proton::ProtonClient::CreateEnvironment ( const Model::CreateEnvironmentRequest request) const
virtual

Deploy a new environment. An Proton environment is created from an environment template that defines infrastructure and resources that can be shared across services.

You can provision environments using the following methods:

  • Amazon Web Services-managed provisioning: Proton makes direct calls to provision your resources.

  • Self-managed provisioning: Proton makes pull requests on your repository to provide compiled infrastructure as code (IaC) files that your IaC engine uses to provision resources.

For more information, see Environments and Provisioning methods in the Proton User Guide.

See Also:

AWS API Reference

◆ CreateEnvironmentAccountConnection()

virtual Model::CreateEnvironmentAccountConnectionOutcome Aws::Proton::ProtonClient::CreateEnvironmentAccountConnection ( const Model::CreateEnvironmentAccountConnectionRequest request) const
virtual

Create an environment account connection in an environment account so that environment infrastructure resources can be provisioned in the environment account from a management account.

An environment account connection is a secure bi-directional connection between a management account and an environment account that maintains authorization and permissions. For more information, see Environment account connections in the Proton User guide.

See Also:

AWS API Reference

◆ CreateEnvironmentAccountConnectionAsync()

template<typename CreateEnvironmentAccountConnectionRequestT = Model::CreateEnvironmentAccountConnectionRequest>
void Aws::Proton::ProtonClient::CreateEnvironmentAccountConnectionAsync ( const CreateEnvironmentAccountConnectionRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateEnvironmentAccountConnection that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 425 of file ProtonClient.h.

◆ CreateEnvironmentAccountConnectionCallable()

template<typename CreateEnvironmentAccountConnectionRequestT = Model::CreateEnvironmentAccountConnectionRequest>
Model::CreateEnvironmentAccountConnectionOutcomeCallable Aws::Proton::ProtonClient::CreateEnvironmentAccountConnectionCallable ( const CreateEnvironmentAccountConnectionRequestT &  request) const
inline

A Callable wrapper for CreateEnvironmentAccountConnection that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 416 of file ProtonClient.h.

◆ CreateEnvironmentAsync()

template<typename CreateEnvironmentRequestT = Model::CreateEnvironmentRequest>
void Aws::Proton::ProtonClient::CreateEnvironmentAsync ( const CreateEnvironmentRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateEnvironment that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 392 of file ProtonClient.h.

◆ CreateEnvironmentCallable()

template<typename CreateEnvironmentRequestT = Model::CreateEnvironmentRequest>
Model::CreateEnvironmentOutcomeCallable Aws::Proton::ProtonClient::CreateEnvironmentCallable ( const CreateEnvironmentRequestT &  request) const
inline

A Callable wrapper for CreateEnvironment that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 383 of file ProtonClient.h.

◆ CreateEnvironmentTemplate()

virtual Model::CreateEnvironmentTemplateOutcome Aws::Proton::ProtonClient::CreateEnvironmentTemplate ( const Model::CreateEnvironmentTemplateRequest request) const
virtual

Create an environment template for Proton. For more information, see Environment Templates in the Proton User Guide.

You can create an environment template in one of the two following ways:

  • Register and publish a standard environment template that instructs Proton to deploy and manage environment infrastructure.

  • Register and publish a customer managed environment template that connects Proton to your existing provisioned infrastructure that you manage. Proton doesn't manage your existing provisioned infrastructure. To create an environment template for customer provisioned and managed infrastructure, include the provisioning parameter and set the value to CUSTOMER_MANAGED. For more information, see Register and publish an environment template in the Proton User Guide.

See Also:

AWS API Reference

◆ CreateEnvironmentTemplateAsync()

template<typename CreateEnvironmentTemplateRequestT = Model::CreateEnvironmentTemplateRequest>
void Aws::Proton::ProtonClient::CreateEnvironmentTemplateAsync ( const CreateEnvironmentTemplateRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateEnvironmentTemplate that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 464 of file ProtonClient.h.

◆ CreateEnvironmentTemplateCallable()

template<typename CreateEnvironmentTemplateRequestT = Model::CreateEnvironmentTemplateRequest>
Model::CreateEnvironmentTemplateOutcomeCallable Aws::Proton::ProtonClient::CreateEnvironmentTemplateCallable ( const CreateEnvironmentTemplateRequestT &  request) const
inline

A Callable wrapper for CreateEnvironmentTemplate that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 455 of file ProtonClient.h.

◆ CreateEnvironmentTemplateVersion()

virtual Model::CreateEnvironmentTemplateVersionOutcome Aws::Proton::ProtonClient::CreateEnvironmentTemplateVersion ( const Model::CreateEnvironmentTemplateVersionRequest request) const
virtual

Create a new major or minor version of an environment template. A major version of an environment template is a version that isn't backwards compatible. A minor version of an environment template is a version that's backwards compatible within its major version.

See Also:

AWS API Reference

◆ CreateEnvironmentTemplateVersionAsync()

template<typename CreateEnvironmentTemplateVersionRequestT = Model::CreateEnvironmentTemplateVersionRequest>
void Aws::Proton::ProtonClient::CreateEnvironmentTemplateVersionAsync ( const CreateEnvironmentTemplateVersionRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateEnvironmentTemplateVersion that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 492 of file ProtonClient.h.

◆ CreateEnvironmentTemplateVersionCallable()

template<typename CreateEnvironmentTemplateVersionRequestT = Model::CreateEnvironmentTemplateVersionRequest>
Model::CreateEnvironmentTemplateVersionOutcomeCallable Aws::Proton::ProtonClient::CreateEnvironmentTemplateVersionCallable ( const CreateEnvironmentTemplateVersionRequestT &  request) const
inline

A Callable wrapper for CreateEnvironmentTemplateVersion that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 483 of file ProtonClient.h.

◆ CreateRepository()

virtual Model::CreateRepositoryOutcome Aws::Proton::ProtonClient::CreateRepository ( const Model::CreateRepositoryRequest request) const
virtual

Create and register a link to a repository. Proton uses the link to repeatedly access the repository, to either push to it (self-managed provisioning) or pull from it (template sync). You can share a linked repository across multiple resources (like environments using self-managed provisioning, or synced templates). When you create a repository link, Proton creates a service-linked role for you.

For more information, see Self-managed provisioning, Template bundles, and Template sync configurations in the Proton User Guide.

See Also:

AWS API Reference

◆ CreateRepositoryAsync()

template<typename CreateRepositoryRequestT = Model::CreateRepositoryRequest>
void Aws::Proton::ProtonClient::CreateRepositoryAsync ( const CreateRepositoryRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateRepository that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 530 of file ProtonClient.h.

◆ CreateRepositoryCallable()

template<typename CreateRepositoryRequestT = Model::CreateRepositoryRequest>
Model::CreateRepositoryOutcomeCallable Aws::Proton::ProtonClient::CreateRepositoryCallable ( const CreateRepositoryRequestT &  request) const
inline

A Callable wrapper for CreateRepository that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 521 of file ProtonClient.h.

◆ CreateService()

virtual Model::CreateServiceOutcome Aws::Proton::ProtonClient::CreateService ( const Model::CreateServiceRequest request) const
virtual

Create an Proton service. An Proton service is an instantiation of a service template and often includes several service instances and pipeline. For more information, see Services in the Proton User Guide.

See Also:

AWS API Reference

◆ CreateServiceAsync()

template<typename CreateServiceRequestT = Model::CreateServiceRequest>
void Aws::Proton::ProtonClient::CreateServiceAsync ( const CreateServiceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateService that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 559 of file ProtonClient.h.

◆ CreateServiceCallable()

template<typename CreateServiceRequestT = Model::CreateServiceRequest>
Model::CreateServiceOutcomeCallable Aws::Proton::ProtonClient::CreateServiceCallable ( const CreateServiceRequestT &  request) const
inline

A Callable wrapper for CreateService that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 550 of file ProtonClient.h.

◆ CreateServiceInstance()

virtual Model::CreateServiceInstanceOutcome Aws::Proton::ProtonClient::CreateServiceInstance ( const Model::CreateServiceInstanceRequest request) const
virtual

Create a service instance.

See Also:

AWS API Reference

◆ CreateServiceInstanceAsync()

template<typename CreateServiceInstanceRequestT = Model::CreateServiceInstanceRequest>
void Aws::Proton::ProtonClient::CreateServiceInstanceAsync ( const CreateServiceInstanceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateServiceInstance that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 584 of file ProtonClient.h.

◆ CreateServiceInstanceCallable()

template<typename CreateServiceInstanceRequestT = Model::CreateServiceInstanceRequest>
Model::CreateServiceInstanceOutcomeCallable Aws::Proton::ProtonClient::CreateServiceInstanceCallable ( const CreateServiceInstanceRequestT &  request) const
inline

A Callable wrapper for CreateServiceInstance that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 575 of file ProtonClient.h.

◆ CreateServiceSyncConfig()

virtual Model::CreateServiceSyncConfigOutcome Aws::Proton::ProtonClient::CreateServiceSyncConfig ( const Model::CreateServiceSyncConfigRequest request) const
virtual

Create the Proton Ops configuration file.

See Also:

AWS API Reference

◆ CreateServiceSyncConfigAsync()

template<typename CreateServiceSyncConfigRequestT = Model::CreateServiceSyncConfigRequest>
void Aws::Proton::ProtonClient::CreateServiceSyncConfigAsync ( const CreateServiceSyncConfigRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateServiceSyncConfig that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 609 of file ProtonClient.h.

◆ CreateServiceSyncConfigCallable()

template<typename CreateServiceSyncConfigRequestT = Model::CreateServiceSyncConfigRequest>
Model::CreateServiceSyncConfigOutcomeCallable Aws::Proton::ProtonClient::CreateServiceSyncConfigCallable ( const CreateServiceSyncConfigRequestT &  request) const
inline

A Callable wrapper for CreateServiceSyncConfig that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 600 of file ProtonClient.h.

◆ CreateServiceTemplate()

virtual Model::CreateServiceTemplateOutcome Aws::Proton::ProtonClient::CreateServiceTemplate ( const Model::CreateServiceTemplateRequest request) const
virtual

Create a service template. The administrator creates a service template to define standardized infrastructure and an optional CI/CD service pipeline. Developers, in turn, select the service template from Proton. If the selected service template includes a service pipeline definition, they provide a link to their source code repository. Proton then deploys and manages the infrastructure defined by the selected service template. For more information, see Proton templates in the Proton User Guide.

See Also:

AWS API Reference

◆ CreateServiceTemplateAsync()

template<typename CreateServiceTemplateRequestT = Model::CreateServiceTemplateRequest>
void Aws::Proton::ProtonClient::CreateServiceTemplateAsync ( const CreateServiceTemplateRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateServiceTemplate that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 641 of file ProtonClient.h.

◆ CreateServiceTemplateCallable()

template<typename CreateServiceTemplateRequestT = Model::CreateServiceTemplateRequest>
Model::CreateServiceTemplateOutcomeCallable Aws::Proton::ProtonClient::CreateServiceTemplateCallable ( const CreateServiceTemplateRequestT &  request) const
inline

A Callable wrapper for CreateServiceTemplate that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 632 of file ProtonClient.h.

◆ CreateServiceTemplateVersion()

virtual Model::CreateServiceTemplateVersionOutcome Aws::Proton::ProtonClient::CreateServiceTemplateVersion ( const Model::CreateServiceTemplateVersionRequest request) const
virtual

Create a new major or minor version of a service template. A major version of a service template is a version that isn't backward compatible. A minor version of a service template is a version that's backward compatible within its major version.

See Also:

AWS API Reference

◆ CreateServiceTemplateVersionAsync()

template<typename CreateServiceTemplateVersionRequestT = Model::CreateServiceTemplateVersionRequest>
void Aws::Proton::ProtonClient::CreateServiceTemplateVersionAsync ( const CreateServiceTemplateVersionRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateServiceTemplateVersion that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 669 of file ProtonClient.h.

◆ CreateServiceTemplateVersionCallable()

template<typename CreateServiceTemplateVersionRequestT = Model::CreateServiceTemplateVersionRequest>
Model::CreateServiceTemplateVersionOutcomeCallable Aws::Proton::ProtonClient::CreateServiceTemplateVersionCallable ( const CreateServiceTemplateVersionRequestT &  request) const
inline

A Callable wrapper for CreateServiceTemplateVersion that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 660 of file ProtonClient.h.

◆ CreateTemplateSyncConfig()

virtual Model::CreateTemplateSyncConfigOutcome Aws::Proton::ProtonClient::CreateTemplateSyncConfig ( const Model::CreateTemplateSyncConfigRequest request) const
virtual

Set up a template to create new template versions automatically by tracking a linked repository. A linked repository is a repository that has been registered with Proton. For more information, see CreateRepository.

When a commit is pushed to your linked repository, Proton checks for changes to your repository template bundles. If it detects a template bundle change, a new major or minor version of its template is created, if the version doesn’t already exist. For more information, see Template sync configurations in the Proton User Guide.

See Also:

AWS API Reference

◆ CreateTemplateSyncConfigAsync()

template<typename CreateTemplateSyncConfigRequestT = Model::CreateTemplateSyncConfigRequest>
void Aws::Proton::ProtonClient::CreateTemplateSyncConfigAsync ( const CreateTemplateSyncConfigRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for CreateTemplateSyncConfig that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 703 of file ProtonClient.h.

◆ CreateTemplateSyncConfigCallable()

template<typename CreateTemplateSyncConfigRequestT = Model::CreateTemplateSyncConfigRequest>
Model::CreateTemplateSyncConfigOutcomeCallable Aws::Proton::ProtonClient::CreateTemplateSyncConfigCallable ( const CreateTemplateSyncConfigRequestT &  request) const
inline

A Callable wrapper for CreateTemplateSyncConfig that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 694 of file ProtonClient.h.

◆ DeleteComponent()

virtual Model::DeleteComponentOutcome Aws::Proton::ProtonClient::DeleteComponent ( const Model::DeleteComponentRequest request) const
virtual

Delete an Proton component resource.

For more information about components, see Proton components in the Proton User Guide.

See Also:

AWS API Reference

◆ DeleteComponentAsync()

template<typename DeleteComponentRequestT = Model::DeleteComponentRequest>
void Aws::Proton::ProtonClient::DeleteComponentAsync ( const DeleteComponentRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteComponent that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 731 of file ProtonClient.h.

◆ DeleteComponentCallable()

template<typename DeleteComponentRequestT = Model::DeleteComponentRequest>
Model::DeleteComponentOutcomeCallable Aws::Proton::ProtonClient::DeleteComponentCallable ( const DeleteComponentRequestT &  request) const
inline

A Callable wrapper for DeleteComponent that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 722 of file ProtonClient.h.

◆ DeleteDeployment()

virtual Model::DeleteDeploymentOutcome Aws::Proton::ProtonClient::DeleteDeployment ( const Model::DeleteDeploymentRequest request) const
virtual

Delete the deployment.

See Also:

AWS API Reference

◆ DeleteDeploymentAsync()

template<typename DeleteDeploymentRequestT = Model::DeleteDeploymentRequest>
void Aws::Proton::ProtonClient::DeleteDeploymentAsync ( const DeleteDeploymentRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteDeployment that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 756 of file ProtonClient.h.

◆ DeleteDeploymentCallable()

template<typename DeleteDeploymentRequestT = Model::DeleteDeploymentRequest>
Model::DeleteDeploymentOutcomeCallable Aws::Proton::ProtonClient::DeleteDeploymentCallable ( const DeleteDeploymentRequestT &  request) const
inline

A Callable wrapper for DeleteDeployment that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 747 of file ProtonClient.h.

◆ DeleteEnvironment()

virtual Model::DeleteEnvironmentOutcome Aws::Proton::ProtonClient::DeleteEnvironment ( const Model::DeleteEnvironmentRequest request) const
virtual

Delete an environment.

See Also:

AWS API Reference

◆ DeleteEnvironmentAccountConnection()

virtual Model::DeleteEnvironmentAccountConnectionOutcome Aws::Proton::ProtonClient::DeleteEnvironmentAccountConnection ( const Model::DeleteEnvironmentAccountConnectionRequest request) const
virtual

In an environment account, delete an environment account connection.

After you delete an environment account connection that’s in use by an Proton environment, Proton can’t manage the environment infrastructure resources until a new environment account connection is accepted for the environment account and associated environment. You're responsible for cleaning up provisioned resources that remain without an environment connection.

For more information, see Environment account connections in the Proton User guide.

See Also:

AWS API Reference

◆ DeleteEnvironmentAccountConnectionAsync()

template<typename DeleteEnvironmentAccountConnectionRequestT = Model::DeleteEnvironmentAccountConnectionRequest>
void Aws::Proton::ProtonClient::DeleteEnvironmentAccountConnectionAsync ( const DeleteEnvironmentAccountConnectionRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteEnvironmentAccountConnection that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 815 of file ProtonClient.h.

◆ DeleteEnvironmentAccountConnectionCallable()

template<typename DeleteEnvironmentAccountConnectionRequestT = Model::DeleteEnvironmentAccountConnectionRequest>
Model::DeleteEnvironmentAccountConnectionOutcomeCallable Aws::Proton::ProtonClient::DeleteEnvironmentAccountConnectionCallable ( const DeleteEnvironmentAccountConnectionRequestT &  request) const
inline

A Callable wrapper for DeleteEnvironmentAccountConnection that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 806 of file ProtonClient.h.

◆ DeleteEnvironmentAsync()

template<typename DeleteEnvironmentRequestT = Model::DeleteEnvironmentRequest>
void Aws::Proton::ProtonClient::DeleteEnvironmentAsync ( const DeleteEnvironmentRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteEnvironment that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 781 of file ProtonClient.h.

◆ DeleteEnvironmentCallable()

template<typename DeleteEnvironmentRequestT = Model::DeleteEnvironmentRequest>
Model::DeleteEnvironmentOutcomeCallable Aws::Proton::ProtonClient::DeleteEnvironmentCallable ( const DeleteEnvironmentRequestT &  request) const
inline

A Callable wrapper for DeleteEnvironment that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 772 of file ProtonClient.h.

◆ DeleteEnvironmentTemplate()

virtual Model::DeleteEnvironmentTemplateOutcome Aws::Proton::ProtonClient::DeleteEnvironmentTemplate ( const Model::DeleteEnvironmentTemplateRequest request) const
virtual

If no other major or minor versions of an environment template exist, delete the environment template.

See Also:

AWS API Reference

◆ DeleteEnvironmentTemplateAsync()

template<typename DeleteEnvironmentTemplateRequestT = Model::DeleteEnvironmentTemplateRequest>
void Aws::Proton::ProtonClient::DeleteEnvironmentTemplateAsync ( const DeleteEnvironmentTemplateRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteEnvironmentTemplate that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 841 of file ProtonClient.h.

◆ DeleteEnvironmentTemplateCallable()

template<typename DeleteEnvironmentTemplateRequestT = Model::DeleteEnvironmentTemplateRequest>
Model::DeleteEnvironmentTemplateOutcomeCallable Aws::Proton::ProtonClient::DeleteEnvironmentTemplateCallable ( const DeleteEnvironmentTemplateRequestT &  request) const
inline

A Callable wrapper for DeleteEnvironmentTemplate that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 832 of file ProtonClient.h.

◆ DeleteEnvironmentTemplateVersion()

virtual Model::DeleteEnvironmentTemplateVersionOutcome Aws::Proton::ProtonClient::DeleteEnvironmentTemplateVersion ( const Model::DeleteEnvironmentTemplateVersionRequest request) const
virtual

If no other minor versions of an environment template exist, delete a major version of the environment template if it's not the Recommended version. Delete the Recommended version of the environment template if no other major versions or minor versions of the environment template exist. A major version of an environment template is a version that's not backward compatible.

Delete a minor version of an environment template if it isn't the Recommended version. Delete a Recommended minor version of the environment template if no other minor versions of the environment template exist. A minor version of an environment template is a version that's backward compatible.

See Also:

AWS API Reference

◆ DeleteEnvironmentTemplateVersionAsync()

template<typename DeleteEnvironmentTemplateVersionRequestT = Model::DeleteEnvironmentTemplateVersionRequest>
void Aws::Proton::ProtonClient::DeleteEnvironmentTemplateVersionAsync ( const DeleteEnvironmentTemplateVersionRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteEnvironmentTemplateVersion that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 876 of file ProtonClient.h.

◆ DeleteEnvironmentTemplateVersionCallable()

template<typename DeleteEnvironmentTemplateVersionRequestT = Model::DeleteEnvironmentTemplateVersionRequest>
Model::DeleteEnvironmentTemplateVersionOutcomeCallable Aws::Proton::ProtonClient::DeleteEnvironmentTemplateVersionCallable ( const DeleteEnvironmentTemplateVersionRequestT &  request) const
inline

A Callable wrapper for DeleteEnvironmentTemplateVersion that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 867 of file ProtonClient.h.

◆ DeleteRepository()

virtual Model::DeleteRepositoryOutcome Aws::Proton::ProtonClient::DeleteRepository ( const Model::DeleteRepositoryRequest request) const
virtual

De-register and unlink your repository.

See Also:

AWS API Reference

◆ DeleteRepositoryAsync()

template<typename DeleteRepositoryRequestT = Model::DeleteRepositoryRequest>
void Aws::Proton::ProtonClient::DeleteRepositoryAsync ( const DeleteRepositoryRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteRepository that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 901 of file ProtonClient.h.

◆ DeleteRepositoryCallable()

template<typename DeleteRepositoryRequestT = Model::DeleteRepositoryRequest>
Model::DeleteRepositoryOutcomeCallable Aws::Proton::ProtonClient::DeleteRepositoryCallable ( const DeleteRepositoryRequestT &  request) const
inline

A Callable wrapper for DeleteRepository that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 892 of file ProtonClient.h.

◆ DeleteService()

virtual Model::DeleteServiceOutcome Aws::Proton::ProtonClient::DeleteService ( const Model::DeleteServiceRequest request) const
virtual

Delete a service, with its instances and pipeline.

You can't delete a service if it has any service instances that have components attached to them.

For more information about components, see Proton components in the Proton User Guide.

See Also:

AWS API Reference

◆ DeleteServiceAsync()

template<typename DeleteServiceRequestT = Model::DeleteServiceRequest>
void Aws::Proton::ProtonClient::DeleteServiceAsync ( const DeleteServiceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteService that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 931 of file ProtonClient.h.

◆ DeleteServiceCallable()

template<typename DeleteServiceRequestT = Model::DeleteServiceRequest>
Model::DeleteServiceOutcomeCallable Aws::Proton::ProtonClient::DeleteServiceCallable ( const DeleteServiceRequestT &  request) const
inline

A Callable wrapper for DeleteService that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 922 of file ProtonClient.h.

◆ DeleteServiceSyncConfig()

virtual Model::DeleteServiceSyncConfigOutcome Aws::Proton::ProtonClient::DeleteServiceSyncConfig ( const Model::DeleteServiceSyncConfigRequest request) const
virtual

Delete the Proton Ops file.

See Also:

AWS API Reference

◆ DeleteServiceSyncConfigAsync()

template<typename DeleteServiceSyncConfigRequestT = Model::DeleteServiceSyncConfigRequest>
void Aws::Proton::ProtonClient::DeleteServiceSyncConfigAsync ( const DeleteServiceSyncConfigRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteServiceSyncConfig that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 956 of file ProtonClient.h.

◆ DeleteServiceSyncConfigCallable()

template<typename DeleteServiceSyncConfigRequestT = Model::DeleteServiceSyncConfigRequest>
Model::DeleteServiceSyncConfigOutcomeCallable Aws::Proton::ProtonClient::DeleteServiceSyncConfigCallable ( const DeleteServiceSyncConfigRequestT &  request) const
inline

A Callable wrapper for DeleteServiceSyncConfig that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 947 of file ProtonClient.h.

◆ DeleteServiceTemplate()

virtual Model::DeleteServiceTemplateOutcome Aws::Proton::ProtonClient::DeleteServiceTemplate ( const Model::DeleteServiceTemplateRequest request) const
virtual

If no other major or minor versions of the service template exist, delete the service template.

See Also:

AWS API Reference

◆ DeleteServiceTemplateAsync()

template<typename DeleteServiceTemplateRequestT = Model::DeleteServiceTemplateRequest>
void Aws::Proton::ProtonClient::DeleteServiceTemplateAsync ( const DeleteServiceTemplateRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteServiceTemplate that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 982 of file ProtonClient.h.

◆ DeleteServiceTemplateCallable()

template<typename DeleteServiceTemplateRequestT = Model::DeleteServiceTemplateRequest>
Model::DeleteServiceTemplateOutcomeCallable Aws::Proton::ProtonClient::DeleteServiceTemplateCallable ( const DeleteServiceTemplateRequestT &  request) const
inline

A Callable wrapper for DeleteServiceTemplate that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 973 of file ProtonClient.h.

◆ DeleteServiceTemplateVersion()

virtual Model::DeleteServiceTemplateVersionOutcome Aws::Proton::ProtonClient::DeleteServiceTemplateVersion ( const Model::DeleteServiceTemplateVersionRequest request) const
virtual

If no other minor versions of a service template exist, delete a major version of the service template if it's not the Recommended version. Delete the Recommended version of the service template if no other major versions or minor versions of the service template exist. A major version of a service template is a version that isn't backwards compatible.

Delete a minor version of a service template if it's not the Recommended version. Delete a Recommended minor version of the service template if no other minor versions of the service template exist. A minor version of a service template is a version that's backwards compatible.

See Also:

AWS API Reference

◆ DeleteServiceTemplateVersionAsync()

template<typename DeleteServiceTemplateVersionRequestT = Model::DeleteServiceTemplateVersionRequest>
void Aws::Proton::ProtonClient::DeleteServiceTemplateVersionAsync ( const DeleteServiceTemplateVersionRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteServiceTemplateVersion that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1016 of file ProtonClient.h.

◆ DeleteServiceTemplateVersionCallable()

template<typename DeleteServiceTemplateVersionRequestT = Model::DeleteServiceTemplateVersionRequest>
Model::DeleteServiceTemplateVersionOutcomeCallable Aws::Proton::ProtonClient::DeleteServiceTemplateVersionCallable ( const DeleteServiceTemplateVersionRequestT &  request) const
inline

A Callable wrapper for DeleteServiceTemplateVersion that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1007 of file ProtonClient.h.

◆ DeleteTemplateSyncConfig()

virtual Model::DeleteTemplateSyncConfigOutcome Aws::Proton::ProtonClient::DeleteTemplateSyncConfig ( const Model::DeleteTemplateSyncConfigRequest request) const
virtual

Delete a template sync configuration.

See Also:

AWS API Reference

◆ DeleteTemplateSyncConfigAsync()

template<typename DeleteTemplateSyncConfigRequestT = Model::DeleteTemplateSyncConfigRequest>
void Aws::Proton::ProtonClient::DeleteTemplateSyncConfigAsync ( const DeleteTemplateSyncConfigRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for DeleteTemplateSyncConfig that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1041 of file ProtonClient.h.

◆ DeleteTemplateSyncConfigCallable()

template<typename DeleteTemplateSyncConfigRequestT = Model::DeleteTemplateSyncConfigRequest>
Model::DeleteTemplateSyncConfigOutcomeCallable Aws::Proton::ProtonClient::DeleteTemplateSyncConfigCallable ( const DeleteTemplateSyncConfigRequestT &  request) const
inline

A Callable wrapper for DeleteTemplateSyncConfig that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1032 of file ProtonClient.h.

◆ GetAccountSettings()

virtual Model::GetAccountSettingsOutcome Aws::Proton::ProtonClient::GetAccountSettings ( const Model::GetAccountSettingsRequest request = {}) const
virtual

Get detail data for Proton account-wide settings.

See Also:


AWS API Reference

◆ GetAccountSettingsAsync()

template<typename GetAccountSettingsRequestT = Model::GetAccountSettingsRequest>
void Aws::Proton::ProtonClient::GetAccountSettingsAsync ( const GetAccountSettingsResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetAccountSettingsRequestT &  request = {} 
) const
inline

An Async wrapper for GetAccountSettings that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1067 of file ProtonClient.h.

◆ GetAccountSettingsCallable()

template<typename GetAccountSettingsRequestT = Model::GetAccountSettingsRequest>
Model::GetAccountSettingsOutcomeCallable Aws::Proton::ProtonClient::GetAccountSettingsCallable ( const GetAccountSettingsRequestT &  request = {}) const
inline

A Callable wrapper for GetAccountSettings that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1058 of file ProtonClient.h.

◆ GetAllocationTag()

static const char * Aws::Proton::ProtonClient::GetAllocationTag ( )
static

◆ GetComponent()

virtual Model::GetComponentOutcome Aws::Proton::ProtonClient::GetComponent ( const Model::GetComponentRequest request) const
virtual

Get detailed data for a component.

For more information about components, see Proton components in the Proton User Guide.

See Also:

AWS API Reference

◆ GetComponentAsync()

template<typename GetComponentRequestT = Model::GetComponentRequest>
void Aws::Proton::ProtonClient::GetComponentAsync ( const GetComponentRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetComponent that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1095 of file ProtonClient.h.

◆ GetComponentCallable()

template<typename GetComponentRequestT = Model::GetComponentRequest>
Model::GetComponentOutcomeCallable Aws::Proton::ProtonClient::GetComponentCallable ( const GetComponentRequestT &  request) const
inline

A Callable wrapper for GetComponent that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1086 of file ProtonClient.h.

◆ GetDeployment()

virtual Model::GetDeploymentOutcome Aws::Proton::ProtonClient::GetDeployment ( const Model::GetDeploymentRequest request) const
virtual

Get detailed data for a deployment.

See Also:

AWS API Reference

◆ GetDeploymentAsync()

template<typename GetDeploymentRequestT = Model::GetDeploymentRequest>
void Aws::Proton::ProtonClient::GetDeploymentAsync ( const GetDeploymentRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetDeployment that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1120 of file ProtonClient.h.

◆ GetDeploymentCallable()

template<typename GetDeploymentRequestT = Model::GetDeploymentRequest>
Model::GetDeploymentOutcomeCallable Aws::Proton::ProtonClient::GetDeploymentCallable ( const GetDeploymentRequestT &  request) const
inline

A Callable wrapper for GetDeployment that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1111 of file ProtonClient.h.

◆ GetEnvironment()

virtual Model::GetEnvironmentOutcome Aws::Proton::ProtonClient::GetEnvironment ( const Model::GetEnvironmentRequest request) const
virtual

Get detailed data for an environment.

See Also:

AWS API Reference

◆ GetEnvironmentAccountConnection()

virtual Model::GetEnvironmentAccountConnectionOutcome Aws::Proton::ProtonClient::GetEnvironmentAccountConnection ( const Model::GetEnvironmentAccountConnectionRequest request) const
virtual

In an environment account, get the detailed data for an environment account connection.

For more information, see Environment account connections in the Proton User guide.

See Also:

AWS API Reference

◆ GetEnvironmentAccountConnectionAsync()

template<typename GetEnvironmentAccountConnectionRequestT = Model::GetEnvironmentAccountConnectionRequest>
void Aws::Proton::ProtonClient::GetEnvironmentAccountConnectionAsync ( const GetEnvironmentAccountConnectionRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetEnvironmentAccountConnection that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1174 of file ProtonClient.h.

◆ GetEnvironmentAccountConnectionCallable()

template<typename GetEnvironmentAccountConnectionRequestT = Model::GetEnvironmentAccountConnectionRequest>
Model::GetEnvironmentAccountConnectionOutcomeCallable Aws::Proton::ProtonClient::GetEnvironmentAccountConnectionCallable ( const GetEnvironmentAccountConnectionRequestT &  request) const
inline

A Callable wrapper for GetEnvironmentAccountConnection that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1165 of file ProtonClient.h.

◆ GetEnvironmentAsync()

template<typename GetEnvironmentRequestT = Model::GetEnvironmentRequest>
void Aws::Proton::ProtonClient::GetEnvironmentAsync ( const GetEnvironmentRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetEnvironment that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1145 of file ProtonClient.h.

◆ GetEnvironmentCallable()

template<typename GetEnvironmentRequestT = Model::GetEnvironmentRequest>
Model::GetEnvironmentOutcomeCallable Aws::Proton::ProtonClient::GetEnvironmentCallable ( const GetEnvironmentRequestT &  request) const
inline

A Callable wrapper for GetEnvironment that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1136 of file ProtonClient.h.

◆ GetEnvironmentTemplate()

virtual Model::GetEnvironmentTemplateOutcome Aws::Proton::ProtonClient::GetEnvironmentTemplate ( const Model::GetEnvironmentTemplateRequest request) const
virtual

Get detailed data for an environment template.

See Also:

AWS API Reference

◆ GetEnvironmentTemplateAsync()

template<typename GetEnvironmentTemplateRequestT = Model::GetEnvironmentTemplateRequest>
void Aws::Proton::ProtonClient::GetEnvironmentTemplateAsync ( const GetEnvironmentTemplateRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetEnvironmentTemplate that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1199 of file ProtonClient.h.

◆ GetEnvironmentTemplateCallable()

template<typename GetEnvironmentTemplateRequestT = Model::GetEnvironmentTemplateRequest>
Model::GetEnvironmentTemplateOutcomeCallable Aws::Proton::ProtonClient::GetEnvironmentTemplateCallable ( const GetEnvironmentTemplateRequestT &  request) const
inline

A Callable wrapper for GetEnvironmentTemplate that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1190 of file ProtonClient.h.

◆ GetEnvironmentTemplateVersion()

virtual Model::GetEnvironmentTemplateVersionOutcome Aws::Proton::ProtonClient::GetEnvironmentTemplateVersion ( const Model::GetEnvironmentTemplateVersionRequest request) const
virtual

Get detailed data for a major or minor version of an environment template.

See Also:

AWS API Reference

◆ GetEnvironmentTemplateVersionAsync()

template<typename GetEnvironmentTemplateVersionRequestT = Model::GetEnvironmentTemplateVersionRequest>
void Aws::Proton::ProtonClient::GetEnvironmentTemplateVersionAsync ( const GetEnvironmentTemplateVersionRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetEnvironmentTemplateVersion that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1225 of file ProtonClient.h.

◆ GetEnvironmentTemplateVersionCallable()

template<typename GetEnvironmentTemplateVersionRequestT = Model::GetEnvironmentTemplateVersionRequest>
Model::GetEnvironmentTemplateVersionOutcomeCallable Aws::Proton::ProtonClient::GetEnvironmentTemplateVersionCallable ( const GetEnvironmentTemplateVersionRequestT &  request) const
inline

A Callable wrapper for GetEnvironmentTemplateVersion that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1216 of file ProtonClient.h.

◆ GetRepository()

virtual Model::GetRepositoryOutcome Aws::Proton::ProtonClient::GetRepository ( const Model::GetRepositoryRequest request) const
virtual

Get detail data for a linked repository.

See Also:

AWS API Reference

◆ GetRepositoryAsync()

template<typename GetRepositoryRequestT = Model::GetRepositoryRequest>
void Aws::Proton::ProtonClient::GetRepositoryAsync ( const GetRepositoryRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetRepository that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1250 of file ProtonClient.h.

◆ GetRepositoryCallable()

template<typename GetRepositoryRequestT = Model::GetRepositoryRequest>
Model::GetRepositoryOutcomeCallable Aws::Proton::ProtonClient::GetRepositoryCallable ( const GetRepositoryRequestT &  request) const
inline

A Callable wrapper for GetRepository that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1241 of file ProtonClient.h.

◆ GetRepositorySyncStatus()

virtual Model::GetRepositorySyncStatusOutcome Aws::Proton::ProtonClient::GetRepositorySyncStatus ( const Model::GetRepositorySyncStatusRequest request) const
virtual

Get the sync status of a repository used for Proton template sync. For more information about template sync, see .

A repository sync status isn't tied to the Proton Repository resource (or any other Proton resource). Therefore, tags on an Proton Repository resource have no effect on this action. Specifically, you can't use these tags to control access to this action using Attribute-based access control (ABAC).

For more information about ABAC, see ABAC in the Proton User Guide.

See Also:

AWS API Reference

◆ GetRepositorySyncStatusAsync()

template<typename GetRepositorySyncStatusRequestT = Model::GetRepositorySyncStatusRequest>
void Aws::Proton::ProtonClient::GetRepositorySyncStatusAsync ( const GetRepositorySyncStatusRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetRepositorySyncStatus that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1283 of file ProtonClient.h.

◆ GetRepositorySyncStatusCallable()

template<typename GetRepositorySyncStatusRequestT = Model::GetRepositorySyncStatusRequest>
Model::GetRepositorySyncStatusOutcomeCallable Aws::Proton::ProtonClient::GetRepositorySyncStatusCallable ( const GetRepositorySyncStatusRequestT &  request) const
inline

A Callable wrapper for GetRepositorySyncStatus that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1274 of file ProtonClient.h.

◆ GetResourcesSummary()

virtual Model::GetResourcesSummaryOutcome Aws::Proton::ProtonClient::GetResourcesSummary ( const Model::GetResourcesSummaryRequest request = {}) const
virtual

Get counts of Proton resources.

For infrastructure-provisioning resources (environments, services, service instances, pipelines), the action returns staleness counts. A resource is stale when it's behind the recommended version of the Proton template that it uses and it needs an update to become current.

The action returns staleness counts (counts of resources that are up-to-date, behind a template major version, or behind a template minor version), the total number of resources, and the number of resources that are in a failed state, grouped by resource type. Components, environments, and service templates return less information - see the components, environments, and serviceTemplates field descriptions.

For context, the action also returns the total number of each type of Proton template in the Amazon Web Services account.

For more information, see Proton dashboard in the Proton User Guide.

See Also:

AWS API Reference

◆ GetResourcesSummaryAsync()

template<typename GetResourcesSummaryRequestT = Model::GetResourcesSummaryRequest>
void Aws::Proton::ProtonClient::GetResourcesSummaryAsync ( const GetResourcesSummaryResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const GetResourcesSummaryRequestT &  request = {} 
) const
inline

An Async wrapper for GetResourcesSummary that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1322 of file ProtonClient.h.

◆ GetResourcesSummaryCallable()

template<typename GetResourcesSummaryRequestT = Model::GetResourcesSummaryRequest>
Model::GetResourcesSummaryOutcomeCallable Aws::Proton::ProtonClient::GetResourcesSummaryCallable ( const GetResourcesSummaryRequestT &  request = {}) const
inline

A Callable wrapper for GetResourcesSummary that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1313 of file ProtonClient.h.

◆ GetService()

virtual Model::GetServiceOutcome Aws::Proton::ProtonClient::GetService ( const Model::GetServiceRequest request) const
virtual

Get detailed data for a service.

See Also:

AWS API Reference

◆ GetServiceAsync()

template<typename GetServiceRequestT = Model::GetServiceRequest>
void Aws::Proton::ProtonClient::GetServiceAsync ( const GetServiceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetService that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1347 of file ProtonClient.h.

◆ GetServiceCallable()

template<typename GetServiceRequestT = Model::GetServiceRequest>
Model::GetServiceOutcomeCallable Aws::Proton::ProtonClient::GetServiceCallable ( const GetServiceRequestT &  request) const
inline

A Callable wrapper for GetService that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1338 of file ProtonClient.h.

◆ GetServiceInstance()

virtual Model::GetServiceInstanceOutcome Aws::Proton::ProtonClient::GetServiceInstance ( const Model::GetServiceInstanceRequest request) const
virtual

Get detailed data for a service instance. A service instance is an instantiation of service template and it runs in a specific environment.

See Also:

AWS API Reference

◆ GetServiceInstanceAsync()

template<typename GetServiceInstanceRequestT = Model::GetServiceInstanceRequest>
void Aws::Proton::ProtonClient::GetServiceInstanceAsync ( const GetServiceInstanceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetServiceInstance that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1374 of file ProtonClient.h.

◆ GetServiceInstanceCallable()

template<typename GetServiceInstanceRequestT = Model::GetServiceInstanceRequest>
Model::GetServiceInstanceOutcomeCallable Aws::Proton::ProtonClient::GetServiceInstanceCallable ( const GetServiceInstanceRequestT &  request) const
inline

A Callable wrapper for GetServiceInstance that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1365 of file ProtonClient.h.

◆ GetServiceInstanceSyncStatus()

virtual Model::GetServiceInstanceSyncStatusOutcome Aws::Proton::ProtonClient::GetServiceInstanceSyncStatus ( const Model::GetServiceInstanceSyncStatusRequest request) const
virtual

Get the status of the synced service instance.

See Also:

AWS API Reference

◆ GetServiceInstanceSyncStatusAsync()

template<typename GetServiceInstanceSyncStatusRequestT = Model::GetServiceInstanceSyncStatusRequest>
void Aws::Proton::ProtonClient::GetServiceInstanceSyncStatusAsync ( const GetServiceInstanceSyncStatusRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetServiceInstanceSyncStatus that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1399 of file ProtonClient.h.

◆ GetServiceInstanceSyncStatusCallable()

template<typename GetServiceInstanceSyncStatusRequestT = Model::GetServiceInstanceSyncStatusRequest>
Model::GetServiceInstanceSyncStatusOutcomeCallable Aws::Proton::ProtonClient::GetServiceInstanceSyncStatusCallable ( const GetServiceInstanceSyncStatusRequestT &  request) const
inline

A Callable wrapper for GetServiceInstanceSyncStatus that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1390 of file ProtonClient.h.

◆ GetServiceName()

static const char * Aws::Proton::ProtonClient::GetServiceName ( )
static

◆ GetServiceSyncBlockerSummary()

virtual Model::GetServiceSyncBlockerSummaryOutcome Aws::Proton::ProtonClient::GetServiceSyncBlockerSummary ( const Model::GetServiceSyncBlockerSummaryRequest request) const
virtual

Get detailed data for the service sync blocker summary.

See Also:

AWS API Reference

◆ GetServiceSyncBlockerSummaryAsync()

template<typename GetServiceSyncBlockerSummaryRequestT = Model::GetServiceSyncBlockerSummaryRequest>
void Aws::Proton::ProtonClient::GetServiceSyncBlockerSummaryAsync ( const GetServiceSyncBlockerSummaryRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetServiceSyncBlockerSummary that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1425 of file ProtonClient.h.

◆ GetServiceSyncBlockerSummaryCallable()

template<typename GetServiceSyncBlockerSummaryRequestT = Model::GetServiceSyncBlockerSummaryRequest>
Model::GetServiceSyncBlockerSummaryOutcomeCallable Aws::Proton::ProtonClient::GetServiceSyncBlockerSummaryCallable ( const GetServiceSyncBlockerSummaryRequestT &  request) const
inline

A Callable wrapper for GetServiceSyncBlockerSummary that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1416 of file ProtonClient.h.

◆ GetServiceSyncConfig()

virtual Model::GetServiceSyncConfigOutcome Aws::Proton::ProtonClient::GetServiceSyncConfig ( const Model::GetServiceSyncConfigRequest request) const
virtual

Get detailed information for the service sync configuration.

See Also:

AWS API Reference

◆ GetServiceSyncConfigAsync()

template<typename GetServiceSyncConfigRequestT = Model::GetServiceSyncConfigRequest>
void Aws::Proton::ProtonClient::GetServiceSyncConfigAsync ( const GetServiceSyncConfigRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetServiceSyncConfig that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1451 of file ProtonClient.h.

◆ GetServiceSyncConfigCallable()

template<typename GetServiceSyncConfigRequestT = Model::GetServiceSyncConfigRequest>
Model::GetServiceSyncConfigOutcomeCallable Aws::Proton::ProtonClient::GetServiceSyncConfigCallable ( const GetServiceSyncConfigRequestT &  request) const
inline

A Callable wrapper for GetServiceSyncConfig that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1442 of file ProtonClient.h.

◆ GetServiceTemplate()

virtual Model::GetServiceTemplateOutcome Aws::Proton::ProtonClient::GetServiceTemplate ( const Model::GetServiceTemplateRequest request) const
virtual

Get detailed data for a service template.

See Also:

AWS API Reference

◆ GetServiceTemplateAsync()

template<typename GetServiceTemplateRequestT = Model::GetServiceTemplateRequest>
void Aws::Proton::ProtonClient::GetServiceTemplateAsync ( const GetServiceTemplateRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetServiceTemplate that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1476 of file ProtonClient.h.

◆ GetServiceTemplateCallable()

template<typename GetServiceTemplateRequestT = Model::GetServiceTemplateRequest>
Model::GetServiceTemplateOutcomeCallable Aws::Proton::ProtonClient::GetServiceTemplateCallable ( const GetServiceTemplateRequestT &  request) const
inline

A Callable wrapper for GetServiceTemplate that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1467 of file ProtonClient.h.

◆ GetServiceTemplateVersion()

virtual Model::GetServiceTemplateVersionOutcome Aws::Proton::ProtonClient::GetServiceTemplateVersion ( const Model::GetServiceTemplateVersionRequest request) const
virtual

Get detailed data for a major or minor version of a service template.

See Also:

AWS API Reference

◆ GetServiceTemplateVersionAsync()

template<typename GetServiceTemplateVersionRequestT = Model::GetServiceTemplateVersionRequest>
void Aws::Proton::ProtonClient::GetServiceTemplateVersionAsync ( const GetServiceTemplateVersionRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetServiceTemplateVersion that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1502 of file ProtonClient.h.

◆ GetServiceTemplateVersionCallable()

template<typename GetServiceTemplateVersionRequestT = Model::GetServiceTemplateVersionRequest>
Model::GetServiceTemplateVersionOutcomeCallable Aws::Proton::ProtonClient::GetServiceTemplateVersionCallable ( const GetServiceTemplateVersionRequestT &  request) const
inline

A Callable wrapper for GetServiceTemplateVersion that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1493 of file ProtonClient.h.

◆ GetTemplateSyncConfig()

virtual Model::GetTemplateSyncConfigOutcome Aws::Proton::ProtonClient::GetTemplateSyncConfig ( const Model::GetTemplateSyncConfigRequest request) const
virtual

Get detail data for a template sync configuration.

See Also:


AWS API Reference

◆ GetTemplateSyncConfigAsync()

template<typename GetTemplateSyncConfigRequestT = Model::GetTemplateSyncConfigRequest>
void Aws::Proton::ProtonClient::GetTemplateSyncConfigAsync ( const GetTemplateSyncConfigRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetTemplateSyncConfig that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1528 of file ProtonClient.h.

◆ GetTemplateSyncConfigCallable()

template<typename GetTemplateSyncConfigRequestT = Model::GetTemplateSyncConfigRequest>
Model::GetTemplateSyncConfigOutcomeCallable Aws::Proton::ProtonClient::GetTemplateSyncConfigCallable ( const GetTemplateSyncConfigRequestT &  request) const
inline

A Callable wrapper for GetTemplateSyncConfig that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1519 of file ProtonClient.h.

◆ GetTemplateSyncStatus()

virtual Model::GetTemplateSyncStatusOutcome Aws::Proton::ProtonClient::GetTemplateSyncStatus ( const Model::GetTemplateSyncStatusRequest request) const
virtual

Get the status of a template sync.

See Also:

AWS API Reference

◆ GetTemplateSyncStatusAsync()

template<typename GetTemplateSyncStatusRequestT = Model::GetTemplateSyncStatusRequest>
void Aws::Proton::ProtonClient::GetTemplateSyncStatusAsync ( const GetTemplateSyncStatusRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for GetTemplateSyncStatus that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1553 of file ProtonClient.h.

◆ GetTemplateSyncStatusCallable()

template<typename GetTemplateSyncStatusRequestT = Model::GetTemplateSyncStatusRequest>
Model::GetTemplateSyncStatusOutcomeCallable Aws::Proton::ProtonClient::GetTemplateSyncStatusCallable ( const GetTemplateSyncStatusRequestT &  request) const
inline

A Callable wrapper for GetTemplateSyncStatus that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1544 of file ProtonClient.h.

◆ ListComponentOutputs()

virtual Model::ListComponentOutputsOutcome Aws::Proton::ProtonClient::ListComponentOutputs ( const Model::ListComponentOutputsRequest request) const
virtual

Get a list of component Infrastructure as Code (IaC) outputs.

For more information about components, see Proton components in the Proton User Guide.

See Also:

AWS API Reference

◆ ListComponentOutputsAsync()

template<typename ListComponentOutputsRequestT = Model::ListComponentOutputsRequest>
void Aws::Proton::ProtonClient::ListComponentOutputsAsync ( const ListComponentOutputsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListComponentOutputs that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1581 of file ProtonClient.h.

◆ ListComponentOutputsCallable()

template<typename ListComponentOutputsRequestT = Model::ListComponentOutputsRequest>
Model::ListComponentOutputsOutcomeCallable Aws::Proton::ProtonClient::ListComponentOutputsCallable ( const ListComponentOutputsRequestT &  request) const
inline

A Callable wrapper for ListComponentOutputs that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1572 of file ProtonClient.h.

◆ ListComponentProvisionedResources()

virtual Model::ListComponentProvisionedResourcesOutcome Aws::Proton::ProtonClient::ListComponentProvisionedResources ( const Model::ListComponentProvisionedResourcesRequest request) const
virtual

List provisioned resources for a component with details.

For more information about components, see Proton components in the Proton User Guide.

See Also:

AWS API Reference

◆ ListComponentProvisionedResourcesAsync()

template<typename ListComponentProvisionedResourcesRequestT = Model::ListComponentProvisionedResourcesRequest>
void Aws::Proton::ProtonClient::ListComponentProvisionedResourcesAsync ( const ListComponentProvisionedResourcesRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListComponentProvisionedResources that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1609 of file ProtonClient.h.

◆ ListComponentProvisionedResourcesCallable()

template<typename ListComponentProvisionedResourcesRequestT = Model::ListComponentProvisionedResourcesRequest>
Model::ListComponentProvisionedResourcesOutcomeCallable Aws::Proton::ProtonClient::ListComponentProvisionedResourcesCallable ( const ListComponentProvisionedResourcesRequestT &  request) const
inline

A Callable wrapper for ListComponentProvisionedResources that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1600 of file ProtonClient.h.

◆ ListComponents()

virtual Model::ListComponentsOutcome Aws::Proton::ProtonClient::ListComponents ( const Model::ListComponentsRequest request = {}) const
virtual

List components with summary data. You can filter the result list by environment, service, or a single service instance.

For more information about components, see Proton components in the Proton User Guide.

See Also:

AWS API Reference

◆ ListComponentsAsync()

template<typename ListComponentsRequestT = Model::ListComponentsRequest>
void Aws::Proton::ProtonClient::ListComponentsAsync ( const ListComponentsResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const ListComponentsRequestT &  request = {} 
) const
inline

An Async wrapper for ListComponents that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1638 of file ProtonClient.h.

◆ ListComponentsCallable()

template<typename ListComponentsRequestT = Model::ListComponentsRequest>
Model::ListComponentsOutcomeCallable Aws::Proton::ProtonClient::ListComponentsCallable ( const ListComponentsRequestT &  request = {}) const
inline

A Callable wrapper for ListComponents that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1629 of file ProtonClient.h.

◆ ListDeployments()

virtual Model::ListDeploymentsOutcome Aws::Proton::ProtonClient::ListDeployments ( const Model::ListDeploymentsRequest request = {}) const
virtual

List deployments. You can filter the result list by environment, service, or a single service instance.

See Also:

AWS API Reference

◆ ListDeploymentsAsync()

template<typename ListDeploymentsRequestT = Model::ListDeploymentsRequest>
void Aws::Proton::ProtonClient::ListDeploymentsAsync ( const ListDeploymentsResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const ListDeploymentsRequestT &  request = {} 
) const
inline

An Async wrapper for ListDeployments that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1664 of file ProtonClient.h.

◆ ListDeploymentsCallable()

template<typename ListDeploymentsRequestT = Model::ListDeploymentsRequest>
Model::ListDeploymentsOutcomeCallable Aws::Proton::ProtonClient::ListDeploymentsCallable ( const ListDeploymentsRequestT &  request = {}) const
inline

A Callable wrapper for ListDeployments that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1655 of file ProtonClient.h.

◆ ListEnvironmentAccountConnections()

virtual Model::ListEnvironmentAccountConnectionsOutcome Aws::Proton::ProtonClient::ListEnvironmentAccountConnections ( const Model::ListEnvironmentAccountConnectionsRequest request) const
virtual

View a list of environment account connections.

For more information, see Environment account connections in the Proton User guide.

See Also:

AWS API Reference

◆ ListEnvironmentAccountConnectionsAsync()

template<typename ListEnvironmentAccountConnectionsRequestT = Model::ListEnvironmentAccountConnectionsRequest>
void Aws::Proton::ProtonClient::ListEnvironmentAccountConnectionsAsync ( const ListEnvironmentAccountConnectionsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListEnvironmentAccountConnections that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1693 of file ProtonClient.h.

◆ ListEnvironmentAccountConnectionsCallable()

template<typename ListEnvironmentAccountConnectionsRequestT = Model::ListEnvironmentAccountConnectionsRequest>
Model::ListEnvironmentAccountConnectionsOutcomeCallable Aws::Proton::ProtonClient::ListEnvironmentAccountConnectionsCallable ( const ListEnvironmentAccountConnectionsRequestT &  request) const
inline

A Callable wrapper for ListEnvironmentAccountConnections that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1684 of file ProtonClient.h.

◆ ListEnvironmentOutputs()

virtual Model::ListEnvironmentOutputsOutcome Aws::Proton::ProtonClient::ListEnvironmentOutputs ( const Model::ListEnvironmentOutputsRequest request) const
virtual

List the infrastructure as code outputs for your environment.

See Also:

AWS API Reference

◆ ListEnvironmentOutputsAsync()

template<typename ListEnvironmentOutputsRequestT = Model::ListEnvironmentOutputsRequest>
void Aws::Proton::ProtonClient::ListEnvironmentOutputsAsync ( const ListEnvironmentOutputsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListEnvironmentOutputs that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1719 of file ProtonClient.h.

◆ ListEnvironmentOutputsCallable()

template<typename ListEnvironmentOutputsRequestT = Model::ListEnvironmentOutputsRequest>
Model::ListEnvironmentOutputsOutcomeCallable Aws::Proton::ProtonClient::ListEnvironmentOutputsCallable ( const ListEnvironmentOutputsRequestT &  request) const
inline

A Callable wrapper for ListEnvironmentOutputs that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1710 of file ProtonClient.h.

◆ ListEnvironmentProvisionedResources()

virtual Model::ListEnvironmentProvisionedResourcesOutcome Aws::Proton::ProtonClient::ListEnvironmentProvisionedResources ( const Model::ListEnvironmentProvisionedResourcesRequest request) const
virtual

List the provisioned resources for your environment.

See Also:

AWS API Reference

◆ ListEnvironmentProvisionedResourcesAsync()

template<typename ListEnvironmentProvisionedResourcesRequestT = Model::ListEnvironmentProvisionedResourcesRequest>
void Aws::Proton::ProtonClient::ListEnvironmentProvisionedResourcesAsync ( const ListEnvironmentProvisionedResourcesRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListEnvironmentProvisionedResources that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1745 of file ProtonClient.h.

◆ ListEnvironmentProvisionedResourcesCallable()

template<typename ListEnvironmentProvisionedResourcesRequestT = Model::ListEnvironmentProvisionedResourcesRequest>
Model::ListEnvironmentProvisionedResourcesOutcomeCallable Aws::Proton::ProtonClient::ListEnvironmentProvisionedResourcesCallable ( const ListEnvironmentProvisionedResourcesRequestT &  request) const
inline

A Callable wrapper for ListEnvironmentProvisionedResources that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1736 of file ProtonClient.h.

◆ ListEnvironments()

virtual Model::ListEnvironmentsOutcome Aws::Proton::ProtonClient::ListEnvironments ( const Model::ListEnvironmentsRequest request = {}) const
virtual

List environments with detail data summaries.

See Also:

AWS API Reference

◆ ListEnvironmentsAsync()

template<typename ListEnvironmentsRequestT = Model::ListEnvironmentsRequest>
void Aws::Proton::ProtonClient::ListEnvironmentsAsync ( const ListEnvironmentsResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const ListEnvironmentsRequestT &  request = {} 
) const
inline

An Async wrapper for ListEnvironments that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1821 of file ProtonClient.h.

◆ ListEnvironmentsCallable()

template<typename ListEnvironmentsRequestT = Model::ListEnvironmentsRequest>
Model::ListEnvironmentsOutcomeCallable Aws::Proton::ProtonClient::ListEnvironmentsCallable ( const ListEnvironmentsRequestT &  request = {}) const
inline

A Callable wrapper for ListEnvironments that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1812 of file ProtonClient.h.

◆ ListEnvironmentTemplates()

virtual Model::ListEnvironmentTemplatesOutcome Aws::Proton::ProtonClient::ListEnvironmentTemplates ( const Model::ListEnvironmentTemplatesRequest request = {}) const
virtual

List environment templates.

See Also:

AWS API Reference

◆ ListEnvironmentTemplatesAsync()

template<typename ListEnvironmentTemplatesRequestT = Model::ListEnvironmentTemplatesRequest>
void Aws::Proton::ProtonClient::ListEnvironmentTemplatesAsync ( const ListEnvironmentTemplatesResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const ListEnvironmentTemplatesRequestT &  request = {} 
) const
inline

An Async wrapper for ListEnvironmentTemplates that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1796 of file ProtonClient.h.

◆ ListEnvironmentTemplatesCallable()

template<typename ListEnvironmentTemplatesRequestT = Model::ListEnvironmentTemplatesRequest>
Model::ListEnvironmentTemplatesOutcomeCallable Aws::Proton::ProtonClient::ListEnvironmentTemplatesCallable ( const ListEnvironmentTemplatesRequestT &  request = {}) const
inline

A Callable wrapper for ListEnvironmentTemplates that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1787 of file ProtonClient.h.

◆ ListEnvironmentTemplateVersions()

virtual Model::ListEnvironmentTemplateVersionsOutcome Aws::Proton::ProtonClient::ListEnvironmentTemplateVersions ( const Model::ListEnvironmentTemplateVersionsRequest request) const
virtual

List major or minor versions of an environment template with detail data.

See Also:

AWS API Reference

◆ ListEnvironmentTemplateVersionsAsync()

template<typename ListEnvironmentTemplateVersionsRequestT = Model::ListEnvironmentTemplateVersionsRequest>
void Aws::Proton::ProtonClient::ListEnvironmentTemplateVersionsAsync ( const ListEnvironmentTemplateVersionsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListEnvironmentTemplateVersions that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1771 of file ProtonClient.h.

◆ ListEnvironmentTemplateVersionsCallable()

template<typename ListEnvironmentTemplateVersionsRequestT = Model::ListEnvironmentTemplateVersionsRequest>
Model::ListEnvironmentTemplateVersionsOutcomeCallable Aws::Proton::ProtonClient::ListEnvironmentTemplateVersionsCallable ( const ListEnvironmentTemplateVersionsRequestT &  request) const
inline

A Callable wrapper for ListEnvironmentTemplateVersions that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1762 of file ProtonClient.h.

◆ ListRepositories()

virtual Model::ListRepositoriesOutcome Aws::Proton::ProtonClient::ListRepositories ( const Model::ListRepositoriesRequest request = {}) const
virtual

List linked repositories with detail data.

See Also:

AWS API Reference

◆ ListRepositoriesAsync()

template<typename ListRepositoriesRequestT = Model::ListRepositoriesRequest>
void Aws::Proton::ProtonClient::ListRepositoriesAsync ( const ListRepositoriesResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const ListRepositoriesRequestT &  request = {} 
) const
inline

An Async wrapper for ListRepositories that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1846 of file ProtonClient.h.

◆ ListRepositoriesCallable()

template<typename ListRepositoriesRequestT = Model::ListRepositoriesRequest>
Model::ListRepositoriesOutcomeCallable Aws::Proton::ProtonClient::ListRepositoriesCallable ( const ListRepositoriesRequestT &  request = {}) const
inline

A Callable wrapper for ListRepositories that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1837 of file ProtonClient.h.

◆ ListRepositorySyncDefinitions()

virtual Model::ListRepositorySyncDefinitionsOutcome Aws::Proton::ProtonClient::ListRepositorySyncDefinitions ( const Model::ListRepositorySyncDefinitionsRequest request) const
virtual

List repository sync definitions with detail data.

See Also:


AWS API Reference

◆ ListRepositorySyncDefinitionsAsync()

template<typename ListRepositorySyncDefinitionsRequestT = Model::ListRepositorySyncDefinitionsRequest>
void Aws::Proton::ProtonClient::ListRepositorySyncDefinitionsAsync ( const ListRepositorySyncDefinitionsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListRepositorySyncDefinitions that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1872 of file ProtonClient.h.

◆ ListRepositorySyncDefinitionsCallable()

template<typename ListRepositorySyncDefinitionsRequestT = Model::ListRepositorySyncDefinitionsRequest>
Model::ListRepositorySyncDefinitionsOutcomeCallable Aws::Proton::ProtonClient::ListRepositorySyncDefinitionsCallable ( const ListRepositorySyncDefinitionsRequestT &  request) const
inline

A Callable wrapper for ListRepositorySyncDefinitions that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1863 of file ProtonClient.h.

◆ ListServiceInstanceOutputs()

virtual Model::ListServiceInstanceOutputsOutcome Aws::Proton::ProtonClient::ListServiceInstanceOutputs ( const Model::ListServiceInstanceOutputsRequest request) const
virtual

Get a list service of instance Infrastructure as Code (IaC) outputs.

See Also:

AWS API Reference

◆ ListServiceInstanceOutputsAsync()

template<typename ListServiceInstanceOutputsRequestT = Model::ListServiceInstanceOutputsRequest>
void Aws::Proton::ProtonClient::ListServiceInstanceOutputsAsync ( const ListServiceInstanceOutputsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListServiceInstanceOutputs that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1898 of file ProtonClient.h.

◆ ListServiceInstanceOutputsCallable()

template<typename ListServiceInstanceOutputsRequestT = Model::ListServiceInstanceOutputsRequest>
Model::ListServiceInstanceOutputsOutcomeCallable Aws::Proton::ProtonClient::ListServiceInstanceOutputsCallable ( const ListServiceInstanceOutputsRequestT &  request) const
inline

A Callable wrapper for ListServiceInstanceOutputs that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1889 of file ProtonClient.h.

◆ ListServiceInstanceProvisionedResources()

virtual Model::ListServiceInstanceProvisionedResourcesOutcome Aws::Proton::ProtonClient::ListServiceInstanceProvisionedResources ( const Model::ListServiceInstanceProvisionedResourcesRequest request) const
virtual

List provisioned resources for a service instance with details.

See Also:

AWS API Reference

◆ ListServiceInstanceProvisionedResourcesAsync()

template<typename ListServiceInstanceProvisionedResourcesRequestT = Model::ListServiceInstanceProvisionedResourcesRequest>
void Aws::Proton::ProtonClient::ListServiceInstanceProvisionedResourcesAsync ( const ListServiceInstanceProvisionedResourcesRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListServiceInstanceProvisionedResources that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1924 of file ProtonClient.h.

◆ ListServiceInstanceProvisionedResourcesCallable()

template<typename ListServiceInstanceProvisionedResourcesRequestT = Model::ListServiceInstanceProvisionedResourcesRequest>
Model::ListServiceInstanceProvisionedResourcesOutcomeCallable Aws::Proton::ProtonClient::ListServiceInstanceProvisionedResourcesCallable ( const ListServiceInstanceProvisionedResourcesRequestT &  request) const
inline

A Callable wrapper for ListServiceInstanceProvisionedResources that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1915 of file ProtonClient.h.

◆ ListServiceInstances()

virtual Model::ListServiceInstancesOutcome Aws::Proton::ProtonClient::ListServiceInstances ( const Model::ListServiceInstancesRequest request = {}) const
virtual

List service instances with summary data. This action lists service instances of all services in the Amazon Web Services account.

See Also:


AWS API Reference

◆ ListServiceInstancesAsync()

template<typename ListServiceInstancesRequestT = Model::ListServiceInstancesRequest>
void Aws::Proton::ProtonClient::ListServiceInstancesAsync ( const ListServiceInstancesResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const ListServiceInstancesRequestT &  request = {} 
) const
inline

An Async wrapper for ListServiceInstances that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1951 of file ProtonClient.h.

◆ ListServiceInstancesCallable()

template<typename ListServiceInstancesRequestT = Model::ListServiceInstancesRequest>
Model::ListServiceInstancesOutcomeCallable Aws::Proton::ProtonClient::ListServiceInstancesCallable ( const ListServiceInstancesRequestT &  request = {}) const
inline

A Callable wrapper for ListServiceInstances that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1942 of file ProtonClient.h.

◆ ListServicePipelineOutputs()

virtual Model::ListServicePipelineOutputsOutcome Aws::Proton::ProtonClient::ListServicePipelineOutputs ( const Model::ListServicePipelineOutputsRequest request) const
virtual

Get a list of service pipeline Infrastructure as Code (IaC) outputs.

See Also:

AWS API Reference

◆ ListServicePipelineOutputsAsync()

template<typename ListServicePipelineOutputsRequestT = Model::ListServicePipelineOutputsRequest>
void Aws::Proton::ProtonClient::ListServicePipelineOutputsAsync ( const ListServicePipelineOutputsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListServicePipelineOutputs that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 1977 of file ProtonClient.h.

◆ ListServicePipelineOutputsCallable()

template<typename ListServicePipelineOutputsRequestT = Model::ListServicePipelineOutputsRequest>
Model::ListServicePipelineOutputsOutcomeCallable Aws::Proton::ProtonClient::ListServicePipelineOutputsCallable ( const ListServicePipelineOutputsRequestT &  request) const
inline

A Callable wrapper for ListServicePipelineOutputs that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1968 of file ProtonClient.h.

◆ ListServicePipelineProvisionedResources()

virtual Model::ListServicePipelineProvisionedResourcesOutcome Aws::Proton::ProtonClient::ListServicePipelineProvisionedResources ( const Model::ListServicePipelineProvisionedResourcesRequest request) const
virtual

List provisioned resources for a service and pipeline with details.

See Also:

AWS API Reference

◆ ListServicePipelineProvisionedResourcesAsync()

template<typename ListServicePipelineProvisionedResourcesRequestT = Model::ListServicePipelineProvisionedResourcesRequest>
void Aws::Proton::ProtonClient::ListServicePipelineProvisionedResourcesAsync ( const ListServicePipelineProvisionedResourcesRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListServicePipelineProvisionedResources that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2003 of file ProtonClient.h.

◆ ListServicePipelineProvisionedResourcesCallable()

template<typename ListServicePipelineProvisionedResourcesRequestT = Model::ListServicePipelineProvisionedResourcesRequest>
Model::ListServicePipelineProvisionedResourcesOutcomeCallable Aws::Proton::ProtonClient::ListServicePipelineProvisionedResourcesCallable ( const ListServicePipelineProvisionedResourcesRequestT &  request) const
inline

A Callable wrapper for ListServicePipelineProvisionedResources that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 1994 of file ProtonClient.h.

◆ ListServices()

virtual Model::ListServicesOutcome Aws::Proton::ProtonClient::ListServices ( const Model::ListServicesRequest request = {}) const
virtual

List services with summaries of detail data.

See Also:

AWS API Reference

◆ ListServicesAsync()

template<typename ListServicesRequestT = Model::ListServicesRequest>
void Aws::Proton::ProtonClient::ListServicesAsync ( const ListServicesResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const ListServicesRequestT &  request = {} 
) const
inline

An Async wrapper for ListServices that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2079 of file ProtonClient.h.

◆ ListServicesCallable()

template<typename ListServicesRequestT = Model::ListServicesRequest>
Model::ListServicesOutcomeCallable Aws::Proton::ProtonClient::ListServicesCallable ( const ListServicesRequestT &  request = {}) const
inline

A Callable wrapper for ListServices that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2070 of file ProtonClient.h.

◆ ListServiceTemplates()

virtual Model::ListServiceTemplatesOutcome Aws::Proton::ProtonClient::ListServiceTemplates ( const Model::ListServiceTemplatesRequest request = {}) const
virtual

List service templates with detail data.

See Also:

AWS API Reference

◆ ListServiceTemplatesAsync()

template<typename ListServiceTemplatesRequestT = Model::ListServiceTemplatesRequest>
void Aws::Proton::ProtonClient::ListServiceTemplatesAsync ( const ListServiceTemplatesResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const ListServiceTemplatesRequestT &  request = {} 
) const
inline

An Async wrapper for ListServiceTemplates that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2054 of file ProtonClient.h.

◆ ListServiceTemplatesCallable()

template<typename ListServiceTemplatesRequestT = Model::ListServiceTemplatesRequest>
Model::ListServiceTemplatesOutcomeCallable Aws::Proton::ProtonClient::ListServiceTemplatesCallable ( const ListServiceTemplatesRequestT &  request = {}) const
inline

A Callable wrapper for ListServiceTemplates that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2045 of file ProtonClient.h.

◆ ListServiceTemplateVersions()

virtual Model::ListServiceTemplateVersionsOutcome Aws::Proton::ProtonClient::ListServiceTemplateVersions ( const Model::ListServiceTemplateVersionsRequest request) const
virtual

List major or minor versions of a service template with detail data.

See Also:

AWS API Reference

◆ ListServiceTemplateVersionsAsync()

template<typename ListServiceTemplateVersionsRequestT = Model::ListServiceTemplateVersionsRequest>
void Aws::Proton::ProtonClient::ListServiceTemplateVersionsAsync ( const ListServiceTemplateVersionsRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListServiceTemplateVersions that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2029 of file ProtonClient.h.

◆ ListServiceTemplateVersionsCallable()

template<typename ListServiceTemplateVersionsRequestT = Model::ListServiceTemplateVersionsRequest>
Model::ListServiceTemplateVersionsOutcomeCallable Aws::Proton::ProtonClient::ListServiceTemplateVersionsCallable ( const ListServiceTemplateVersionsRequestT &  request) const
inline

A Callable wrapper for ListServiceTemplateVersions that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2020 of file ProtonClient.h.

◆ ListTagsForResource()

virtual Model::ListTagsForResourceOutcome Aws::Proton::ProtonClient::ListTagsForResource ( const Model::ListTagsForResourceRequest request) const
virtual

List tags for a resource. For more information, see Proton resources and tagging in the Proton User Guide.

See Also:

AWS API Reference

◆ ListTagsForResourceAsync()

template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
void Aws::Proton::ProtonClient::ListTagsForResourceAsync ( const ListTagsForResourceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2107 of file ProtonClient.h.

◆ ListTagsForResourceCallable()

template<typename ListTagsForResourceRequestT = Model::ListTagsForResourceRequest>
Model::ListTagsForResourceOutcomeCallable Aws::Proton::ProtonClient::ListTagsForResourceCallable ( const ListTagsForResourceRequestT &  request) const
inline

A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2098 of file ProtonClient.h.

◆ NotifyResourceDeploymentStatusChange()

virtual Model::NotifyResourceDeploymentStatusChangeOutcome Aws::Proton::ProtonClient::NotifyResourceDeploymentStatusChange ( const Model::NotifyResourceDeploymentStatusChangeRequest request) const
virtual

Notify Proton of status changes to a provisioned resource when you use self-managed provisioning.

For more information, see Self-managed provisioning in the Proton User Guide.

See Also:

AWS API Reference

◆ NotifyResourceDeploymentStatusChangeAsync()

template<typename NotifyResourceDeploymentStatusChangeRequestT = Model::NotifyResourceDeploymentStatusChangeRequest>
void Aws::Proton::ProtonClient::NotifyResourceDeploymentStatusChangeAsync ( const NotifyResourceDeploymentStatusChangeRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for NotifyResourceDeploymentStatusChange that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2135 of file ProtonClient.h.

◆ NotifyResourceDeploymentStatusChangeCallable()

template<typename NotifyResourceDeploymentStatusChangeRequestT = Model::NotifyResourceDeploymentStatusChangeRequest>
Model::NotifyResourceDeploymentStatusChangeOutcomeCallable Aws::Proton::ProtonClient::NotifyResourceDeploymentStatusChangeCallable ( const NotifyResourceDeploymentStatusChangeRequestT &  request) const
inline

A Callable wrapper for NotifyResourceDeploymentStatusChange that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2126 of file ProtonClient.h.

◆ OverrideEndpoint()

void Aws::Proton::ProtonClient::OverrideEndpoint ( const Aws::String endpoint)

◆ RejectEnvironmentAccountConnection()

virtual Model::RejectEnvironmentAccountConnectionOutcome Aws::Proton::ProtonClient::RejectEnvironmentAccountConnection ( const Model::RejectEnvironmentAccountConnectionRequest request) const
virtual

In a management account, reject an environment account connection from another environment account.

After you reject an environment account connection request, you can't accept or use the rejected environment account connection.

You can’t reject an environment account connection that's connected to an environment.

For more information, see Environment account connections in the Proton User guide.

See Also:

AWS API Reference

◆ RejectEnvironmentAccountConnectionAsync()

template<typename RejectEnvironmentAccountConnectionRequestT = Model::RejectEnvironmentAccountConnectionRequest>
void Aws::Proton::ProtonClient::RejectEnvironmentAccountConnectionAsync ( const RejectEnvironmentAccountConnectionRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for RejectEnvironmentAccountConnection that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2168 of file ProtonClient.h.

◆ RejectEnvironmentAccountConnectionCallable()

template<typename RejectEnvironmentAccountConnectionRequestT = Model::RejectEnvironmentAccountConnectionRequest>
Model::RejectEnvironmentAccountConnectionOutcomeCallable Aws::Proton::ProtonClient::RejectEnvironmentAccountConnectionCallable ( const RejectEnvironmentAccountConnectionRequestT &  request) const
inline

A Callable wrapper for RejectEnvironmentAccountConnection that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2159 of file ProtonClient.h.

◆ TagResource()

virtual Model::TagResourceOutcome Aws::Proton::ProtonClient::TagResource ( const Model::TagResourceRequest request) const
virtual

Tag a resource. A tag is a key-value pair of metadata that you associate with an Proton resource.

For more information, see Proton resources and tagging in the Proton User Guide.

See Also:

AWS API Reference

◆ TagResourceAsync()

template<typename TagResourceRequestT = Model::TagResourceRequest>
void Aws::Proton::ProtonClient::TagResourceAsync ( const TagResourceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2197 of file ProtonClient.h.

◆ TagResourceCallable()

template<typename TagResourceRequestT = Model::TagResourceRequest>
Model::TagResourceOutcomeCallable Aws::Proton::ProtonClient::TagResourceCallable ( const TagResourceRequestT &  request) const
inline

A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2188 of file ProtonClient.h.

◆ UntagResource()

virtual Model::UntagResourceOutcome Aws::Proton::ProtonClient::UntagResource ( const Model::UntagResourceRequest request) const
virtual

Remove a customer tag from a resource. A tag is a key-value pair of metadata associated with an Proton resource.

For more information, see Proton resources and tagging in the Proton User Guide.

See Also:

AWS API Reference

◆ UntagResourceAsync()

template<typename UntagResourceRequestT = Model::UntagResourceRequest>
void Aws::Proton::ProtonClient::UntagResourceAsync ( const UntagResourceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2226 of file ProtonClient.h.

◆ UntagResourceCallable()

template<typename UntagResourceRequestT = Model::UntagResourceRequest>
Model::UntagResourceOutcomeCallable Aws::Proton::ProtonClient::UntagResourceCallable ( const UntagResourceRequestT &  request) const
inline

A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2217 of file ProtonClient.h.

◆ UpdateAccountSettings()

virtual Model::UpdateAccountSettingsOutcome Aws::Proton::ProtonClient::UpdateAccountSettings ( const Model::UpdateAccountSettingsRequest request = {}) const
virtual

Update Proton settings that are used for multiple services in the Amazon Web Services account.

See Also:

AWS API Reference

◆ UpdateAccountSettingsAsync()

template<typename UpdateAccountSettingsRequestT = Model::UpdateAccountSettingsRequest>
void Aws::Proton::ProtonClient::UpdateAccountSettingsAsync ( const UpdateAccountSettingsResponseReceivedHandler handler,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr,
const UpdateAccountSettingsRequestT &  request = {} 
) const
inline

An Async wrapper for UpdateAccountSettings that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2252 of file ProtonClient.h.

◆ UpdateAccountSettingsCallable()

template<typename UpdateAccountSettingsRequestT = Model::UpdateAccountSettingsRequest>
Model::UpdateAccountSettingsOutcomeCallable Aws::Proton::ProtonClient::UpdateAccountSettingsCallable ( const UpdateAccountSettingsRequestT &  request = {}) const
inline

A Callable wrapper for UpdateAccountSettings that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2243 of file ProtonClient.h.

◆ UpdateComponent()

virtual Model::UpdateComponentOutcome Aws::Proton::ProtonClient::UpdateComponent ( const Model::UpdateComponentRequest request) const
virtual

Update a component.

There are a few modes for updating a component. The deploymentType field defines the mode.

You can't update a component while its deployment status, or the deployment status of a service instance attached to it, is IN_PROGRESS.

For more information about components, see Proton components in the Proton User Guide.

See Also:

AWS API Reference

◆ UpdateComponentAsync()

template<typename UpdateComponentRequestT = Model::UpdateComponentRequest>
void Aws::Proton::ProtonClient::UpdateComponentAsync ( const UpdateComponentRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateComponent that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2283 of file ProtonClient.h.

◆ UpdateComponentCallable()

template<typename UpdateComponentRequestT = Model::UpdateComponentRequest>
Model::UpdateComponentOutcomeCallable Aws::Proton::ProtonClient::UpdateComponentCallable ( const UpdateComponentRequestT &  request) const
inline

A Callable wrapper for UpdateComponent that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2274 of file ProtonClient.h.

◆ UpdateEnvironment()

virtual Model::UpdateEnvironmentOutcome Aws::Proton::ProtonClient::UpdateEnvironment ( const Model::UpdateEnvironmentRequest request) const
virtual

Update an environment.

If the environment is associated with an environment account connection, don't update or include the protonServiceRoleArn and provisioningRepository parameter to update or connect to an environment account connection.

You can only update to a new environment account connection if that connection was created in the same environment account that the current environment account connection was created in. The account connection must also be associated with the current environment.

If the environment isn't associated with an environment account connection, don't update or include the environmentAccountConnectionId parameter. You can't update or connect the environment to an environment account connection if it isn't already associated with an environment connection.

You can update either the environmentAccountConnectionId or protonServiceRoleArn parameter and value. You can’t update both.

If the environment was configured for Amazon Web Services-managed provisioning, omit the provisioningRepository parameter.

If the environment was configured for self-managed provisioning, specify the provisioningRepository parameter and omit the protonServiceRoleArn and environmentAccountConnectionId parameters.

For more information, see Environments and Provisioning methods in the Proton User Guide.

There are four modes for updating an environment. The deploymentType field defines the mode.

NONE

In this mode, a deployment doesn't occur. Only the requested metadata parameters are updated.

CURRENT_VERSION

In this mode, the environment is deployed and updated with the new spec that you provide. Only requested parameters are updated. Don’t include minor or major version parameters when you use this deployment-type.

MINOR_VERSION

In this mode, the environment is deployed and updated with the published, recommended (latest) minor version of the current major version in use, by default. You can also specify a different minor version of the current major version in use.

MAJOR_VERSION

In this mode, the environment is deployed and updated with the published, recommended (latest) major and minor version of the current template, by default. You can also specify a different major version that's higher than the major version in use and a minor version.

See Also:

AWS API Reference

◆ UpdateEnvironmentAccountConnection()

virtual Model::UpdateEnvironmentAccountConnectionOutcome Aws::Proton::ProtonClient::UpdateEnvironmentAccountConnection ( const Model::UpdateEnvironmentAccountConnectionRequest request) const
virtual

In an environment account, update an environment account connection to use a new IAM role.

For more information, see Environment account connections in the Proton User guide.

See Also:

AWS API Reference

◆ UpdateEnvironmentAccountConnectionAsync()

template<typename UpdateEnvironmentAccountConnectionRequestT = Model::UpdateEnvironmentAccountConnectionRequest>
void Aws::Proton::ProtonClient::UpdateEnvironmentAccountConnectionAsync ( const UpdateEnvironmentAccountConnectionRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateEnvironmentAccountConnection that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2377 of file ProtonClient.h.

◆ UpdateEnvironmentAccountConnectionCallable()

template<typename UpdateEnvironmentAccountConnectionRequestT = Model::UpdateEnvironmentAccountConnectionRequest>
Model::UpdateEnvironmentAccountConnectionOutcomeCallable Aws::Proton::ProtonClient::UpdateEnvironmentAccountConnectionCallable ( const UpdateEnvironmentAccountConnectionRequestT &  request) const
inline

A Callable wrapper for UpdateEnvironmentAccountConnection that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2368 of file ProtonClient.h.

◆ UpdateEnvironmentAsync()

template<typename UpdateEnvironmentRequestT = Model::UpdateEnvironmentRequest>
void Aws::Proton::ProtonClient::UpdateEnvironmentAsync ( const UpdateEnvironmentRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateEnvironment that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2348 of file ProtonClient.h.

◆ UpdateEnvironmentCallable()

template<typename UpdateEnvironmentRequestT = Model::UpdateEnvironmentRequest>
Model::UpdateEnvironmentOutcomeCallable Aws::Proton::ProtonClient::UpdateEnvironmentCallable ( const UpdateEnvironmentRequestT &  request) const
inline

A Callable wrapper for UpdateEnvironment that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2339 of file ProtonClient.h.

◆ UpdateEnvironmentTemplate()

virtual Model::UpdateEnvironmentTemplateOutcome Aws::Proton::ProtonClient::UpdateEnvironmentTemplate ( const Model::UpdateEnvironmentTemplateRequest request) const
virtual

Update an environment template.

See Also:

AWS API Reference

◆ UpdateEnvironmentTemplateAsync()

template<typename UpdateEnvironmentTemplateRequestT = Model::UpdateEnvironmentTemplateRequest>
void Aws::Proton::ProtonClient::UpdateEnvironmentTemplateAsync ( const UpdateEnvironmentTemplateRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateEnvironmentTemplate that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2402 of file ProtonClient.h.

◆ UpdateEnvironmentTemplateCallable()

template<typename UpdateEnvironmentTemplateRequestT = Model::UpdateEnvironmentTemplateRequest>
Model::UpdateEnvironmentTemplateOutcomeCallable Aws::Proton::ProtonClient::UpdateEnvironmentTemplateCallable ( const UpdateEnvironmentTemplateRequestT &  request) const
inline

A Callable wrapper for UpdateEnvironmentTemplate that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2393 of file ProtonClient.h.

◆ UpdateEnvironmentTemplateVersion()

virtual Model::UpdateEnvironmentTemplateVersionOutcome Aws::Proton::ProtonClient::UpdateEnvironmentTemplateVersion ( const Model::UpdateEnvironmentTemplateVersionRequest request) const
virtual

Update a major or minor version of an environment template.

See Also:

AWS API Reference

◆ UpdateEnvironmentTemplateVersionAsync()

template<typename UpdateEnvironmentTemplateVersionRequestT = Model::UpdateEnvironmentTemplateVersionRequest>
void Aws::Proton::ProtonClient::UpdateEnvironmentTemplateVersionAsync ( const UpdateEnvironmentTemplateVersionRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateEnvironmentTemplateVersion that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2428 of file ProtonClient.h.

◆ UpdateEnvironmentTemplateVersionCallable()

template<typename UpdateEnvironmentTemplateVersionRequestT = Model::UpdateEnvironmentTemplateVersionRequest>
Model::UpdateEnvironmentTemplateVersionOutcomeCallable Aws::Proton::ProtonClient::UpdateEnvironmentTemplateVersionCallable ( const UpdateEnvironmentTemplateVersionRequestT &  request) const
inline

A Callable wrapper for UpdateEnvironmentTemplateVersion that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2419 of file ProtonClient.h.

◆ UpdateService()

virtual Model::UpdateServiceOutcome Aws::Proton::ProtonClient::UpdateService ( const Model::UpdateServiceRequest request) const
virtual

Edit a service description or use a spec to add and delete service instances.

Existing service instances and the service pipeline can't be edited using this API. They can only be deleted.

Use the description parameter to modify the description.

Edit the spec parameter to add or delete instances.

You can't delete a service instance (remove it from the spec) if it has an attached component.

For more information about components, see Proton components in the Proton User Guide.

See Also:

AWS API Reference

◆ UpdateServiceAsync()

template<typename UpdateServiceRequestT = Model::UpdateServiceRequest>
void Aws::Proton::ProtonClient::UpdateServiceAsync ( const UpdateServiceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateService that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2462 of file ProtonClient.h.

◆ UpdateServiceCallable()

template<typename UpdateServiceRequestT = Model::UpdateServiceRequest>
Model::UpdateServiceOutcomeCallable Aws::Proton::ProtonClient::UpdateServiceCallable ( const UpdateServiceRequestT &  request) const
inline

A Callable wrapper for UpdateService that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2453 of file ProtonClient.h.

◆ UpdateServiceInstance()

virtual Model::UpdateServiceInstanceOutcome Aws::Proton::ProtonClient::UpdateServiceInstance ( const Model::UpdateServiceInstanceRequest request) const
virtual

Update a service instance.

There are a few modes for updating a service instance. The deploymentType field defines the mode.

You can't update a service instance while its deployment status, or the deployment status of a component attached to it, is IN_PROGRESS.

For more information about components, see Proton components in the Proton User Guide.

See Also:

AWS API Reference

◆ UpdateServiceInstanceAsync()

template<typename UpdateServiceInstanceRequestT = Model::UpdateServiceInstanceRequest>
void Aws::Proton::ProtonClient::UpdateServiceInstanceAsync ( const UpdateServiceInstanceRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateServiceInstance that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2494 of file ProtonClient.h.

◆ UpdateServiceInstanceCallable()

template<typename UpdateServiceInstanceRequestT = Model::UpdateServiceInstanceRequest>
Model::UpdateServiceInstanceOutcomeCallable Aws::Proton::ProtonClient::UpdateServiceInstanceCallable ( const UpdateServiceInstanceRequestT &  request) const
inline

A Callable wrapper for UpdateServiceInstance that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2485 of file ProtonClient.h.

◆ UpdateServicePipeline()

virtual Model::UpdateServicePipelineOutcome Aws::Proton::ProtonClient::UpdateServicePipeline ( const Model::UpdateServicePipelineRequest request) const
virtual

Update the service pipeline.

There are four modes for updating a service pipeline. The deploymentType field defines the mode.

NONE

In this mode, a deployment doesn't occur. Only the requested metadata parameters are updated.

CURRENT_VERSION

In this mode, the service pipeline is deployed and updated with the new spec that you provide. Only requested parameters are updated. Don’t include major or minor version parameters when you use this deployment-type.

MINOR_VERSION

In this mode, the service pipeline is deployed and updated with the published, recommended (latest) minor version of the current major version in use, by default. You can specify a different minor version of the current major version in use.

MAJOR_VERSION

In this mode, the service pipeline is deployed and updated with the published, recommended (latest) major and minor version of the current template by default. You can specify a different major version that's higher than the major version in use and a minor version.

See Also:

AWS API Reference

◆ UpdateServicePipelineAsync()

template<typename UpdateServicePipelineRequestT = Model::UpdateServicePipelineRequest>
void Aws::Proton::ProtonClient::UpdateServicePipelineAsync ( const UpdateServicePipelineRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateServicePipeline that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2535 of file ProtonClient.h.

◆ UpdateServicePipelineCallable()

template<typename UpdateServicePipelineRequestT = Model::UpdateServicePipelineRequest>
Model::UpdateServicePipelineOutcomeCallable Aws::Proton::ProtonClient::UpdateServicePipelineCallable ( const UpdateServicePipelineRequestT &  request) const
inline

A Callable wrapper for UpdateServicePipeline that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2526 of file ProtonClient.h.

◆ UpdateServiceSyncBlocker()

virtual Model::UpdateServiceSyncBlockerOutcome Aws::Proton::ProtonClient::UpdateServiceSyncBlocker ( const Model::UpdateServiceSyncBlockerRequest request) const
virtual

Update the service sync blocker by resolving it.

See Also:


AWS API Reference

◆ UpdateServiceSyncBlockerAsync()

template<typename UpdateServiceSyncBlockerRequestT = Model::UpdateServiceSyncBlockerRequest>
void Aws::Proton::ProtonClient::UpdateServiceSyncBlockerAsync ( const UpdateServiceSyncBlockerRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateServiceSyncBlocker that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2561 of file ProtonClient.h.

◆ UpdateServiceSyncBlockerCallable()

template<typename UpdateServiceSyncBlockerRequestT = Model::UpdateServiceSyncBlockerRequest>
Model::UpdateServiceSyncBlockerOutcomeCallable Aws::Proton::ProtonClient::UpdateServiceSyncBlockerCallable ( const UpdateServiceSyncBlockerRequestT &  request) const
inline

A Callable wrapper for UpdateServiceSyncBlocker that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2552 of file ProtonClient.h.

◆ UpdateServiceSyncConfig()

virtual Model::UpdateServiceSyncConfigOutcome Aws::Proton::ProtonClient::UpdateServiceSyncConfig ( const Model::UpdateServiceSyncConfigRequest request) const
virtual

Update the Proton Ops config file.

See Also:

AWS API Reference

◆ UpdateServiceSyncConfigAsync()

template<typename UpdateServiceSyncConfigRequestT = Model::UpdateServiceSyncConfigRequest>
void Aws::Proton::ProtonClient::UpdateServiceSyncConfigAsync ( const UpdateServiceSyncConfigRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateServiceSyncConfig that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2586 of file ProtonClient.h.

◆ UpdateServiceSyncConfigCallable()

template<typename UpdateServiceSyncConfigRequestT = Model::UpdateServiceSyncConfigRequest>
Model::UpdateServiceSyncConfigOutcomeCallable Aws::Proton::ProtonClient::UpdateServiceSyncConfigCallable ( const UpdateServiceSyncConfigRequestT &  request) const
inline

A Callable wrapper for UpdateServiceSyncConfig that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2577 of file ProtonClient.h.

◆ UpdateServiceTemplate()

virtual Model::UpdateServiceTemplateOutcome Aws::Proton::ProtonClient::UpdateServiceTemplate ( const Model::UpdateServiceTemplateRequest request) const
virtual

Update a service template.

See Also:

AWS API Reference

◆ UpdateServiceTemplateAsync()

template<typename UpdateServiceTemplateRequestT = Model::UpdateServiceTemplateRequest>
void Aws::Proton::ProtonClient::UpdateServiceTemplateAsync ( const UpdateServiceTemplateRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateServiceTemplate that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2611 of file ProtonClient.h.

◆ UpdateServiceTemplateCallable()

template<typename UpdateServiceTemplateRequestT = Model::UpdateServiceTemplateRequest>
Model::UpdateServiceTemplateOutcomeCallable Aws::Proton::ProtonClient::UpdateServiceTemplateCallable ( const UpdateServiceTemplateRequestT &  request) const
inline

A Callable wrapper for UpdateServiceTemplate that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2602 of file ProtonClient.h.

◆ UpdateServiceTemplateVersion()

virtual Model::UpdateServiceTemplateVersionOutcome Aws::Proton::ProtonClient::UpdateServiceTemplateVersion ( const Model::UpdateServiceTemplateVersionRequest request) const
virtual

Update a major or minor version of a service template.

See Also:

AWS API Reference

◆ UpdateServiceTemplateVersionAsync()

template<typename UpdateServiceTemplateVersionRequestT = Model::UpdateServiceTemplateVersionRequest>
void Aws::Proton::ProtonClient::UpdateServiceTemplateVersionAsync ( const UpdateServiceTemplateVersionRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateServiceTemplateVersion that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2637 of file ProtonClient.h.

◆ UpdateServiceTemplateVersionCallable()

template<typename UpdateServiceTemplateVersionRequestT = Model::UpdateServiceTemplateVersionRequest>
Model::UpdateServiceTemplateVersionOutcomeCallable Aws::Proton::ProtonClient::UpdateServiceTemplateVersionCallable ( const UpdateServiceTemplateVersionRequestT &  request) const
inline

A Callable wrapper for UpdateServiceTemplateVersion that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2628 of file ProtonClient.h.

◆ UpdateTemplateSyncConfig()

virtual Model::UpdateTemplateSyncConfigOutcome Aws::Proton::ProtonClient::UpdateTemplateSyncConfig ( const Model::UpdateTemplateSyncConfigRequest request) const
virtual

Update template sync configuration parameters, except for the templateName and templateType. Repository details (branch, name, and provider) should be of a linked repository. A linked repository is a repository that has been registered with Proton. For more information, see CreateRepository.

See Also:

AWS API Reference

◆ UpdateTemplateSyncConfigAsync()

template<typename UpdateTemplateSyncConfigRequestT = Model::UpdateTemplateSyncConfigRequest>
void Aws::Proton::ProtonClient::UpdateTemplateSyncConfigAsync ( const UpdateTemplateSyncConfigRequestT &  request,
const std::shared_ptr< const Aws::Client::AsyncCallerContext > &  context = nullptr 
) const
inline

An Async wrapper for UpdateTemplateSyncConfig that queues the request into a thread executor and triggers associated callback when operation has finished.

Definition at line 2666 of file ProtonClient.h.

◆ UpdateTemplateSyncConfigCallable()

template<typename UpdateTemplateSyncConfigRequestT = Model::UpdateTemplateSyncConfigRequest>
Model::UpdateTemplateSyncConfigOutcomeCallable Aws::Proton::ProtonClient::UpdateTemplateSyncConfigCallable ( const UpdateTemplateSyncConfigRequestT &  request) const
inline

A Callable wrapper for UpdateTemplateSyncConfig that returns a future to the operation so that it can be executed in parallel to other requests.

Definition at line 2657 of file ProtonClient.h.

Friends And Related Symbol Documentation

◆ Aws::Client::ClientWithAsyncTemplateMethods< ProtonClient >

Definition at line 2673 of file ProtonClient.h.


The documentation for this class was generated from the following file: