software.amazon.awssdk.services.codestarconnections.CodeStarConnectionsAsyncClient Maven / Gradle / Ivy
/*
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License"). You may not use this file except in compliance with
* the License. A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions
* and limitations under the License.
*/
package software.amazon.awssdk.services.codestarconnections;
import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
import software.amazon.awssdk.annotations.Generated;
import software.amazon.awssdk.annotations.SdkPublicApi;
import software.amazon.awssdk.annotations.ThreadSafe;
import software.amazon.awssdk.awscore.AwsClient;
import software.amazon.awssdk.services.codestarconnections.model.CreateConnectionRequest;
import software.amazon.awssdk.services.codestarconnections.model.CreateConnectionResponse;
import software.amazon.awssdk.services.codestarconnections.model.CreateHostRequest;
import software.amazon.awssdk.services.codestarconnections.model.CreateHostResponse;
import software.amazon.awssdk.services.codestarconnections.model.CreateRepositoryLinkRequest;
import software.amazon.awssdk.services.codestarconnections.model.CreateRepositoryLinkResponse;
import software.amazon.awssdk.services.codestarconnections.model.CreateSyncConfigurationRequest;
import software.amazon.awssdk.services.codestarconnections.model.CreateSyncConfigurationResponse;
import software.amazon.awssdk.services.codestarconnections.model.DeleteConnectionRequest;
import software.amazon.awssdk.services.codestarconnections.model.DeleteConnectionResponse;
import software.amazon.awssdk.services.codestarconnections.model.DeleteHostRequest;
import software.amazon.awssdk.services.codestarconnections.model.DeleteHostResponse;
import software.amazon.awssdk.services.codestarconnections.model.DeleteRepositoryLinkRequest;
import software.amazon.awssdk.services.codestarconnections.model.DeleteRepositoryLinkResponse;
import software.amazon.awssdk.services.codestarconnections.model.DeleteSyncConfigurationRequest;
import software.amazon.awssdk.services.codestarconnections.model.DeleteSyncConfigurationResponse;
import software.amazon.awssdk.services.codestarconnections.model.GetConnectionRequest;
import software.amazon.awssdk.services.codestarconnections.model.GetConnectionResponse;
import software.amazon.awssdk.services.codestarconnections.model.GetHostRequest;
import software.amazon.awssdk.services.codestarconnections.model.GetHostResponse;
import software.amazon.awssdk.services.codestarconnections.model.GetRepositoryLinkRequest;
import software.amazon.awssdk.services.codestarconnections.model.GetRepositoryLinkResponse;
import software.amazon.awssdk.services.codestarconnections.model.GetRepositorySyncStatusRequest;
import software.amazon.awssdk.services.codestarconnections.model.GetRepositorySyncStatusResponse;
import software.amazon.awssdk.services.codestarconnections.model.GetResourceSyncStatusRequest;
import software.amazon.awssdk.services.codestarconnections.model.GetResourceSyncStatusResponse;
import software.amazon.awssdk.services.codestarconnections.model.GetSyncBlockerSummaryRequest;
import software.amazon.awssdk.services.codestarconnections.model.GetSyncBlockerSummaryResponse;
import software.amazon.awssdk.services.codestarconnections.model.GetSyncConfigurationRequest;
import software.amazon.awssdk.services.codestarconnections.model.GetSyncConfigurationResponse;
import software.amazon.awssdk.services.codestarconnections.model.ListConnectionsRequest;
import software.amazon.awssdk.services.codestarconnections.model.ListConnectionsResponse;
import software.amazon.awssdk.services.codestarconnections.model.ListHostsRequest;
import software.amazon.awssdk.services.codestarconnections.model.ListHostsResponse;
import software.amazon.awssdk.services.codestarconnections.model.ListRepositoryLinksRequest;
import software.amazon.awssdk.services.codestarconnections.model.ListRepositoryLinksResponse;
import software.amazon.awssdk.services.codestarconnections.model.ListRepositorySyncDefinitionsRequest;
import software.amazon.awssdk.services.codestarconnections.model.ListRepositorySyncDefinitionsResponse;
import software.amazon.awssdk.services.codestarconnections.model.ListSyncConfigurationsRequest;
import software.amazon.awssdk.services.codestarconnections.model.ListSyncConfigurationsResponse;
import software.amazon.awssdk.services.codestarconnections.model.ListTagsForResourceRequest;
import software.amazon.awssdk.services.codestarconnections.model.ListTagsForResourceResponse;
import software.amazon.awssdk.services.codestarconnections.model.TagResourceRequest;
import software.amazon.awssdk.services.codestarconnections.model.TagResourceResponse;
import software.amazon.awssdk.services.codestarconnections.model.UntagResourceRequest;
import software.amazon.awssdk.services.codestarconnections.model.UntagResourceResponse;
import software.amazon.awssdk.services.codestarconnections.model.UpdateHostRequest;
import software.amazon.awssdk.services.codestarconnections.model.UpdateHostResponse;
import software.amazon.awssdk.services.codestarconnections.model.UpdateRepositoryLinkRequest;
import software.amazon.awssdk.services.codestarconnections.model.UpdateRepositoryLinkResponse;
import software.amazon.awssdk.services.codestarconnections.model.UpdateSyncBlockerRequest;
import software.amazon.awssdk.services.codestarconnections.model.UpdateSyncBlockerResponse;
import software.amazon.awssdk.services.codestarconnections.model.UpdateSyncConfigurationRequest;
import software.amazon.awssdk.services.codestarconnections.model.UpdateSyncConfigurationResponse;
import software.amazon.awssdk.services.codestarconnections.paginators.ListConnectionsPublisher;
import software.amazon.awssdk.services.codestarconnections.paginators.ListHostsPublisher;
import software.amazon.awssdk.services.codestarconnections.paginators.ListRepositoryLinksPublisher;
import software.amazon.awssdk.services.codestarconnections.paginators.ListSyncConfigurationsPublisher;
/**
* Service client for accessing AWS CodeStar connections asynchronously. This can be created using the static
* {@link #builder()} method.The asynchronous client performs non-blocking I/O when configured with any
* {@code SdkAsyncHttpClient} supported in the SDK. However, full non-blocking is not guaranteed as the async client may
* perform blocking calls in some cases such as credentials retrieval and endpoint discovery as part of the async API
* call.
*
* AWS CodeStar Connections
*
* This Amazon Web Services CodeStar Connections API Reference provides descriptions and usage examples of the
* operations and data types for the Amazon Web Services CodeStar Connections API. You can use the connections API to
* work with connections and installations.
*
*
* Connections are configurations that you use to connect Amazon Web Services resources to external code
* repositories. Each connection is a resource that can be given to services such as CodePipeline to connect to a
* third-party repository such as Bitbucket. For example, you can add the connection in CodePipeline so that it triggers
* your pipeline when a code change is made to your third-party code repository. Each connection is named and associated
* with a unique ARN that is used to reference the connection.
*
*
* When you create a connection, the console initiates a third-party connection handshake. Installations are the
* apps that are used to conduct this handshake. For example, the installation for the Bitbucket provider type is the
* Bitbucket app. When you create a connection, you can choose an existing installation or create one.
*
*
* When you want to create a connection to an installed provider type such as GitHub Enterprise Server, you create a
* host for your connections.
*
*
* You can work with connections by calling:
*
*
* -
*
* CreateConnection, which creates a uniquely named connection that can be referenced by services such as
* CodePipeline.
*
*
* -
*
* DeleteConnection, which deletes the specified connection.
*
*
* -
*
* GetConnection, which returns information about the connection, including the connection status.
*
*
* -
*
* ListConnections, which lists the connections associated with your account.
*
*
*
*
* You can work with hosts by calling:
*
*
* -
*
* CreateHost, which creates a host that represents the infrastructure where your provider is installed.
*
*
* -
*
* DeleteHost, which deletes the specified host.
*
*
* -
*
* GetHost, which returns information about the host, including the setup status.
*
*
* -
*
* ListHosts, which lists the hosts associated with your account.
*
*
*
*
* You can work with tags in Amazon Web Services CodeStar Connections by calling the following:
*
*
* -
*
* ListTagsForResource, which gets information about Amazon Web Services tags for a specified Amazon Resource
* Name (ARN) in Amazon Web Services CodeStar Connections.
*
*
* -
*
* TagResource, which adds or updates tags for a resource in Amazon Web Services CodeStar Connections.
*
*
* -
*
* UntagResource, which removes tags for a resource in Amazon Web Services CodeStar Connections.
*
*
*
*
* For information about how to use Amazon Web Services CodeStar Connections, see the Developer Tools User
* Guide.
*
*/
@Generated("software.amazon.awssdk:codegen")
@SdkPublicApi
@ThreadSafe
public interface CodeStarConnectionsAsyncClient extends AwsClient {
String SERVICE_NAME = "codestar-connections";
/**
* Value for looking up the service's metadata from the
* {@link software.amazon.awssdk.regions.ServiceMetadataProvider}.
*/
String SERVICE_METADATA_ID = "codestar-connections";
/**
*
* Creates a connection that can then be given to other Amazon Web Services services like CodePipeline so that it
* can access third-party code repositories. The connection is in pending status until the third-party connection
* handshake is completed from the console.
*
*
* @param createConnectionRequest
* @return A Java Future containing the result of the CreateConnection operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - LimitExceededException Exceeded the maximum limit for connections.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ResourceUnavailableException Resource not found. Verify the ARN for the host resource and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.CreateConnection
* @see AWS API Documentation
*/
default CompletableFuture createConnection(CreateConnectionRequest createConnectionRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a connection that can then be given to other Amazon Web Services services like CodePipeline so that it
* can access third-party code repositories. The connection is in pending status until the third-party connection
* handshake is completed from the console.
*
*
*
* This is a convenience which creates an instance of the {@link CreateConnectionRequest.Builder} avoiding the need
* to create one manually via {@link CreateConnectionRequest#builder()}
*
*
* @param createConnectionRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.CreateConnectionRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the CreateConnection operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - LimitExceededException Exceeded the maximum limit for connections.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ResourceUnavailableException Resource not found. Verify the ARN for the host resource and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.CreateConnection
* @see AWS API Documentation
*/
default CompletableFuture createConnection(
Consumer createConnectionRequest) {
return createConnection(CreateConnectionRequest.builder().applyMutation(createConnectionRequest).build());
}
/**
*
* Creates a resource that represents the infrastructure where a third-party provider is installed. The host is used
* when you create connections to an installed third-party provider type, such as GitHub Enterprise Server. You
* create one host for all connections to that provider.
*
*
*
* A host created through the CLI or the SDK is in `PENDING` status by default. You can make its status `AVAILABLE`
* by setting up the host in the console.
*
*
*
* @param createHostRequest
* @return A Java Future containing the result of the CreateHost operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - LimitExceededException Exceeded the maximum limit for connections.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.CreateHost
* @see AWS API Documentation
*/
default CompletableFuture createHost(CreateHostRequest createHostRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a resource that represents the infrastructure where a third-party provider is installed. The host is used
* when you create connections to an installed third-party provider type, such as GitHub Enterprise Server. You
* create one host for all connections to that provider.
*
*
*
* A host created through the CLI or the SDK is in `PENDING` status by default. You can make its status `AVAILABLE`
* by setting up the host in the console.
*
*
*
* This is a convenience which creates an instance of the {@link CreateHostRequest.Builder} avoiding the need to
* create one manually via {@link CreateHostRequest#builder()}
*
*
* @param createHostRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.CreateHostRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the CreateHost operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - LimitExceededException Exceeded the maximum limit for connections.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.CreateHost
* @see AWS API Documentation
*/
default CompletableFuture createHost(Consumer createHostRequest) {
return createHost(CreateHostRequest.builder().applyMutation(createHostRequest).build());
}
/**
*
* Creates a link to a specified external Git repository. A repository link allows Git sync to monitor and sync
* changes to files in a specified Git repository.
*
*
* @param createRepositoryLinkRequest
* @return A Java Future containing the result of the CreateRepositoryLink operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - LimitExceededException Exceeded the maximum limit for connections.
* - ResourceAlreadyExistsException Unable to create resource. Resource already exists.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.CreateRepositoryLink
* @see AWS API Documentation
*/
default CompletableFuture createRepositoryLink(
CreateRepositoryLinkRequest createRepositoryLinkRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a link to a specified external Git repository. A repository link allows Git sync to monitor and sync
* changes to files in a specified Git repository.
*
*
*
* This is a convenience which creates an instance of the {@link CreateRepositoryLinkRequest.Builder} avoiding the
* need to create one manually via {@link CreateRepositoryLinkRequest#builder()}
*
*
* @param createRepositoryLinkRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.CreateRepositoryLinkRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the CreateRepositoryLink operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - LimitExceededException Exceeded the maximum limit for connections.
* - ResourceAlreadyExistsException Unable to create resource. Resource already exists.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.CreateRepositoryLink
* @see AWS API Documentation
*/
default CompletableFuture createRepositoryLink(
Consumer createRepositoryLinkRequest) {
return createRepositoryLink(CreateRepositoryLinkRequest.builder().applyMutation(createRepositoryLinkRequest).build());
}
/**
*
* Creates a sync configuration which allows Amazon Web Services to sync content from a Git repository to update a
* specified Amazon Web Services resource. Parameters for the sync configuration are determined by the sync type.
*
*
* @param createSyncConfigurationRequest
* @return A Java Future containing the result of the CreateSyncConfiguration operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - LimitExceededException Exceeded the maximum limit for connections.
* - ResourceAlreadyExistsException Unable to create resource. Resource already exists.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.CreateSyncConfiguration
* @see AWS API Documentation
*/
default CompletableFuture createSyncConfiguration(
CreateSyncConfigurationRequest createSyncConfigurationRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a sync configuration which allows Amazon Web Services to sync content from a Git repository to update a
* specified Amazon Web Services resource. Parameters for the sync configuration are determined by the sync type.
*
*
*
* This is a convenience which creates an instance of the {@link CreateSyncConfigurationRequest.Builder} avoiding
* the need to create one manually via {@link CreateSyncConfigurationRequest#builder()}
*
*
* @param createSyncConfigurationRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.CreateSyncConfigurationRequest.Builder}
* to create a request.
* @return A Java Future containing the result of the CreateSyncConfiguration operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - LimitExceededException Exceeded the maximum limit for connections.
* - ResourceAlreadyExistsException Unable to create resource. Resource already exists.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.CreateSyncConfiguration
* @see AWS API Documentation
*/
default CompletableFuture createSyncConfiguration(
Consumer createSyncConfigurationRequest) {
return createSyncConfiguration(CreateSyncConfigurationRequest.builder().applyMutation(createSyncConfigurationRequest)
.build());
}
/**
*
* The connection to be deleted.
*
*
* @param deleteConnectionRequest
* @return A Java Future containing the result of the DeleteConnection operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.DeleteConnection
* @see AWS API Documentation
*/
default CompletableFuture deleteConnection(DeleteConnectionRequest deleteConnectionRequest) {
throw new UnsupportedOperationException();
}
/**
*
* The connection to be deleted.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteConnectionRequest.Builder} avoiding the need
* to create one manually via {@link DeleteConnectionRequest#builder()}
*
*
* @param deleteConnectionRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.DeleteConnectionRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the DeleteConnection operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.DeleteConnection
* @see AWS API Documentation
*/
default CompletableFuture deleteConnection(
Consumer deleteConnectionRequest) {
return deleteConnection(DeleteConnectionRequest.builder().applyMutation(deleteConnectionRequest).build());
}
/**
*
* The host to be deleted. Before you delete a host, all connections associated to the host must be deleted.
*
*
*
* A host cannot be deleted if it is in the VPC_CONFIG_INITIALIZING or VPC_CONFIG_DELETING state.
*
*
*
* @param deleteHostRequest
* @return A Java Future containing the result of the DeleteHost operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ResourceUnavailableException Resource not found. Verify the ARN for the host resource and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.DeleteHost
* @see AWS API Documentation
*/
default CompletableFuture deleteHost(DeleteHostRequest deleteHostRequest) {
throw new UnsupportedOperationException();
}
/**
*
* The host to be deleted. Before you delete a host, all connections associated to the host must be deleted.
*
*
*
* A host cannot be deleted if it is in the VPC_CONFIG_INITIALIZING or VPC_CONFIG_DELETING state.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteHostRequest.Builder} avoiding the need to
* create one manually via {@link DeleteHostRequest#builder()}
*
*
* @param deleteHostRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.DeleteHostRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DeleteHost operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ResourceUnavailableException Resource not found. Verify the ARN for the host resource and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.DeleteHost
* @see AWS API Documentation
*/
default CompletableFuture deleteHost(Consumer deleteHostRequest) {
return deleteHost(DeleteHostRequest.builder().applyMutation(deleteHostRequest).build());
}
/**
*
* Deletes the association between your connection and a specified external Git repository.
*
*
* @param deleteRepositoryLinkRequest
* @return A Java Future containing the result of the DeleteRepositoryLink operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - SyncConfigurationStillExistsException Unable to continue. The sync blocker still exists.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - UnsupportedProviderTypeException The specified provider type is not supported for connections.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.DeleteRepositoryLink
* @see AWS API Documentation
*/
default CompletableFuture deleteRepositoryLink(
DeleteRepositoryLinkRequest deleteRepositoryLinkRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Deletes the association between your connection and a specified external Git repository.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteRepositoryLinkRequest.Builder} avoiding the
* need to create one manually via {@link DeleteRepositoryLinkRequest#builder()}
*
*
* @param deleteRepositoryLinkRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.DeleteRepositoryLinkRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the DeleteRepositoryLink operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - SyncConfigurationStillExistsException Unable to continue. The sync blocker still exists.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - UnsupportedProviderTypeException The specified provider type is not supported for connections.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.DeleteRepositoryLink
* @see AWS API Documentation
*/
default CompletableFuture deleteRepositoryLink(
Consumer deleteRepositoryLinkRequest) {
return deleteRepositoryLink(DeleteRepositoryLinkRequest.builder().applyMutation(deleteRepositoryLinkRequest).build());
}
/**
*
* Deletes the sync configuration for a specified repository and connection.
*
*
* @param deleteSyncConfigurationRequest
* @return A Java Future containing the result of the DeleteSyncConfiguration operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - LimitExceededException Exceeded the maximum limit for connections.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.DeleteSyncConfiguration
* @see AWS API Documentation
*/
default CompletableFuture deleteSyncConfiguration(
DeleteSyncConfigurationRequest deleteSyncConfigurationRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Deletes the sync configuration for a specified repository and connection.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteSyncConfigurationRequest.Builder} avoiding
* the need to create one manually via {@link DeleteSyncConfigurationRequest#builder()}
*
*
* @param deleteSyncConfigurationRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.DeleteSyncConfigurationRequest.Builder}
* to create a request.
* @return A Java Future containing the result of the DeleteSyncConfiguration operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - LimitExceededException Exceeded the maximum limit for connections.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.DeleteSyncConfiguration
* @see AWS API Documentation
*/
default CompletableFuture deleteSyncConfiguration(
Consumer deleteSyncConfigurationRequest) {
return deleteSyncConfiguration(DeleteSyncConfigurationRequest.builder().applyMutation(deleteSyncConfigurationRequest)
.build());
}
/**
*
* Returns the connection ARN and details such as status, owner, and provider type.
*
*
* @param getConnectionRequest
* @return A Java Future containing the result of the GetConnection operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ResourceUnavailableException Resource not found. Verify the ARN for the host resource and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.GetConnection
* @see AWS API Documentation
*/
default CompletableFuture getConnection(GetConnectionRequest getConnectionRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns the connection ARN and details such as status, owner, and provider type.
*
*
*
* This is a convenience which creates an instance of the {@link GetConnectionRequest.Builder} avoiding the need to
* create one manually via {@link GetConnectionRequest#builder()}
*
*
* @param getConnectionRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.GetConnectionRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the GetConnection operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ResourceUnavailableException Resource not found. Verify the ARN for the host resource and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.GetConnection
* @see AWS API Documentation
*/
default CompletableFuture getConnection(Consumer getConnectionRequest) {
return getConnection(GetConnectionRequest.builder().applyMutation(getConnectionRequest).build());
}
/**
*
* Returns the host ARN and details such as status, provider type, endpoint, and, if applicable, the VPC
* configuration.
*
*
* @param getHostRequest
* @return A Java Future containing the result of the GetHost operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ResourceUnavailableException Resource not found. Verify the ARN for the host resource and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.GetHost
* @see AWS
* API Documentation
*/
default CompletableFuture getHost(GetHostRequest getHostRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns the host ARN and details such as status, provider type, endpoint, and, if applicable, the VPC
* configuration.
*
*
*
* This is a convenience which creates an instance of the {@link GetHostRequest.Builder} avoiding the need to create
* one manually via {@link GetHostRequest#builder()}
*
*
* @param getHostRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.GetHostRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the GetHost operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ResourceUnavailableException Resource not found. Verify the ARN for the host resource and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.GetHost
* @see AWS
* API Documentation
*/
default CompletableFuture getHost(Consumer getHostRequest) {
return getHost(GetHostRequest.builder().applyMutation(getHostRequest).build());
}
/**
*
* Returns details about a repository link. A repository link allows Git sync to monitor and sync changes from files
* in a specified Git repository.
*
*
* @param getRepositoryLinkRequest
* @return A Java Future containing the result of the GetRepositoryLink operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.GetRepositoryLink
* @see AWS API Documentation
*/
default CompletableFuture getRepositoryLink(GetRepositoryLinkRequest getRepositoryLinkRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns details about a repository link. A repository link allows Git sync to monitor and sync changes from files
* in a specified Git repository.
*
*
*
* This is a convenience which creates an instance of the {@link GetRepositoryLinkRequest.Builder} avoiding the need
* to create one manually via {@link GetRepositoryLinkRequest#builder()}
*
*
* @param getRepositoryLinkRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.GetRepositoryLinkRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the GetRepositoryLink operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.GetRepositoryLink
* @see AWS API Documentation
*/
default CompletableFuture getRepositoryLink(
Consumer getRepositoryLinkRequest) {
return getRepositoryLink(GetRepositoryLinkRequest.builder().applyMutation(getRepositoryLinkRequest).build());
}
/**
*
* Returns details about the sync status for a repository. A repository sync uses Git sync to push and pull changes
* from your remote repository.
*
*
* @param getRepositorySyncStatusRequest
* @return A Java Future containing the result of the GetRepositorySyncStatus operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.GetRepositorySyncStatus
* @see AWS API Documentation
*/
default CompletableFuture getRepositorySyncStatus(
GetRepositorySyncStatusRequest getRepositorySyncStatusRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns details about the sync status for a repository. A repository sync uses Git sync to push and pull changes
* from your remote repository.
*
*
*
* This is a convenience which creates an instance of the {@link GetRepositorySyncStatusRequest.Builder} avoiding
* the need to create one manually via {@link GetRepositorySyncStatusRequest#builder()}
*
*
* @param getRepositorySyncStatusRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.GetRepositorySyncStatusRequest.Builder}
* to create a request.
* @return A Java Future containing the result of the GetRepositorySyncStatus operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.GetRepositorySyncStatus
* @see AWS API Documentation
*/
default CompletableFuture getRepositorySyncStatus(
Consumer getRepositorySyncStatusRequest) {
return getRepositorySyncStatus(GetRepositorySyncStatusRequest.builder().applyMutation(getRepositorySyncStatusRequest)
.build());
}
/**
*
* Returns the status of the sync with the Git repository for a specific Amazon Web Services resource.
*
*
* @param getResourceSyncStatusRequest
* @return A Java Future containing the result of the GetResourceSyncStatus operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.GetResourceSyncStatus
* @see AWS API Documentation
*/
default CompletableFuture getResourceSyncStatus(
GetResourceSyncStatusRequest getResourceSyncStatusRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns the status of the sync with the Git repository for a specific Amazon Web Services resource.
*
*
*
* This is a convenience which creates an instance of the {@link GetResourceSyncStatusRequest.Builder} avoiding the
* need to create one manually via {@link GetResourceSyncStatusRequest#builder()}
*
*
* @param getResourceSyncStatusRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.GetResourceSyncStatusRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the GetResourceSyncStatus operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.GetResourceSyncStatus
* @see AWS API Documentation
*/
default CompletableFuture getResourceSyncStatus(
Consumer getResourceSyncStatusRequest) {
return getResourceSyncStatus(GetResourceSyncStatusRequest.builder().applyMutation(getResourceSyncStatusRequest).build());
}
/**
*
* Returns a list of the most recent sync blockers.
*
*
* @param getSyncBlockerSummaryRequest
* @return A Java Future containing the result of the GetSyncBlockerSummary operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.GetSyncBlockerSummary
* @see AWS API Documentation
*/
default CompletableFuture getSyncBlockerSummary(
GetSyncBlockerSummaryRequest getSyncBlockerSummaryRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns a list of the most recent sync blockers.
*
*
*
* This is a convenience which creates an instance of the {@link GetSyncBlockerSummaryRequest.Builder} avoiding the
* need to create one manually via {@link GetSyncBlockerSummaryRequest#builder()}
*
*
* @param getSyncBlockerSummaryRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.GetSyncBlockerSummaryRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the GetSyncBlockerSummary operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.GetSyncBlockerSummary
* @see AWS API Documentation
*/
default CompletableFuture getSyncBlockerSummary(
Consumer getSyncBlockerSummaryRequest) {
return getSyncBlockerSummary(GetSyncBlockerSummaryRequest.builder().applyMutation(getSyncBlockerSummaryRequest).build());
}
/**
*
* Returns details about a sync configuration, including the sync type and resource name. A sync configuration
* allows the configuration to sync (push and pull) changes from the remote repository for a specified branch in a
* Git repository.
*
*
* @param getSyncConfigurationRequest
* @return A Java Future containing the result of the GetSyncConfiguration operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.GetSyncConfiguration
* @see AWS API Documentation
*/
default CompletableFuture getSyncConfiguration(
GetSyncConfigurationRequest getSyncConfigurationRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns details about a sync configuration, including the sync type and resource name. A sync configuration
* allows the configuration to sync (push and pull) changes from the remote repository for a specified branch in a
* Git repository.
*
*
*
* This is a convenience which creates an instance of the {@link GetSyncConfigurationRequest.Builder} avoiding the
* need to create one manually via {@link GetSyncConfigurationRequest#builder()}
*
*
* @param getSyncConfigurationRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.GetSyncConfigurationRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the GetSyncConfiguration operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.GetSyncConfiguration
* @see AWS API Documentation
*/
default CompletableFuture getSyncConfiguration(
Consumer getSyncConfigurationRequest) {
return getSyncConfiguration(GetSyncConfigurationRequest.builder().applyMutation(getSyncConfigurationRequest).build());
}
/**
*
* Lists the connections associated with your account.
*
*
* @param listConnectionsRequest
* @return A Java Future containing the result of the ListConnections operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.ListConnections
* @see AWS API Documentation
*/
default CompletableFuture listConnections(ListConnectionsRequest listConnectionsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Lists the connections associated with your account.
*
*
*
* This is a convenience which creates an instance of the {@link ListConnectionsRequest.Builder} avoiding the need
* to create one manually via {@link ListConnectionsRequest#builder()}
*
*
* @param listConnectionsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.ListConnectionsRequest.Builder} to create
* a request.
* @return A Java Future containing the result of the ListConnections operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.ListConnections
* @see AWS API Documentation
*/
default CompletableFuture listConnections(
Consumer listConnectionsRequest) {
return listConnections(ListConnectionsRequest.builder().applyMutation(listConnectionsRequest).build());
}
/**
*
* This is a variant of
* {@link #listConnections(software.amazon.awssdk.services.codestarconnections.model.ListConnectionsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.codestarconnections.paginators.ListConnectionsPublisher publisher = client.listConnectionsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.codestarconnections.paginators.ListConnectionsPublisher publisher = client.listConnectionsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.codestarconnections.model.ListConnectionsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listConnections(software.amazon.awssdk.services.codestarconnections.model.ListConnectionsRequest)}
* operation.
*
*
* @param listConnectionsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.ListConnections
* @see AWS API Documentation
*/
default ListConnectionsPublisher listConnectionsPaginator(ListConnectionsRequest listConnectionsRequest) {
return new ListConnectionsPublisher(this, listConnectionsRequest);
}
/**
*
* This is a variant of
* {@link #listConnections(software.amazon.awssdk.services.codestarconnections.model.ListConnectionsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.codestarconnections.paginators.ListConnectionsPublisher publisher = client.listConnectionsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.codestarconnections.paginators.ListConnectionsPublisher publisher = client.listConnectionsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.codestarconnections.model.ListConnectionsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listConnections(software.amazon.awssdk.services.codestarconnections.model.ListConnectionsRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link ListConnectionsRequest.Builder} avoiding the need
* to create one manually via {@link ListConnectionsRequest#builder()}
*
*
* @param listConnectionsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.ListConnectionsRequest.Builder} to create
* a request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.ListConnections
* @see AWS API Documentation
*/
default ListConnectionsPublisher listConnectionsPaginator(Consumer listConnectionsRequest) {
return listConnectionsPaginator(ListConnectionsRequest.builder().applyMutation(listConnectionsRequest).build());
}
/**
*
* Lists the hosts associated with your account.
*
*
* @param listHostsRequest
* @return A Java Future containing the result of the ListHosts operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.ListHosts
* @see AWS API Documentation
*/
default CompletableFuture listHosts(ListHostsRequest listHostsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Lists the hosts associated with your account.
*
*
*
* This is a convenience which creates an instance of the {@link ListHostsRequest.Builder} avoiding the need to
* create one manually via {@link ListHostsRequest#builder()}
*
*
* @param listHostsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.ListHostsRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the ListHosts operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.ListHosts
* @see AWS API Documentation
*/
default CompletableFuture listHosts(Consumer listHostsRequest) {
return listHosts(ListHostsRequest.builder().applyMutation(listHostsRequest).build());
}
/**
*
* This is a variant of
* {@link #listHosts(software.amazon.awssdk.services.codestarconnections.model.ListHostsRequest)} operation. The
* return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.codestarconnections.paginators.ListHostsPublisher publisher = client.listHostsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.codestarconnections.paginators.ListHostsPublisher publisher = client.listHostsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.codestarconnections.model.ListHostsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listHosts(software.amazon.awssdk.services.codestarconnections.model.ListHostsRequest)} operation.
*
*
* @param listHostsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.ListHosts
* @see AWS API Documentation
*/
default ListHostsPublisher listHostsPaginator(ListHostsRequest listHostsRequest) {
return new ListHostsPublisher(this, listHostsRequest);
}
/**
*
* This is a variant of
* {@link #listHosts(software.amazon.awssdk.services.codestarconnections.model.ListHostsRequest)} operation. The
* return type is a custom publisher that can be subscribed to request a stream of response pages. SDK will
* internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.codestarconnections.paginators.ListHostsPublisher publisher = client.listHostsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.codestarconnections.paginators.ListHostsPublisher publisher = client.listHostsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.codestarconnections.model.ListHostsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listHosts(software.amazon.awssdk.services.codestarconnections.model.ListHostsRequest)} operation.
*
*
*
* This is a convenience which creates an instance of the {@link ListHostsRequest.Builder} avoiding the need to
* create one manually via {@link ListHostsRequest#builder()}
*
*
* @param listHostsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.ListHostsRequest.Builder} to create a
* request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.ListHosts
* @see AWS API Documentation
*/
default ListHostsPublisher listHostsPaginator(Consumer listHostsRequest) {
return listHostsPaginator(ListHostsRequest.builder().applyMutation(listHostsRequest).build());
}
/**
*
* Lists the repository links created for connections in your account.
*
*
* @param listRepositoryLinksRequest
* @return A Java Future containing the result of the ListRepositoryLinks operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.ListRepositoryLinks
* @see AWS API Documentation
*/
default CompletableFuture listRepositoryLinks(
ListRepositoryLinksRequest listRepositoryLinksRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Lists the repository links created for connections in your account.
*
*
*
* This is a convenience which creates an instance of the {@link ListRepositoryLinksRequest.Builder} avoiding the
* need to create one manually via {@link ListRepositoryLinksRequest#builder()}
*
*
* @param listRepositoryLinksRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.ListRepositoryLinksRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the ListRepositoryLinks operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.ListRepositoryLinks
* @see AWS API Documentation
*/
default CompletableFuture listRepositoryLinks(
Consumer listRepositoryLinksRequest) {
return listRepositoryLinks(ListRepositoryLinksRequest.builder().applyMutation(listRepositoryLinksRequest).build());
}
/**
*
* This is a variant of
* {@link #listRepositoryLinks(software.amazon.awssdk.services.codestarconnections.model.ListRepositoryLinksRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.codestarconnections.paginators.ListRepositoryLinksPublisher publisher = client.listRepositoryLinksPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.codestarconnections.paginators.ListRepositoryLinksPublisher publisher = client.listRepositoryLinksPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.codestarconnections.model.ListRepositoryLinksResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listRepositoryLinks(software.amazon.awssdk.services.codestarconnections.model.ListRepositoryLinksRequest)}
* operation.
*
*
* @param listRepositoryLinksRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.ListRepositoryLinks
* @see AWS API Documentation
*/
default ListRepositoryLinksPublisher listRepositoryLinksPaginator(ListRepositoryLinksRequest listRepositoryLinksRequest) {
return new ListRepositoryLinksPublisher(this, listRepositoryLinksRequest);
}
/**
*
* This is a variant of
* {@link #listRepositoryLinks(software.amazon.awssdk.services.codestarconnections.model.ListRepositoryLinksRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.codestarconnections.paginators.ListRepositoryLinksPublisher publisher = client.listRepositoryLinksPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.codestarconnections.paginators.ListRepositoryLinksPublisher publisher = client.listRepositoryLinksPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.codestarconnections.model.ListRepositoryLinksResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listRepositoryLinks(software.amazon.awssdk.services.codestarconnections.model.ListRepositoryLinksRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link ListRepositoryLinksRequest.Builder} avoiding the
* need to create one manually via {@link ListRepositoryLinksRequest#builder()}
*
*
* @param listRepositoryLinksRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.ListRepositoryLinksRequest.Builder} to
* create a request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.ListRepositoryLinks
* @see AWS API Documentation
*/
default ListRepositoryLinksPublisher listRepositoryLinksPaginator(
Consumer listRepositoryLinksRequest) {
return listRepositoryLinksPaginator(ListRepositoryLinksRequest.builder().applyMutation(listRepositoryLinksRequest)
.build());
}
/**
*
* Lists the repository sync definitions for repository links in your account.
*
*
* @param listRepositorySyncDefinitionsRequest
* @return A Java Future containing the result of the ListRepositorySyncDefinitions operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.ListRepositorySyncDefinitions
* @see AWS API Documentation
*/
default CompletableFuture listRepositorySyncDefinitions(
ListRepositorySyncDefinitionsRequest listRepositorySyncDefinitionsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Lists the repository sync definitions for repository links in your account.
*
*
*
* This is a convenience which creates an instance of the {@link ListRepositorySyncDefinitionsRequest.Builder}
* avoiding the need to create one manually via {@link ListRepositorySyncDefinitionsRequest#builder()}
*
*
* @param listRepositorySyncDefinitionsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.ListRepositorySyncDefinitionsRequest.Builder}
* to create a request.
* @return A Java Future containing the result of the ListRepositorySyncDefinitions operation returned by the
* service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.ListRepositorySyncDefinitions
* @see AWS API Documentation
*/
default CompletableFuture listRepositorySyncDefinitions(
Consumer listRepositorySyncDefinitionsRequest) {
return listRepositorySyncDefinitions(ListRepositorySyncDefinitionsRequest.builder()
.applyMutation(listRepositorySyncDefinitionsRequest).build());
}
/**
*
* Returns a list of sync configurations for a specified repository.
*
*
* @param listSyncConfigurationsRequest
* @return A Java Future containing the result of the ListSyncConfigurations operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.ListSyncConfigurations
* @see AWS API Documentation
*/
default CompletableFuture listSyncConfigurations(
ListSyncConfigurationsRequest listSyncConfigurationsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Returns a list of sync configurations for a specified repository.
*
*
*
* This is a convenience which creates an instance of the {@link ListSyncConfigurationsRequest.Builder} avoiding the
* need to create one manually via {@link ListSyncConfigurationsRequest#builder()}
*
*
* @param listSyncConfigurationsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.ListSyncConfigurationsRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the ListSyncConfigurations operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.ListSyncConfigurations
* @see AWS API Documentation
*/
default CompletableFuture listSyncConfigurations(
Consumer listSyncConfigurationsRequest) {
return listSyncConfigurations(ListSyncConfigurationsRequest.builder().applyMutation(listSyncConfigurationsRequest)
.build());
}
/**
*
* This is a variant of
* {@link #listSyncConfigurations(software.amazon.awssdk.services.codestarconnections.model.ListSyncConfigurationsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.codestarconnections.paginators.ListSyncConfigurationsPublisher publisher = client.listSyncConfigurationsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.codestarconnections.paginators.ListSyncConfigurationsPublisher publisher = client.listSyncConfigurationsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.codestarconnections.model.ListSyncConfigurationsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listSyncConfigurations(software.amazon.awssdk.services.codestarconnections.model.ListSyncConfigurationsRequest)}
* operation.
*
*
* @param listSyncConfigurationsRequest
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.ListSyncConfigurations
* @see AWS API Documentation
*/
default ListSyncConfigurationsPublisher listSyncConfigurationsPaginator(
ListSyncConfigurationsRequest listSyncConfigurationsRequest) {
return new ListSyncConfigurationsPublisher(this, listSyncConfigurationsRequest);
}
/**
*
* This is a variant of
* {@link #listSyncConfigurations(software.amazon.awssdk.services.codestarconnections.model.ListSyncConfigurationsRequest)}
* operation. The return type is a custom publisher that can be subscribed to request a stream of response pages.
* SDK will internally handle making service calls for you.
*
*
* When the operation is called, an instance of this class is returned. At this point, no service calls are made yet
* and so there is no guarantee that the request is valid. If there are errors in your request, you will see the
* failures only after you start streaming the data. The subscribe method should be called as a request to start
* streaming data. For more info, see
* {@link org.reactivestreams.Publisher#subscribe(org.reactivestreams.Subscriber)}. Each call to the subscribe
* method will result in a new {@link org.reactivestreams.Subscription} i.e., a new contract to stream data from the
* starting request.
*
*
*
* The following are few ways to use the response class:
*
* 1) Using the subscribe helper method
*
*
* {@code
* software.amazon.awssdk.services.codestarconnections.paginators.ListSyncConfigurationsPublisher publisher = client.listSyncConfigurationsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.codestarconnections.paginators.ListSyncConfigurationsPublisher publisher = client.listSyncConfigurationsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.codestarconnections.model.ListSyncConfigurationsResponse response) { //... };
* });}
*
*
* As the response is a publisher, it can work well with third party reactive streams implementations like RxJava2.
*
* Please notice that the configuration of MaxResults won't limit the number of results you get with the
* paginator. It only limits the number of results in each page.
*
*
* Note: If you prefer to have control on service calls, use the
* {@link #listSyncConfigurations(software.amazon.awssdk.services.codestarconnections.model.ListSyncConfigurationsRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link ListSyncConfigurationsRequest.Builder} avoiding the
* need to create one manually via {@link ListSyncConfigurationsRequest#builder()}
*
*
* @param listSyncConfigurationsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.ListSyncConfigurationsRequest.Builder} to
* create a request.
* @return A custom publisher that can be subscribed to request a stream of response pages.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.ListSyncConfigurations
* @see AWS API Documentation
*/
default ListSyncConfigurationsPublisher listSyncConfigurationsPaginator(
Consumer listSyncConfigurationsRequest) {
return listSyncConfigurationsPaginator(ListSyncConfigurationsRequest.builder()
.applyMutation(listSyncConfigurationsRequest).build());
}
/**
*
* Gets the set of key-value pairs (metadata) that are used to manage the resource.
*
*
* @param listTagsForResourceRequest
* @return A Java Future containing the result of the ListTagsForResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.ListTagsForResource
* @see AWS API Documentation
*/
default CompletableFuture listTagsForResource(
ListTagsForResourceRequest listTagsForResourceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Gets the set of key-value pairs (metadata) that are used to manage the resource.
*
*
*
* This is a convenience which creates an instance of the {@link ListTagsForResourceRequest.Builder} avoiding the
* need to create one manually via {@link ListTagsForResourceRequest#builder()}
*
*
* @param listTagsForResourceRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.ListTagsForResourceRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the ListTagsForResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.ListTagsForResource
* @see AWS API Documentation
*/
default CompletableFuture listTagsForResource(
Consumer listTagsForResourceRequest) {
return listTagsForResource(ListTagsForResourceRequest.builder().applyMutation(listTagsForResourceRequest).build());
}
/**
*
* Adds to or modifies the tags of the given resource. Tags are metadata that can be used to manage a resource.
*
*
* @param tagResourceRequest
* @return A Java Future containing the result of the TagResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - LimitExceededException Exceeded the maximum limit for connections.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.TagResource
* @see AWS API Documentation
*/
default CompletableFuture tagResource(TagResourceRequest tagResourceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Adds to or modifies the tags of the given resource. Tags are metadata that can be used to manage a resource.
*
*
*
* This is a convenience which creates an instance of the {@link TagResourceRequest.Builder} avoiding the need to
* create one manually via {@link TagResourceRequest#builder()}
*
*
* @param tagResourceRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.TagResourceRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the TagResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - LimitExceededException Exceeded the maximum limit for connections.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.TagResource
* @see AWS API Documentation
*/
default CompletableFuture tagResource(Consumer tagResourceRequest) {
return tagResource(TagResourceRequest.builder().applyMutation(tagResourceRequest).build());
}
/**
*
* Removes tags from an Amazon Web Services resource.
*
*
* @param untagResourceRequest
* @return A Java Future containing the result of the UntagResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.UntagResource
* @see AWS API Documentation
*/
default CompletableFuture untagResource(UntagResourceRequest untagResourceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Removes tags from an Amazon Web Services resource.
*
*
*
* This is a convenience which creates an instance of the {@link UntagResourceRequest.Builder} avoiding the need to
* create one manually via {@link UntagResourceRequest#builder()}
*
*
* @param untagResourceRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.UntagResourceRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the UntagResource operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.UntagResource
* @see AWS API Documentation
*/
default CompletableFuture untagResource(Consumer untagResourceRequest) {
return untagResource(UntagResourceRequest.builder().applyMutation(untagResourceRequest).build());
}
/**
*
* Updates a specified host with the provided configurations.
*
*
* @param updateHostRequest
* @return A Java Future containing the result of the UpdateHost operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ConflictException Two conflicting operations have been made on the same resource.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ResourceUnavailableException Resource not found. Verify the ARN for the host resource and try again.
* - UnsupportedOperationException The operation is not supported. Check the connection status and try
* again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.UpdateHost
* @see AWS API Documentation
*/
default CompletableFuture updateHost(UpdateHostRequest updateHostRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Updates a specified host with the provided configurations.
*
*
*
* This is a convenience which creates an instance of the {@link UpdateHostRequest.Builder} avoiding the need to
* create one manually via {@link UpdateHostRequest#builder()}
*
*
* @param updateHostRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.UpdateHostRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the UpdateHost operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - ConflictException Two conflicting operations have been made on the same resource.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ResourceUnavailableException Resource not found. Verify the ARN for the host resource and try again.
* - UnsupportedOperationException The operation is not supported. Check the connection status and try
* again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.UpdateHost
* @see AWS API Documentation
*/
default CompletableFuture updateHost(Consumer updateHostRequest) {
return updateHost(UpdateHostRequest.builder().applyMutation(updateHostRequest).build());
}
/**
*
* Updates the association between your connection and a specified external Git repository. A repository link allows
* Git sync to monitor and sync changes to files in a specified Git repository.
*
*
* @param updateRepositoryLinkRequest
* @return A Java Future containing the result of the UpdateRepositoryLink operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - ConditionalCheckFailedException The conditional check failed. Try again later.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - UpdateOutOfSyncException The update is out of sync. Try syncing again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.UpdateRepositoryLink
* @see AWS API Documentation
*/
default CompletableFuture updateRepositoryLink(
UpdateRepositoryLinkRequest updateRepositoryLinkRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Updates the association between your connection and a specified external Git repository. A repository link allows
* Git sync to monitor and sync changes to files in a specified Git repository.
*
*
*
* This is a convenience which creates an instance of the {@link UpdateRepositoryLinkRequest.Builder} avoiding the
* need to create one manually via {@link UpdateRepositoryLinkRequest#builder()}
*
*
* @param updateRepositoryLinkRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.UpdateRepositoryLinkRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the UpdateRepositoryLink operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - ConditionalCheckFailedException The conditional check failed. Try again later.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - UpdateOutOfSyncException The update is out of sync. Try syncing again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.UpdateRepositoryLink
* @see AWS API Documentation
*/
default CompletableFuture updateRepositoryLink(
Consumer updateRepositoryLinkRequest) {
return updateRepositoryLink(UpdateRepositoryLinkRequest.builder().applyMutation(updateRepositoryLinkRequest).build());
}
/**
*
* Allows you to update the status of a sync blocker, resolving the blocker and allowing syncing to continue.
*
*
* @param updateSyncBlockerRequest
* @return A Java Future containing the result of the UpdateSyncBlocker operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - RetryLatestCommitFailedException Retrying the latest commit failed. Try again later.
* - SyncBlockerDoesNotExistException Unable to continue. The sync blocker does not exist.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.UpdateSyncBlocker
* @see AWS API Documentation
*/
default CompletableFuture updateSyncBlocker(UpdateSyncBlockerRequest updateSyncBlockerRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Allows you to update the status of a sync blocker, resolving the blocker and allowing syncing to continue.
*
*
*
* This is a convenience which creates an instance of the {@link UpdateSyncBlockerRequest.Builder} avoiding the need
* to create one manually via {@link UpdateSyncBlockerRequest#builder()}
*
*
* @param updateSyncBlockerRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.UpdateSyncBlockerRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the UpdateSyncBlocker operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - RetryLatestCommitFailedException Retrying the latest commit failed. Try again later.
* - SyncBlockerDoesNotExistException Unable to continue. The sync blocker does not exist.
* - ThrottlingException The request was denied due to request throttling.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.UpdateSyncBlocker
* @see AWS API Documentation
*/
default CompletableFuture updateSyncBlocker(
Consumer updateSyncBlockerRequest) {
return updateSyncBlocker(UpdateSyncBlockerRequest.builder().applyMutation(updateSyncBlockerRequest).build());
}
/**
*
* Updates the sync configuration for your connection and a specified external Git repository.
*
*
* @param updateSyncConfigurationRequest
* @return A Java Future containing the result of the UpdateSyncConfiguration operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - UpdateOutOfSyncException The update is out of sync. Try syncing again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.UpdateSyncConfiguration
* @see AWS API Documentation
*/
default CompletableFuture updateSyncConfiguration(
UpdateSyncConfigurationRequest updateSyncConfigurationRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Updates the sync configuration for your connection and a specified external Git repository.
*
*
*
* This is a convenience which creates an instance of the {@link UpdateSyncConfigurationRequest.Builder} avoiding
* the need to create one manually via {@link UpdateSyncConfigurationRequest#builder()}
*
*
* @param updateSyncConfigurationRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.codestarconnections.model.UpdateSyncConfigurationRequest.Builder}
* to create a request.
* @return A Java Future containing the result of the UpdateSyncConfiguration operation returned by the service.
* The CompletableFuture returned by this method can be completed exceptionally with the following
* exceptions. The exception returned is wrapped with CompletionException, so you need to invoke
* {@link Throwable#getCause} to retrieve the underlying exception.
*
* - AccessDeniedException You do not have sufficient access to perform this action.
* - ConcurrentModificationException Exception thrown as a result of concurrent modification to an
* application. For example, two individuals attempting to edit the same application at the same time.
* - InternalServerException Received an internal server exception. Try again later.
* - InvalidInputException The input is not valid. Verify that the action is typed correctly.
* - ResourceNotFoundException Resource not found. Verify the connection resource ARN and try again.
* - ThrottlingException The request was denied due to request throttling.
* - UpdateOutOfSyncException The update is out of sync. Try syncing again.
* - SdkException Base class for all exceptions that can be thrown by the SDK (both service and client).
* Can be used for catch all scenarios.
* - SdkClientException If any client side error occurs such as an IO related failure, failure to get
* credentials, etc.
* - CodeStarConnectionsException Base class for all service exceptions. Unknown exceptions will be thrown
* as an instance of this type.
*
* @sample CodeStarConnectionsAsyncClient.UpdateSyncConfiguration
* @see AWS API Documentation
*/
default CompletableFuture updateSyncConfiguration(
Consumer updateSyncConfigurationRequest) {
return updateSyncConfiguration(UpdateSyncConfigurationRequest.builder().applyMutation(updateSyncConfigurationRequest)
.build());
}
@Override
default CodeStarConnectionsServiceClientConfiguration serviceClientConfiguration() {
throw new UnsupportedOperationException();
}
/**
* Create a {@link CodeStarConnectionsAsyncClient} with the region loaded from the
* {@link software.amazon.awssdk.regions.providers.DefaultAwsRegionProviderChain} and credentials loaded from the
* {@link software.amazon.awssdk.auth.credentials.DefaultCredentialsProvider}.
*/
static CodeStarConnectionsAsyncClient create() {
return builder().build();
}
/**
* Create a builder that can be used to configure and create a {@link CodeStarConnectionsAsyncClient}.
*/
static CodeStarConnectionsAsyncClientBuilder builder() {
return new DefaultCodeStarConnectionsAsyncClientBuilder();
}
}