/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include namespace Aws { namespace Proton { /** *

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:

  • CreateEnvironmentTemplateVersion

    • *

  • CreateServiceTemplateVersion

  • *

    CreateEnvironmentAccountConnection

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:

  • CreateEnvironmentTemplate

  • *

    CreateServiceTemplate

  • CreateEnvironment

  • *

    CreateService

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:

  • DeleteEnvironmentTemplate

  • *

    DeleteEnvironmentTemplateVersion

  • DeleteServiceTemplate

    *

  • DeleteServiceTemplateVersion

  • *

    DeleteEnvironmentAccountConnection

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:

*

  • DeleteEnvironment

  • DeleteService

*/ class AWS_PROTON_API ProtonClient : public Aws::Client::AWSJsonClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSJsonClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef ProtonClientConfiguration ClientConfigurationType; typedef ProtonEndpointProvider EndpointProviderType; /** * 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(const Aws::Proton::ProtonClientConfiguration& clientConfiguration = Aws::Proton::ProtonClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * 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(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), 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(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::Proton::ProtonClientConfiguration& clientConfiguration = Aws::Proton::ProtonClientConfiguration()); /* Legacy constructors due deprecation */ /** * 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(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(const Aws::Auth::AWSCredentials& credentials, 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(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~ProtonClient(); /** *

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

*/ virtual Model::AcceptEnvironmentAccountConnectionOutcome AcceptEnvironmentAccountConnection(const Model::AcceptEnvironmentAccountConnectionRequest& request) const; /** * A Callable wrapper for AcceptEnvironmentAccountConnection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AcceptEnvironmentAccountConnectionOutcomeCallable AcceptEnvironmentAccountConnectionCallable(const AcceptEnvironmentAccountConnectionRequestT& request) const { return SubmitCallable(&ProtonClient::AcceptEnvironmentAccountConnection, request); } /** * An Async wrapper for AcceptEnvironmentAccountConnection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AcceptEnvironmentAccountConnectionAsync(const AcceptEnvironmentAccountConnectionRequestT& request, const AcceptEnvironmentAccountConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::AcceptEnvironmentAccountConnection, request, handler, context); } /** *

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

*/ virtual Model::CancelComponentDeploymentOutcome CancelComponentDeployment(const Model::CancelComponentDeploymentRequest& request) const; /** * A Callable wrapper for CancelComponentDeployment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelComponentDeploymentOutcomeCallable CancelComponentDeploymentCallable(const CancelComponentDeploymentRequestT& request) const { return SubmitCallable(&ProtonClient::CancelComponentDeployment, request); } /** * An Async wrapper for CancelComponentDeployment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelComponentDeploymentAsync(const CancelComponentDeploymentRequestT& request, const CancelComponentDeploymentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::CancelComponentDeployment, request, handler, context); } /** *

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

*/ virtual Model::CancelEnvironmentDeploymentOutcome CancelEnvironmentDeployment(const Model::CancelEnvironmentDeploymentRequest& request) const; /** * A Callable wrapper for CancelEnvironmentDeployment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelEnvironmentDeploymentOutcomeCallable CancelEnvironmentDeploymentCallable(const CancelEnvironmentDeploymentRequestT& request) const { return SubmitCallable(&ProtonClient::CancelEnvironmentDeployment, request); } /** * An Async wrapper for CancelEnvironmentDeployment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelEnvironmentDeploymentAsync(const CancelEnvironmentDeploymentRequestT& request, const CancelEnvironmentDeploymentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::CancelEnvironmentDeployment, request, handler, context); } /** *

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

*/ virtual Model::CancelServiceInstanceDeploymentOutcome CancelServiceInstanceDeployment(const Model::CancelServiceInstanceDeploymentRequest& request) const; /** * A Callable wrapper for CancelServiceInstanceDeployment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelServiceInstanceDeploymentOutcomeCallable CancelServiceInstanceDeploymentCallable(const CancelServiceInstanceDeploymentRequestT& request) const { return SubmitCallable(&ProtonClient::CancelServiceInstanceDeployment, request); } /** * An Async wrapper for CancelServiceInstanceDeployment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelServiceInstanceDeploymentAsync(const CancelServiceInstanceDeploymentRequestT& request, const CancelServiceInstanceDeploymentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::CancelServiceInstanceDeployment, request, handler, context); } /** *

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

*/ virtual Model::CancelServicePipelineDeploymentOutcome CancelServicePipelineDeployment(const Model::CancelServicePipelineDeploymentRequest& request) const; /** * A Callable wrapper for CancelServicePipelineDeployment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelServicePipelineDeploymentOutcomeCallable CancelServicePipelineDeploymentCallable(const CancelServicePipelineDeploymentRequestT& request) const { return SubmitCallable(&ProtonClient::CancelServicePipelineDeployment, request); } /** * An Async wrapper for CancelServicePipelineDeployment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelServicePipelineDeploymentAsync(const CancelServicePipelineDeploymentRequestT& request, const CancelServicePipelineDeploymentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::CancelServicePipelineDeployment, request, handler, context); } /** *

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

*/ virtual Model::CreateComponentOutcome CreateComponent(const Model::CreateComponentRequest& request) const; /** * A Callable wrapper for CreateComponent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateComponentOutcomeCallable CreateComponentCallable(const CreateComponentRequestT& request) const { return SubmitCallable(&ProtonClient::CreateComponent, request); } /** * An Async wrapper for CreateComponent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateComponentAsync(const CreateComponentRequestT& request, const CreateComponentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::CreateComponent, request, handler, context); } /** *

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

*/ virtual Model::CreateEnvironmentOutcome CreateEnvironment(const Model::CreateEnvironmentRequest& request) const; /** * A Callable wrapper for CreateEnvironment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateEnvironmentOutcomeCallable CreateEnvironmentCallable(const CreateEnvironmentRequestT& request) const { return SubmitCallable(&ProtonClient::CreateEnvironment, request); } /** * An Async wrapper for CreateEnvironment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateEnvironmentAsync(const CreateEnvironmentRequestT& request, const CreateEnvironmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::CreateEnvironment, request, handler, context); } /** *

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

*/ virtual Model::CreateEnvironmentAccountConnectionOutcome CreateEnvironmentAccountConnection(const Model::CreateEnvironmentAccountConnectionRequest& request) const; /** * A Callable wrapper for CreateEnvironmentAccountConnection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateEnvironmentAccountConnectionOutcomeCallable CreateEnvironmentAccountConnectionCallable(const CreateEnvironmentAccountConnectionRequestT& request) const { return SubmitCallable(&ProtonClient::CreateEnvironmentAccountConnection, request); } /** * An Async wrapper for CreateEnvironmentAccountConnection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateEnvironmentAccountConnectionAsync(const CreateEnvironmentAccountConnectionRequestT& request, const CreateEnvironmentAccountConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::CreateEnvironmentAccountConnection, request, handler, context); } /** *

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

*/ virtual Model::CreateEnvironmentTemplateOutcome CreateEnvironmentTemplate(const Model::CreateEnvironmentTemplateRequest& request) const; /** * A Callable wrapper for CreateEnvironmentTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateEnvironmentTemplateOutcomeCallable CreateEnvironmentTemplateCallable(const CreateEnvironmentTemplateRequestT& request) const { return SubmitCallable(&ProtonClient::CreateEnvironmentTemplate, request); } /** * An Async wrapper for CreateEnvironmentTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateEnvironmentTemplateAsync(const CreateEnvironmentTemplateRequestT& request, const CreateEnvironmentTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::CreateEnvironmentTemplate, request, handler, context); } /** *

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

*/ virtual Model::CreateEnvironmentTemplateVersionOutcome CreateEnvironmentTemplateVersion(const Model::CreateEnvironmentTemplateVersionRequest& request) const; /** * A Callable wrapper for CreateEnvironmentTemplateVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateEnvironmentTemplateVersionOutcomeCallable CreateEnvironmentTemplateVersionCallable(const CreateEnvironmentTemplateVersionRequestT& request) const { return SubmitCallable(&ProtonClient::CreateEnvironmentTemplateVersion, request); } /** * An Async wrapper for CreateEnvironmentTemplateVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateEnvironmentTemplateVersionAsync(const CreateEnvironmentTemplateVersionRequestT& request, const CreateEnvironmentTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::CreateEnvironmentTemplateVersion, request, handler, context); } /** *

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

*/ virtual Model::CreateRepositoryOutcome CreateRepository(const Model::CreateRepositoryRequest& request) const; /** * A Callable wrapper for CreateRepository that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateRepositoryOutcomeCallable CreateRepositoryCallable(const CreateRepositoryRequestT& request) const { return SubmitCallable(&ProtonClient::CreateRepository, request); } /** * An Async wrapper for CreateRepository that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateRepositoryAsync(const CreateRepositoryRequestT& request, const CreateRepositoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::CreateRepository, request, handler, context); } /** *

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

*/ virtual Model::CreateServiceOutcome CreateService(const Model::CreateServiceRequest& request) const; /** * A Callable wrapper for CreateService that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateServiceOutcomeCallable CreateServiceCallable(const CreateServiceRequestT& request) const { return SubmitCallable(&ProtonClient::CreateService, request); } /** * An Async wrapper for CreateService that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateServiceAsync(const CreateServiceRequestT& request, const CreateServiceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::CreateService, request, handler, context); } /** *

Create a service instance.

See Also:

AWS * API Reference

*/ virtual Model::CreateServiceInstanceOutcome CreateServiceInstance(const Model::CreateServiceInstanceRequest& request) const; /** * A Callable wrapper for CreateServiceInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateServiceInstanceOutcomeCallable CreateServiceInstanceCallable(const CreateServiceInstanceRequestT& request) const { return SubmitCallable(&ProtonClient::CreateServiceInstance, request); } /** * An Async wrapper for CreateServiceInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateServiceInstanceAsync(const CreateServiceInstanceRequestT& request, const CreateServiceInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::CreateServiceInstance, request, handler, context); } /** *

Create the Proton Ops configuration file.

See Also:

AWS * API Reference

*/ virtual Model::CreateServiceSyncConfigOutcome CreateServiceSyncConfig(const Model::CreateServiceSyncConfigRequest& request) const; /** * A Callable wrapper for CreateServiceSyncConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateServiceSyncConfigOutcomeCallable CreateServiceSyncConfigCallable(const CreateServiceSyncConfigRequestT& request) const { return SubmitCallable(&ProtonClient::CreateServiceSyncConfig, request); } /** * An Async wrapper for CreateServiceSyncConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateServiceSyncConfigAsync(const CreateServiceSyncConfigRequestT& request, const CreateServiceSyncConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::CreateServiceSyncConfig, request, handler, context); } /** *

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

*/ virtual Model::CreateServiceTemplateOutcome CreateServiceTemplate(const Model::CreateServiceTemplateRequest& request) const; /** * A Callable wrapper for CreateServiceTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateServiceTemplateOutcomeCallable CreateServiceTemplateCallable(const CreateServiceTemplateRequestT& request) const { return SubmitCallable(&ProtonClient::CreateServiceTemplate, request); } /** * An Async wrapper for CreateServiceTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateServiceTemplateAsync(const CreateServiceTemplateRequestT& request, const CreateServiceTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::CreateServiceTemplate, request, handler, context); } /** *

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

*/ virtual Model::CreateServiceTemplateVersionOutcome CreateServiceTemplateVersion(const Model::CreateServiceTemplateVersionRequest& request) const; /** * A Callable wrapper for CreateServiceTemplateVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateServiceTemplateVersionOutcomeCallable CreateServiceTemplateVersionCallable(const CreateServiceTemplateVersionRequestT& request) const { return SubmitCallable(&ProtonClient::CreateServiceTemplateVersion, request); } /** * An Async wrapper for CreateServiceTemplateVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateServiceTemplateVersionAsync(const CreateServiceTemplateVersionRequestT& request, const CreateServiceTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::CreateServiceTemplateVersion, request, handler, context); } /** *

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

*/ virtual Model::CreateTemplateSyncConfigOutcome CreateTemplateSyncConfig(const Model::CreateTemplateSyncConfigRequest& request) const; /** * A Callable wrapper for CreateTemplateSyncConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateTemplateSyncConfigOutcomeCallable CreateTemplateSyncConfigCallable(const CreateTemplateSyncConfigRequestT& request) const { return SubmitCallable(&ProtonClient::CreateTemplateSyncConfig, request); } /** * An Async wrapper for CreateTemplateSyncConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateTemplateSyncConfigAsync(const CreateTemplateSyncConfigRequestT& request, const CreateTemplateSyncConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::CreateTemplateSyncConfig, request, handler, context); } /** *

Delete an Proton component resource.

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

See Also:

AWS * API Reference

*/ virtual Model::DeleteComponentOutcome DeleteComponent(const Model::DeleteComponentRequest& request) const; /** * A Callable wrapper for DeleteComponent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteComponentOutcomeCallable DeleteComponentCallable(const DeleteComponentRequestT& request) const { return SubmitCallable(&ProtonClient::DeleteComponent, request); } /** * An Async wrapper for DeleteComponent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteComponentAsync(const DeleteComponentRequestT& request, const DeleteComponentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::DeleteComponent, request, handler, context); } /** *

Delete the deployment.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDeploymentOutcome DeleteDeployment(const Model::DeleteDeploymentRequest& request) const; /** * A Callable wrapper for DeleteDeployment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDeploymentOutcomeCallable DeleteDeploymentCallable(const DeleteDeploymentRequestT& request) const { return SubmitCallable(&ProtonClient::DeleteDeployment, request); } /** * An Async wrapper for DeleteDeployment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDeploymentAsync(const DeleteDeploymentRequestT& request, const DeleteDeploymentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::DeleteDeployment, request, handler, context); } /** *

Delete an environment.

See Also:

AWS * API Reference

*/ virtual Model::DeleteEnvironmentOutcome DeleteEnvironment(const Model::DeleteEnvironmentRequest& request) const; /** * A Callable wrapper for DeleteEnvironment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEnvironmentOutcomeCallable DeleteEnvironmentCallable(const DeleteEnvironmentRequestT& request) const { return SubmitCallable(&ProtonClient::DeleteEnvironment, request); } /** * An Async wrapper for DeleteEnvironment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEnvironmentAsync(const DeleteEnvironmentRequestT& request, const DeleteEnvironmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::DeleteEnvironment, request, handler, context); } /** *

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

*/ virtual Model::DeleteEnvironmentAccountConnectionOutcome DeleteEnvironmentAccountConnection(const Model::DeleteEnvironmentAccountConnectionRequest& request) const; /** * A Callable wrapper for DeleteEnvironmentAccountConnection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEnvironmentAccountConnectionOutcomeCallable DeleteEnvironmentAccountConnectionCallable(const DeleteEnvironmentAccountConnectionRequestT& request) const { return SubmitCallable(&ProtonClient::DeleteEnvironmentAccountConnection, request); } /** * An Async wrapper for DeleteEnvironmentAccountConnection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEnvironmentAccountConnectionAsync(const DeleteEnvironmentAccountConnectionRequestT& request, const DeleteEnvironmentAccountConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::DeleteEnvironmentAccountConnection, request, handler, context); } /** *

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

See Also:

AWS * API Reference

*/ virtual Model::DeleteEnvironmentTemplateOutcome DeleteEnvironmentTemplate(const Model::DeleteEnvironmentTemplateRequest& request) const; /** * A Callable wrapper for DeleteEnvironmentTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEnvironmentTemplateOutcomeCallable DeleteEnvironmentTemplateCallable(const DeleteEnvironmentTemplateRequestT& request) const { return SubmitCallable(&ProtonClient::DeleteEnvironmentTemplate, request); } /** * An Async wrapper for DeleteEnvironmentTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEnvironmentTemplateAsync(const DeleteEnvironmentTemplateRequestT& request, const DeleteEnvironmentTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::DeleteEnvironmentTemplate, request, handler, context); } /** *

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

*/ virtual Model::DeleteEnvironmentTemplateVersionOutcome DeleteEnvironmentTemplateVersion(const Model::DeleteEnvironmentTemplateVersionRequest& request) const; /** * A Callable wrapper for DeleteEnvironmentTemplateVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEnvironmentTemplateVersionOutcomeCallable DeleteEnvironmentTemplateVersionCallable(const DeleteEnvironmentTemplateVersionRequestT& request) const { return SubmitCallable(&ProtonClient::DeleteEnvironmentTemplateVersion, request); } /** * An Async wrapper for DeleteEnvironmentTemplateVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEnvironmentTemplateVersionAsync(const DeleteEnvironmentTemplateVersionRequestT& request, const DeleteEnvironmentTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::DeleteEnvironmentTemplateVersion, request, handler, context); } /** *

De-register and unlink your repository.

See Also:

AWS * API Reference

*/ virtual Model::DeleteRepositoryOutcome DeleteRepository(const Model::DeleteRepositoryRequest& request) const; /** * A Callable wrapper for DeleteRepository that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteRepositoryOutcomeCallable DeleteRepositoryCallable(const DeleteRepositoryRequestT& request) const { return SubmitCallable(&ProtonClient::DeleteRepository, request); } /** * An Async wrapper for DeleteRepository that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteRepositoryAsync(const DeleteRepositoryRequestT& request, const DeleteRepositoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::DeleteRepository, request, handler, context); } /** *

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

*/ virtual Model::DeleteServiceOutcome DeleteService(const Model::DeleteServiceRequest& request) const; /** * A Callable wrapper for DeleteService that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteServiceOutcomeCallable DeleteServiceCallable(const DeleteServiceRequestT& request) const { return SubmitCallable(&ProtonClient::DeleteService, request); } /** * An Async wrapper for DeleteService that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteServiceAsync(const DeleteServiceRequestT& request, const DeleteServiceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::DeleteService, request, handler, context); } /** *

Delete the Proton Ops file.

See Also:

AWS * API Reference

*/ virtual Model::DeleteServiceSyncConfigOutcome DeleteServiceSyncConfig(const Model::DeleteServiceSyncConfigRequest& request) const; /** * A Callable wrapper for DeleteServiceSyncConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteServiceSyncConfigOutcomeCallable DeleteServiceSyncConfigCallable(const DeleteServiceSyncConfigRequestT& request) const { return SubmitCallable(&ProtonClient::DeleteServiceSyncConfig, request); } /** * An Async wrapper for DeleteServiceSyncConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteServiceSyncConfigAsync(const DeleteServiceSyncConfigRequestT& request, const DeleteServiceSyncConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::DeleteServiceSyncConfig, request, handler, context); } /** *

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

See Also:

AWS * API Reference

*/ virtual Model::DeleteServiceTemplateOutcome DeleteServiceTemplate(const Model::DeleteServiceTemplateRequest& request) const; /** * A Callable wrapper for DeleteServiceTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteServiceTemplateOutcomeCallable DeleteServiceTemplateCallable(const DeleteServiceTemplateRequestT& request) const { return SubmitCallable(&ProtonClient::DeleteServiceTemplate, request); } /** * An Async wrapper for DeleteServiceTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteServiceTemplateAsync(const DeleteServiceTemplateRequestT& request, const DeleteServiceTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::DeleteServiceTemplate, request, handler, context); } /** *

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

*/ virtual Model::DeleteServiceTemplateVersionOutcome DeleteServiceTemplateVersion(const Model::DeleteServiceTemplateVersionRequest& request) const; /** * A Callable wrapper for DeleteServiceTemplateVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteServiceTemplateVersionOutcomeCallable DeleteServiceTemplateVersionCallable(const DeleteServiceTemplateVersionRequestT& request) const { return SubmitCallable(&ProtonClient::DeleteServiceTemplateVersion, request); } /** * An Async wrapper for DeleteServiceTemplateVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteServiceTemplateVersionAsync(const DeleteServiceTemplateVersionRequestT& request, const DeleteServiceTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::DeleteServiceTemplateVersion, request, handler, context); } /** *

Delete a template sync configuration.

See Also:

AWS * API Reference

*/ virtual Model::DeleteTemplateSyncConfigOutcome DeleteTemplateSyncConfig(const Model::DeleteTemplateSyncConfigRequest& request) const; /** * A Callable wrapper for DeleteTemplateSyncConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteTemplateSyncConfigOutcomeCallable DeleteTemplateSyncConfigCallable(const DeleteTemplateSyncConfigRequestT& request) const { return SubmitCallable(&ProtonClient::DeleteTemplateSyncConfig, request); } /** * An Async wrapper for DeleteTemplateSyncConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteTemplateSyncConfigAsync(const DeleteTemplateSyncConfigRequestT& request, const DeleteTemplateSyncConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::DeleteTemplateSyncConfig, request, handler, context); } /** *

Get detail data for Proton account-wide settings.

See Also:

* AWS * API Reference

*/ virtual Model::GetAccountSettingsOutcome GetAccountSettings(const Model::GetAccountSettingsRequest& request) const; /** * A Callable wrapper for GetAccountSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetAccountSettingsOutcomeCallable GetAccountSettingsCallable(const GetAccountSettingsRequestT& request) const { return SubmitCallable(&ProtonClient::GetAccountSettings, request); } /** * An Async wrapper for GetAccountSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetAccountSettingsAsync(const GetAccountSettingsRequestT& request, const GetAccountSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::GetAccountSettings, request, handler, context); } /** *

Get detailed data for a component.

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

See Also:

AWS * API Reference

*/ virtual Model::GetComponentOutcome GetComponent(const Model::GetComponentRequest& request) const; /** * A Callable wrapper for GetComponent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetComponentOutcomeCallable GetComponentCallable(const GetComponentRequestT& request) const { return SubmitCallable(&ProtonClient::GetComponent, request); } /** * An Async wrapper for GetComponent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetComponentAsync(const GetComponentRequestT& request, const GetComponentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::GetComponent, request, handler, context); } /** *

Get detailed data for a deployment.

See Also:

AWS * API Reference

*/ virtual Model::GetDeploymentOutcome GetDeployment(const Model::GetDeploymentRequest& request) const; /** * A Callable wrapper for GetDeployment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetDeploymentOutcomeCallable GetDeploymentCallable(const GetDeploymentRequestT& request) const { return SubmitCallable(&ProtonClient::GetDeployment, request); } /** * An Async wrapper for GetDeployment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetDeploymentAsync(const GetDeploymentRequestT& request, const GetDeploymentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::GetDeployment, request, handler, context); } /** *

Get detailed data for an environment.

See Also:

AWS * API Reference

*/ virtual Model::GetEnvironmentOutcome GetEnvironment(const Model::GetEnvironmentRequest& request) const; /** * A Callable wrapper for GetEnvironment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEnvironmentOutcomeCallable GetEnvironmentCallable(const GetEnvironmentRequestT& request) const { return SubmitCallable(&ProtonClient::GetEnvironment, request); } /** * An Async wrapper for GetEnvironment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEnvironmentAsync(const GetEnvironmentRequestT& request, const GetEnvironmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::GetEnvironment, request, handler, context); } /** *

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

*/ virtual Model::GetEnvironmentAccountConnectionOutcome GetEnvironmentAccountConnection(const Model::GetEnvironmentAccountConnectionRequest& request) const; /** * A Callable wrapper for GetEnvironmentAccountConnection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEnvironmentAccountConnectionOutcomeCallable GetEnvironmentAccountConnectionCallable(const GetEnvironmentAccountConnectionRequestT& request) const { return SubmitCallable(&ProtonClient::GetEnvironmentAccountConnection, request); } /** * An Async wrapper for GetEnvironmentAccountConnection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEnvironmentAccountConnectionAsync(const GetEnvironmentAccountConnectionRequestT& request, const GetEnvironmentAccountConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::GetEnvironmentAccountConnection, request, handler, context); } /** *

Get detailed data for an environment template.

See Also:

AWS * API Reference

*/ virtual Model::GetEnvironmentTemplateOutcome GetEnvironmentTemplate(const Model::GetEnvironmentTemplateRequest& request) const; /** * A Callable wrapper for GetEnvironmentTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEnvironmentTemplateOutcomeCallable GetEnvironmentTemplateCallable(const GetEnvironmentTemplateRequestT& request) const { return SubmitCallable(&ProtonClient::GetEnvironmentTemplate, request); } /** * An Async wrapper for GetEnvironmentTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEnvironmentTemplateAsync(const GetEnvironmentTemplateRequestT& request, const GetEnvironmentTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::GetEnvironmentTemplate, request, handler, context); } /** *

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

See Also:

AWS * API Reference

*/ virtual Model::GetEnvironmentTemplateVersionOutcome GetEnvironmentTemplateVersion(const Model::GetEnvironmentTemplateVersionRequest& request) const; /** * A Callable wrapper for GetEnvironmentTemplateVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetEnvironmentTemplateVersionOutcomeCallable GetEnvironmentTemplateVersionCallable(const GetEnvironmentTemplateVersionRequestT& request) const { return SubmitCallable(&ProtonClient::GetEnvironmentTemplateVersion, request); } /** * An Async wrapper for GetEnvironmentTemplateVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetEnvironmentTemplateVersionAsync(const GetEnvironmentTemplateVersionRequestT& request, const GetEnvironmentTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::GetEnvironmentTemplateVersion, request, handler, context); } /** *

Get detail data for a linked repository.

See Also:

AWS * API Reference

*/ virtual Model::GetRepositoryOutcome GetRepository(const Model::GetRepositoryRequest& request) const; /** * A Callable wrapper for GetRepository that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRepositoryOutcomeCallable GetRepositoryCallable(const GetRepositoryRequestT& request) const { return SubmitCallable(&ProtonClient::GetRepository, request); } /** * An Async wrapper for GetRepository that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRepositoryAsync(const GetRepositoryRequestT& request, const GetRepositoryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::GetRepository, request, handler, context); } /** *

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

*/ virtual Model::GetRepositorySyncStatusOutcome GetRepositorySyncStatus(const Model::GetRepositorySyncStatusRequest& request) const; /** * A Callable wrapper for GetRepositorySyncStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetRepositorySyncStatusOutcomeCallable GetRepositorySyncStatusCallable(const GetRepositorySyncStatusRequestT& request) const { return SubmitCallable(&ProtonClient::GetRepositorySyncStatus, request); } /** * An Async wrapper for GetRepositorySyncStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetRepositorySyncStatusAsync(const GetRepositorySyncStatusRequestT& request, const GetRepositorySyncStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::GetRepositorySyncStatus, request, handler, context); } /** *

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

*/ virtual Model::GetResourcesSummaryOutcome GetResourcesSummary(const Model::GetResourcesSummaryRequest& request) const; /** * A Callable wrapper for GetResourcesSummary that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetResourcesSummaryOutcomeCallable GetResourcesSummaryCallable(const GetResourcesSummaryRequestT& request) const { return SubmitCallable(&ProtonClient::GetResourcesSummary, request); } /** * An Async wrapper for GetResourcesSummary that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetResourcesSummaryAsync(const GetResourcesSummaryRequestT& request, const GetResourcesSummaryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::GetResourcesSummary, request, handler, context); } /** *

Get detailed data for a service.

See Also:

AWS * API Reference

*/ virtual Model::GetServiceOutcome GetService(const Model::GetServiceRequest& request) const; /** * A Callable wrapper for GetService that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetServiceOutcomeCallable GetServiceCallable(const GetServiceRequestT& request) const { return SubmitCallable(&ProtonClient::GetService, request); } /** * An Async wrapper for GetService that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetServiceAsync(const GetServiceRequestT& request, const GetServiceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::GetService, request, handler, context); } /** *

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

*/ virtual Model::GetServiceInstanceOutcome GetServiceInstance(const Model::GetServiceInstanceRequest& request) const; /** * A Callable wrapper for GetServiceInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetServiceInstanceOutcomeCallable GetServiceInstanceCallable(const GetServiceInstanceRequestT& request) const { return SubmitCallable(&ProtonClient::GetServiceInstance, request); } /** * An Async wrapper for GetServiceInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetServiceInstanceAsync(const GetServiceInstanceRequestT& request, const GetServiceInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::GetServiceInstance, request, handler, context); } /** *

Get the status of the synced service instance.

See Also:

AWS * API Reference

*/ virtual Model::GetServiceInstanceSyncStatusOutcome GetServiceInstanceSyncStatus(const Model::GetServiceInstanceSyncStatusRequest& request) const; /** * A Callable wrapper for GetServiceInstanceSyncStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetServiceInstanceSyncStatusOutcomeCallable GetServiceInstanceSyncStatusCallable(const GetServiceInstanceSyncStatusRequestT& request) const { return SubmitCallable(&ProtonClient::GetServiceInstanceSyncStatus, request); } /** * An Async wrapper for GetServiceInstanceSyncStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetServiceInstanceSyncStatusAsync(const GetServiceInstanceSyncStatusRequestT& request, const GetServiceInstanceSyncStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::GetServiceInstanceSyncStatus, request, handler, context); } /** *

Get detailed data for the service sync blocker summary.

See * Also:

AWS * API Reference

*/ virtual Model::GetServiceSyncBlockerSummaryOutcome GetServiceSyncBlockerSummary(const Model::GetServiceSyncBlockerSummaryRequest& request) const; /** * A Callable wrapper for GetServiceSyncBlockerSummary that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetServiceSyncBlockerSummaryOutcomeCallable GetServiceSyncBlockerSummaryCallable(const GetServiceSyncBlockerSummaryRequestT& request) const { return SubmitCallable(&ProtonClient::GetServiceSyncBlockerSummary, request); } /** * An Async wrapper for GetServiceSyncBlockerSummary that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetServiceSyncBlockerSummaryAsync(const GetServiceSyncBlockerSummaryRequestT& request, const GetServiceSyncBlockerSummaryResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::GetServiceSyncBlockerSummary, request, handler, context); } /** *

Get detailed information for the service sync configuration.

See * Also:

AWS * API Reference

*/ virtual Model::GetServiceSyncConfigOutcome GetServiceSyncConfig(const Model::GetServiceSyncConfigRequest& request) const; /** * A Callable wrapper for GetServiceSyncConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetServiceSyncConfigOutcomeCallable GetServiceSyncConfigCallable(const GetServiceSyncConfigRequestT& request) const { return SubmitCallable(&ProtonClient::GetServiceSyncConfig, request); } /** * An Async wrapper for GetServiceSyncConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetServiceSyncConfigAsync(const GetServiceSyncConfigRequestT& request, const GetServiceSyncConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::GetServiceSyncConfig, request, handler, context); } /** *

Get detailed data for a service template.

See Also:

AWS * API Reference

*/ virtual Model::GetServiceTemplateOutcome GetServiceTemplate(const Model::GetServiceTemplateRequest& request) const; /** * A Callable wrapper for GetServiceTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetServiceTemplateOutcomeCallable GetServiceTemplateCallable(const GetServiceTemplateRequestT& request) const { return SubmitCallable(&ProtonClient::GetServiceTemplate, request); } /** * An Async wrapper for GetServiceTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetServiceTemplateAsync(const GetServiceTemplateRequestT& request, const GetServiceTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::GetServiceTemplate, request, handler, context); } /** *

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

See Also:

AWS * API Reference

*/ virtual Model::GetServiceTemplateVersionOutcome GetServiceTemplateVersion(const Model::GetServiceTemplateVersionRequest& request) const; /** * A Callable wrapper for GetServiceTemplateVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetServiceTemplateVersionOutcomeCallable GetServiceTemplateVersionCallable(const GetServiceTemplateVersionRequestT& request) const { return SubmitCallable(&ProtonClient::GetServiceTemplateVersion, request); } /** * An Async wrapper for GetServiceTemplateVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetServiceTemplateVersionAsync(const GetServiceTemplateVersionRequestT& request, const GetServiceTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::GetServiceTemplateVersion, request, handler, context); } /** *

Get detail data for a template sync configuration.

See Also:

* AWS * API Reference

*/ virtual Model::GetTemplateSyncConfigOutcome GetTemplateSyncConfig(const Model::GetTemplateSyncConfigRequest& request) const; /** * A Callable wrapper for GetTemplateSyncConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetTemplateSyncConfigOutcomeCallable GetTemplateSyncConfigCallable(const GetTemplateSyncConfigRequestT& request) const { return SubmitCallable(&ProtonClient::GetTemplateSyncConfig, request); } /** * An Async wrapper for GetTemplateSyncConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetTemplateSyncConfigAsync(const GetTemplateSyncConfigRequestT& request, const GetTemplateSyncConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::GetTemplateSyncConfig, request, handler, context); } /** *

Get the status of a template sync.

See Also:

AWS * API Reference

*/ virtual Model::GetTemplateSyncStatusOutcome GetTemplateSyncStatus(const Model::GetTemplateSyncStatusRequest& request) const; /** * A Callable wrapper for GetTemplateSyncStatus that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::GetTemplateSyncStatusOutcomeCallable GetTemplateSyncStatusCallable(const GetTemplateSyncStatusRequestT& request) const { return SubmitCallable(&ProtonClient::GetTemplateSyncStatus, request); } /** * An Async wrapper for GetTemplateSyncStatus that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void GetTemplateSyncStatusAsync(const GetTemplateSyncStatusRequestT& request, const GetTemplateSyncStatusResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::GetTemplateSyncStatus, request, handler, context); } /** *

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

*/ virtual Model::ListComponentOutputsOutcome ListComponentOutputs(const Model::ListComponentOutputsRequest& request) const; /** * A Callable wrapper for ListComponentOutputs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListComponentOutputsOutcomeCallable ListComponentOutputsCallable(const ListComponentOutputsRequestT& request) const { return SubmitCallable(&ProtonClient::ListComponentOutputs, request); } /** * An Async wrapper for ListComponentOutputs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListComponentOutputsAsync(const ListComponentOutputsRequestT& request, const ListComponentOutputsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::ListComponentOutputs, request, handler, context); } /** *

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

*/ virtual Model::ListComponentProvisionedResourcesOutcome ListComponentProvisionedResources(const Model::ListComponentProvisionedResourcesRequest& request) const; /** * A Callable wrapper for ListComponentProvisionedResources that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListComponentProvisionedResourcesOutcomeCallable ListComponentProvisionedResourcesCallable(const ListComponentProvisionedResourcesRequestT& request) const { return SubmitCallable(&ProtonClient::ListComponentProvisionedResources, request); } /** * An Async wrapper for ListComponentProvisionedResources that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListComponentProvisionedResourcesAsync(const ListComponentProvisionedResourcesRequestT& request, const ListComponentProvisionedResourcesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::ListComponentProvisionedResources, request, handler, context); } /** *

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

*/ virtual Model::ListComponentsOutcome ListComponents(const Model::ListComponentsRequest& request) const; /** * A Callable wrapper for ListComponents that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListComponentsOutcomeCallable ListComponentsCallable(const ListComponentsRequestT& request) const { return SubmitCallable(&ProtonClient::ListComponents, request); } /** * An Async wrapper for ListComponents that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListComponentsAsync(const ListComponentsRequestT& request, const ListComponentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::ListComponents, request, handler, context); } /** *

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

See Also:

AWS * API Reference

*/ virtual Model::ListDeploymentsOutcome ListDeployments(const Model::ListDeploymentsRequest& request) const; /** * A Callable wrapper for ListDeployments that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListDeploymentsOutcomeCallable ListDeploymentsCallable(const ListDeploymentsRequestT& request) const { return SubmitCallable(&ProtonClient::ListDeployments, request); } /** * An Async wrapper for ListDeployments that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListDeploymentsAsync(const ListDeploymentsRequestT& request, const ListDeploymentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::ListDeployments, request, handler, context); } /** *

View a list of environment account connections.

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

See * Also:

AWS * API Reference

*/ virtual Model::ListEnvironmentAccountConnectionsOutcome ListEnvironmentAccountConnections(const Model::ListEnvironmentAccountConnectionsRequest& request) const; /** * A Callable wrapper for ListEnvironmentAccountConnections that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListEnvironmentAccountConnectionsOutcomeCallable ListEnvironmentAccountConnectionsCallable(const ListEnvironmentAccountConnectionsRequestT& request) const { return SubmitCallable(&ProtonClient::ListEnvironmentAccountConnections, request); } /** * An Async wrapper for ListEnvironmentAccountConnections that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListEnvironmentAccountConnectionsAsync(const ListEnvironmentAccountConnectionsRequestT& request, const ListEnvironmentAccountConnectionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::ListEnvironmentAccountConnections, request, handler, context); } /** *

List the infrastructure as code outputs for your environment.

See * Also:

AWS * API Reference

*/ virtual Model::ListEnvironmentOutputsOutcome ListEnvironmentOutputs(const Model::ListEnvironmentOutputsRequest& request) const; /** * A Callable wrapper for ListEnvironmentOutputs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListEnvironmentOutputsOutcomeCallable ListEnvironmentOutputsCallable(const ListEnvironmentOutputsRequestT& request) const { return SubmitCallable(&ProtonClient::ListEnvironmentOutputs, request); } /** * An Async wrapper for ListEnvironmentOutputs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListEnvironmentOutputsAsync(const ListEnvironmentOutputsRequestT& request, const ListEnvironmentOutputsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::ListEnvironmentOutputs, request, handler, context); } /** *

List the provisioned resources for your environment.

See Also:

* AWS * API Reference

*/ virtual Model::ListEnvironmentProvisionedResourcesOutcome ListEnvironmentProvisionedResources(const Model::ListEnvironmentProvisionedResourcesRequest& request) const; /** * A Callable wrapper for ListEnvironmentProvisionedResources that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListEnvironmentProvisionedResourcesOutcomeCallable ListEnvironmentProvisionedResourcesCallable(const ListEnvironmentProvisionedResourcesRequestT& request) const { return SubmitCallable(&ProtonClient::ListEnvironmentProvisionedResources, request); } /** * An Async wrapper for ListEnvironmentProvisionedResources that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListEnvironmentProvisionedResourcesAsync(const ListEnvironmentProvisionedResourcesRequestT& request, const ListEnvironmentProvisionedResourcesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::ListEnvironmentProvisionedResources, request, handler, context); } /** *

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

See Also:

AWS * API Reference

*/ virtual Model::ListEnvironmentTemplateVersionsOutcome ListEnvironmentTemplateVersions(const Model::ListEnvironmentTemplateVersionsRequest& request) const; /** * A Callable wrapper for ListEnvironmentTemplateVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListEnvironmentTemplateVersionsOutcomeCallable ListEnvironmentTemplateVersionsCallable(const ListEnvironmentTemplateVersionsRequestT& request) const { return SubmitCallable(&ProtonClient::ListEnvironmentTemplateVersions, request); } /** * An Async wrapper for ListEnvironmentTemplateVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListEnvironmentTemplateVersionsAsync(const ListEnvironmentTemplateVersionsRequestT& request, const ListEnvironmentTemplateVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::ListEnvironmentTemplateVersions, request, handler, context); } /** *

List environment templates.

See Also:

AWS * API Reference

*/ virtual Model::ListEnvironmentTemplatesOutcome ListEnvironmentTemplates(const Model::ListEnvironmentTemplatesRequest& request) const; /** * A Callable wrapper for ListEnvironmentTemplates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListEnvironmentTemplatesOutcomeCallable ListEnvironmentTemplatesCallable(const ListEnvironmentTemplatesRequestT& request) const { return SubmitCallable(&ProtonClient::ListEnvironmentTemplates, request); } /** * An Async wrapper for ListEnvironmentTemplates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListEnvironmentTemplatesAsync(const ListEnvironmentTemplatesRequestT& request, const ListEnvironmentTemplatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::ListEnvironmentTemplates, request, handler, context); } /** *

List environments with detail data summaries.

See Also:

AWS * API Reference

*/ virtual Model::ListEnvironmentsOutcome ListEnvironments(const Model::ListEnvironmentsRequest& request) const; /** * A Callable wrapper for ListEnvironments that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListEnvironmentsOutcomeCallable ListEnvironmentsCallable(const ListEnvironmentsRequestT& request) const { return SubmitCallable(&ProtonClient::ListEnvironments, request); } /** * An Async wrapper for ListEnvironments that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListEnvironmentsAsync(const ListEnvironmentsRequestT& request, const ListEnvironmentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::ListEnvironments, request, handler, context); } /** *

List linked repositories with detail data.

See Also:

AWS * API Reference

*/ virtual Model::ListRepositoriesOutcome ListRepositories(const Model::ListRepositoriesRequest& request) const; /** * A Callable wrapper for ListRepositories that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListRepositoriesOutcomeCallable ListRepositoriesCallable(const ListRepositoriesRequestT& request) const { return SubmitCallable(&ProtonClient::ListRepositories, request); } /** * An Async wrapper for ListRepositories that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListRepositoriesAsync(const ListRepositoriesRequestT& request, const ListRepositoriesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::ListRepositories, request, handler, context); } /** *

List repository sync definitions with detail data.

See Also:

* AWS * API Reference

*/ virtual Model::ListRepositorySyncDefinitionsOutcome ListRepositorySyncDefinitions(const Model::ListRepositorySyncDefinitionsRequest& request) const; /** * A Callable wrapper for ListRepositorySyncDefinitions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListRepositorySyncDefinitionsOutcomeCallable ListRepositorySyncDefinitionsCallable(const ListRepositorySyncDefinitionsRequestT& request) const { return SubmitCallable(&ProtonClient::ListRepositorySyncDefinitions, request); } /** * An Async wrapper for ListRepositorySyncDefinitions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListRepositorySyncDefinitionsAsync(const ListRepositorySyncDefinitionsRequestT& request, const ListRepositorySyncDefinitionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::ListRepositorySyncDefinitions, request, handler, context); } /** *

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

See Also:

AWS * API Reference

*/ virtual Model::ListServiceInstanceOutputsOutcome ListServiceInstanceOutputs(const Model::ListServiceInstanceOutputsRequest& request) const; /** * A Callable wrapper for ListServiceInstanceOutputs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListServiceInstanceOutputsOutcomeCallable ListServiceInstanceOutputsCallable(const ListServiceInstanceOutputsRequestT& request) const { return SubmitCallable(&ProtonClient::ListServiceInstanceOutputs, request); } /** * An Async wrapper for ListServiceInstanceOutputs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListServiceInstanceOutputsAsync(const ListServiceInstanceOutputsRequestT& request, const ListServiceInstanceOutputsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::ListServiceInstanceOutputs, request, handler, context); } /** *

List provisioned resources for a service instance with details.

See * Also:

AWS * API Reference

*/ virtual Model::ListServiceInstanceProvisionedResourcesOutcome ListServiceInstanceProvisionedResources(const Model::ListServiceInstanceProvisionedResourcesRequest& request) const; /** * A Callable wrapper for ListServiceInstanceProvisionedResources that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListServiceInstanceProvisionedResourcesOutcomeCallable ListServiceInstanceProvisionedResourcesCallable(const ListServiceInstanceProvisionedResourcesRequestT& request) const { return SubmitCallable(&ProtonClient::ListServiceInstanceProvisionedResources, request); } /** * An Async wrapper for ListServiceInstanceProvisionedResources that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListServiceInstanceProvisionedResourcesAsync(const ListServiceInstanceProvisionedResourcesRequestT& request, const ListServiceInstanceProvisionedResourcesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::ListServiceInstanceProvisionedResources, request, handler, context); } /** *

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

*/ virtual Model::ListServiceInstancesOutcome ListServiceInstances(const Model::ListServiceInstancesRequest& request) const; /** * A Callable wrapper for ListServiceInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListServiceInstancesOutcomeCallable ListServiceInstancesCallable(const ListServiceInstancesRequestT& request) const { return SubmitCallable(&ProtonClient::ListServiceInstances, request); } /** * An Async wrapper for ListServiceInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListServiceInstancesAsync(const ListServiceInstancesRequestT& request, const ListServiceInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::ListServiceInstances, request, handler, context); } /** *

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

See Also:

AWS * API Reference

*/ virtual Model::ListServicePipelineOutputsOutcome ListServicePipelineOutputs(const Model::ListServicePipelineOutputsRequest& request) const; /** * A Callable wrapper for ListServicePipelineOutputs that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListServicePipelineOutputsOutcomeCallable ListServicePipelineOutputsCallable(const ListServicePipelineOutputsRequestT& request) const { return SubmitCallable(&ProtonClient::ListServicePipelineOutputs, request); } /** * An Async wrapper for ListServicePipelineOutputs that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListServicePipelineOutputsAsync(const ListServicePipelineOutputsRequestT& request, const ListServicePipelineOutputsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::ListServicePipelineOutputs, request, handler, context); } /** *

List provisioned resources for a service and pipeline with * details.

See Also:

AWS * API Reference

*/ virtual Model::ListServicePipelineProvisionedResourcesOutcome ListServicePipelineProvisionedResources(const Model::ListServicePipelineProvisionedResourcesRequest& request) const; /** * A Callable wrapper for ListServicePipelineProvisionedResources that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListServicePipelineProvisionedResourcesOutcomeCallable ListServicePipelineProvisionedResourcesCallable(const ListServicePipelineProvisionedResourcesRequestT& request) const { return SubmitCallable(&ProtonClient::ListServicePipelineProvisionedResources, request); } /** * An Async wrapper for ListServicePipelineProvisionedResources that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListServicePipelineProvisionedResourcesAsync(const ListServicePipelineProvisionedResourcesRequestT& request, const ListServicePipelineProvisionedResourcesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::ListServicePipelineProvisionedResources, request, handler, context); } /** *

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

See Also:

AWS * API Reference

*/ virtual Model::ListServiceTemplateVersionsOutcome ListServiceTemplateVersions(const Model::ListServiceTemplateVersionsRequest& request) const; /** * A Callable wrapper for ListServiceTemplateVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListServiceTemplateVersionsOutcomeCallable ListServiceTemplateVersionsCallable(const ListServiceTemplateVersionsRequestT& request) const { return SubmitCallable(&ProtonClient::ListServiceTemplateVersions, request); } /** * An Async wrapper for ListServiceTemplateVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListServiceTemplateVersionsAsync(const ListServiceTemplateVersionsRequestT& request, const ListServiceTemplateVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::ListServiceTemplateVersions, request, handler, context); } /** *

List service templates with detail data.

See Also:

AWS * API Reference

*/ virtual Model::ListServiceTemplatesOutcome ListServiceTemplates(const Model::ListServiceTemplatesRequest& request) const; /** * A Callable wrapper for ListServiceTemplates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListServiceTemplatesOutcomeCallable ListServiceTemplatesCallable(const ListServiceTemplatesRequestT& request) const { return SubmitCallable(&ProtonClient::ListServiceTemplates, request); } /** * An Async wrapper for ListServiceTemplates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListServiceTemplatesAsync(const ListServiceTemplatesRequestT& request, const ListServiceTemplatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::ListServiceTemplates, request, handler, context); } /** *

List services with summaries of detail data.

See Also:

AWS * API Reference

*/ virtual Model::ListServicesOutcome ListServices(const Model::ListServicesRequest& request) const; /** * A Callable wrapper for ListServices that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListServicesOutcomeCallable ListServicesCallable(const ListServicesRequestT& request) const { return SubmitCallable(&ProtonClient::ListServices, request); } /** * An Async wrapper for ListServices that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListServicesAsync(const ListServicesRequestT& request, const ListServicesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::ListServices, request, handler, context); } /** *

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

See * Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&ProtonClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::ListTagsForResource, request, handler, context); } /** *

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

*/ virtual Model::NotifyResourceDeploymentStatusChangeOutcome NotifyResourceDeploymentStatusChange(const Model::NotifyResourceDeploymentStatusChangeRequest& request) const; /** * A Callable wrapper for NotifyResourceDeploymentStatusChange that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::NotifyResourceDeploymentStatusChangeOutcomeCallable NotifyResourceDeploymentStatusChangeCallable(const NotifyResourceDeploymentStatusChangeRequestT& request) const { return SubmitCallable(&ProtonClient::NotifyResourceDeploymentStatusChange, request); } /** * An Async wrapper for NotifyResourceDeploymentStatusChange that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void NotifyResourceDeploymentStatusChangeAsync(const NotifyResourceDeploymentStatusChangeRequestT& request, const NotifyResourceDeploymentStatusChangeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::NotifyResourceDeploymentStatusChange, request, handler, context); } /** *

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

*/ virtual Model::RejectEnvironmentAccountConnectionOutcome RejectEnvironmentAccountConnection(const Model::RejectEnvironmentAccountConnectionRequest& request) const; /** * A Callable wrapper for RejectEnvironmentAccountConnection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RejectEnvironmentAccountConnectionOutcomeCallable RejectEnvironmentAccountConnectionCallable(const RejectEnvironmentAccountConnectionRequestT& request) const { return SubmitCallable(&ProtonClient::RejectEnvironmentAccountConnection, request); } /** * An Async wrapper for RejectEnvironmentAccountConnection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RejectEnvironmentAccountConnectionAsync(const RejectEnvironmentAccountConnectionRequestT& request, const RejectEnvironmentAccountConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::RejectEnvironmentAccountConnection, request, handler, context); } /** *

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

*/ virtual Model::TagResourceOutcome TagResource(const Model::TagResourceRequest& request) const; /** * A Callable wrapper for TagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::TagResourceOutcomeCallable TagResourceCallable(const TagResourceRequestT& request) const { return SubmitCallable(&ProtonClient::TagResource, request); } /** * An Async wrapper for TagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void TagResourceAsync(const TagResourceRequestT& request, const TagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::TagResource, request, handler, context); } /** *

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

*/ virtual Model::UntagResourceOutcome UntagResource(const Model::UntagResourceRequest& request) const; /** * A Callable wrapper for UntagResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UntagResourceOutcomeCallable UntagResourceCallable(const UntagResourceRequestT& request) const { return SubmitCallable(&ProtonClient::UntagResource, request); } /** * An Async wrapper for UntagResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UntagResourceAsync(const UntagResourceRequestT& request, const UntagResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::UntagResource, request, handler, context); } /** *

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

See Also:

AWS * API Reference

*/ virtual Model::UpdateAccountSettingsOutcome UpdateAccountSettings(const Model::UpdateAccountSettingsRequest& request) const; /** * A Callable wrapper for UpdateAccountSettings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateAccountSettingsOutcomeCallable UpdateAccountSettingsCallable(const UpdateAccountSettingsRequestT& request) const { return SubmitCallable(&ProtonClient::UpdateAccountSettings, request); } /** * An Async wrapper for UpdateAccountSettings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateAccountSettingsAsync(const UpdateAccountSettingsRequestT& request, const UpdateAccountSettingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::UpdateAccountSettings, request, handler, context); } /** *

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

*/ virtual Model::UpdateComponentOutcome UpdateComponent(const Model::UpdateComponentRequest& request) const; /** * A Callable wrapper for UpdateComponent that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateComponentOutcomeCallable UpdateComponentCallable(const UpdateComponentRequestT& request) const { return SubmitCallable(&ProtonClient::UpdateComponent, request); } /** * An Async wrapper for UpdateComponent that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateComponentAsync(const UpdateComponentRequestT& request, const UpdateComponentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::UpdateComponent, request, handler, context); } /** *

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

*/ virtual Model::UpdateEnvironmentOutcome UpdateEnvironment(const Model::UpdateEnvironmentRequest& request) const; /** * A Callable wrapper for UpdateEnvironment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateEnvironmentOutcomeCallable UpdateEnvironmentCallable(const UpdateEnvironmentRequestT& request) const { return SubmitCallable(&ProtonClient::UpdateEnvironment, request); } /** * An Async wrapper for UpdateEnvironment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateEnvironmentAsync(const UpdateEnvironmentRequestT& request, const UpdateEnvironmentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::UpdateEnvironment, request, handler, context); } /** *

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

*/ virtual Model::UpdateEnvironmentAccountConnectionOutcome UpdateEnvironmentAccountConnection(const Model::UpdateEnvironmentAccountConnectionRequest& request) const; /** * A Callable wrapper for UpdateEnvironmentAccountConnection that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateEnvironmentAccountConnectionOutcomeCallable UpdateEnvironmentAccountConnectionCallable(const UpdateEnvironmentAccountConnectionRequestT& request) const { return SubmitCallable(&ProtonClient::UpdateEnvironmentAccountConnection, request); } /** * An Async wrapper for UpdateEnvironmentAccountConnection that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateEnvironmentAccountConnectionAsync(const UpdateEnvironmentAccountConnectionRequestT& request, const UpdateEnvironmentAccountConnectionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::UpdateEnvironmentAccountConnection, request, handler, context); } /** *

Update an environment template.

See Also:

AWS * API Reference

*/ virtual Model::UpdateEnvironmentTemplateOutcome UpdateEnvironmentTemplate(const Model::UpdateEnvironmentTemplateRequest& request) const; /** * A Callable wrapper for UpdateEnvironmentTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateEnvironmentTemplateOutcomeCallable UpdateEnvironmentTemplateCallable(const UpdateEnvironmentTemplateRequestT& request) const { return SubmitCallable(&ProtonClient::UpdateEnvironmentTemplate, request); } /** * An Async wrapper for UpdateEnvironmentTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateEnvironmentTemplateAsync(const UpdateEnvironmentTemplateRequestT& request, const UpdateEnvironmentTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::UpdateEnvironmentTemplate, request, handler, context); } /** *

Update a major or minor version of an environment template.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateEnvironmentTemplateVersionOutcome UpdateEnvironmentTemplateVersion(const Model::UpdateEnvironmentTemplateVersionRequest& request) const; /** * A Callable wrapper for UpdateEnvironmentTemplateVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateEnvironmentTemplateVersionOutcomeCallable UpdateEnvironmentTemplateVersionCallable(const UpdateEnvironmentTemplateVersionRequestT& request) const { return SubmitCallable(&ProtonClient::UpdateEnvironmentTemplateVersion, request); } /** * An Async wrapper for UpdateEnvironmentTemplateVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateEnvironmentTemplateVersionAsync(const UpdateEnvironmentTemplateVersionRequestT& request, const UpdateEnvironmentTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::UpdateEnvironmentTemplateVersion, request, handler, context); } /** *

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

*/ virtual Model::UpdateServiceOutcome UpdateService(const Model::UpdateServiceRequest& request) const; /** * A Callable wrapper for UpdateService that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateServiceOutcomeCallable UpdateServiceCallable(const UpdateServiceRequestT& request) const { return SubmitCallable(&ProtonClient::UpdateService, request); } /** * An Async wrapper for UpdateService that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateServiceAsync(const UpdateServiceRequestT& request, const UpdateServiceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::UpdateService, request, handler, context); } /** *

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

*/ virtual Model::UpdateServiceInstanceOutcome UpdateServiceInstance(const Model::UpdateServiceInstanceRequest& request) const; /** * A Callable wrapper for UpdateServiceInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateServiceInstanceOutcomeCallable UpdateServiceInstanceCallable(const UpdateServiceInstanceRequestT& request) const { return SubmitCallable(&ProtonClient::UpdateServiceInstance, request); } /** * An Async wrapper for UpdateServiceInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateServiceInstanceAsync(const UpdateServiceInstanceRequestT& request, const UpdateServiceInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::UpdateServiceInstance, request, handler, context); } /** *

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

*/ virtual Model::UpdateServicePipelineOutcome UpdateServicePipeline(const Model::UpdateServicePipelineRequest& request) const; /** * A Callable wrapper for UpdateServicePipeline that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateServicePipelineOutcomeCallable UpdateServicePipelineCallable(const UpdateServicePipelineRequestT& request) const { return SubmitCallable(&ProtonClient::UpdateServicePipeline, request); } /** * An Async wrapper for UpdateServicePipeline that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateServicePipelineAsync(const UpdateServicePipelineRequestT& request, const UpdateServicePipelineResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::UpdateServicePipeline, request, handler, context); } /** *

Update the service sync blocker by resolving it.

See Also:

* AWS * API Reference

*/ virtual Model::UpdateServiceSyncBlockerOutcome UpdateServiceSyncBlocker(const Model::UpdateServiceSyncBlockerRequest& request) const; /** * A Callable wrapper for UpdateServiceSyncBlocker that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateServiceSyncBlockerOutcomeCallable UpdateServiceSyncBlockerCallable(const UpdateServiceSyncBlockerRequestT& request) const { return SubmitCallable(&ProtonClient::UpdateServiceSyncBlocker, request); } /** * An Async wrapper for UpdateServiceSyncBlocker that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateServiceSyncBlockerAsync(const UpdateServiceSyncBlockerRequestT& request, const UpdateServiceSyncBlockerResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::UpdateServiceSyncBlocker, request, handler, context); } /** *

Update the Proton Ops config file.

See Also:

AWS * API Reference

*/ virtual Model::UpdateServiceSyncConfigOutcome UpdateServiceSyncConfig(const Model::UpdateServiceSyncConfigRequest& request) const; /** * A Callable wrapper for UpdateServiceSyncConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateServiceSyncConfigOutcomeCallable UpdateServiceSyncConfigCallable(const UpdateServiceSyncConfigRequestT& request) const { return SubmitCallable(&ProtonClient::UpdateServiceSyncConfig, request); } /** * An Async wrapper for UpdateServiceSyncConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateServiceSyncConfigAsync(const UpdateServiceSyncConfigRequestT& request, const UpdateServiceSyncConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::UpdateServiceSyncConfig, request, handler, context); } /** *

Update a service template.

See Also:

AWS * API Reference

*/ virtual Model::UpdateServiceTemplateOutcome UpdateServiceTemplate(const Model::UpdateServiceTemplateRequest& request) const; /** * A Callable wrapper for UpdateServiceTemplate that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateServiceTemplateOutcomeCallable UpdateServiceTemplateCallable(const UpdateServiceTemplateRequestT& request) const { return SubmitCallable(&ProtonClient::UpdateServiceTemplate, request); } /** * An Async wrapper for UpdateServiceTemplate that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateServiceTemplateAsync(const UpdateServiceTemplateRequestT& request, const UpdateServiceTemplateResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::UpdateServiceTemplate, request, handler, context); } /** *

Update a major or minor version of a service template.

See * Also:

AWS * API Reference

*/ virtual Model::UpdateServiceTemplateVersionOutcome UpdateServiceTemplateVersion(const Model::UpdateServiceTemplateVersionRequest& request) const; /** * A Callable wrapper for UpdateServiceTemplateVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateServiceTemplateVersionOutcomeCallable UpdateServiceTemplateVersionCallable(const UpdateServiceTemplateVersionRequestT& request) const { return SubmitCallable(&ProtonClient::UpdateServiceTemplateVersion, request); } /** * An Async wrapper for UpdateServiceTemplateVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateServiceTemplateVersionAsync(const UpdateServiceTemplateVersionRequestT& request, const UpdateServiceTemplateVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::UpdateServiceTemplateVersion, request, handler, context); } /** *

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

*/ virtual Model::UpdateTemplateSyncConfigOutcome UpdateTemplateSyncConfig(const Model::UpdateTemplateSyncConfigRequest& request) const; /** * A Callable wrapper for UpdateTemplateSyncConfig that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::UpdateTemplateSyncConfigOutcomeCallable UpdateTemplateSyncConfigCallable(const UpdateTemplateSyncConfigRequestT& request) const { return SubmitCallable(&ProtonClient::UpdateTemplateSyncConfig, request); } /** * An Async wrapper for UpdateTemplateSyncConfig that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void UpdateTemplateSyncConfigAsync(const UpdateTemplateSyncConfigRequestT& request, const UpdateTemplateSyncConfigResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&ProtonClient::UpdateTemplateSyncConfig, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const ProtonClientConfiguration& clientConfiguration); ProtonClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace Proton } // namespace Aws