software.amazon.awssdk.services.tnb.TnbAsyncClient Maven / Gradle / Ivy
Show all versions of tnb Show documentation
/*
* 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.tnb;
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.tnb.model.CancelSolNetworkOperationRequest;
import software.amazon.awssdk.services.tnb.model.CancelSolNetworkOperationResponse;
import software.amazon.awssdk.services.tnb.model.CreateSolFunctionPackageRequest;
import software.amazon.awssdk.services.tnb.model.CreateSolFunctionPackageResponse;
import software.amazon.awssdk.services.tnb.model.CreateSolNetworkInstanceRequest;
import software.amazon.awssdk.services.tnb.model.CreateSolNetworkInstanceResponse;
import software.amazon.awssdk.services.tnb.model.CreateSolNetworkPackageRequest;
import software.amazon.awssdk.services.tnb.model.CreateSolNetworkPackageResponse;
import software.amazon.awssdk.services.tnb.model.DeleteSolFunctionPackageRequest;
import software.amazon.awssdk.services.tnb.model.DeleteSolFunctionPackageResponse;
import software.amazon.awssdk.services.tnb.model.DeleteSolNetworkInstanceRequest;
import software.amazon.awssdk.services.tnb.model.DeleteSolNetworkInstanceResponse;
import software.amazon.awssdk.services.tnb.model.DeleteSolNetworkPackageRequest;
import software.amazon.awssdk.services.tnb.model.DeleteSolNetworkPackageResponse;
import software.amazon.awssdk.services.tnb.model.GetSolFunctionInstanceRequest;
import software.amazon.awssdk.services.tnb.model.GetSolFunctionInstanceResponse;
import software.amazon.awssdk.services.tnb.model.GetSolFunctionPackageContentRequest;
import software.amazon.awssdk.services.tnb.model.GetSolFunctionPackageContentResponse;
import software.amazon.awssdk.services.tnb.model.GetSolFunctionPackageDescriptorRequest;
import software.amazon.awssdk.services.tnb.model.GetSolFunctionPackageDescriptorResponse;
import software.amazon.awssdk.services.tnb.model.GetSolFunctionPackageRequest;
import software.amazon.awssdk.services.tnb.model.GetSolFunctionPackageResponse;
import software.amazon.awssdk.services.tnb.model.GetSolNetworkInstanceRequest;
import software.amazon.awssdk.services.tnb.model.GetSolNetworkInstanceResponse;
import software.amazon.awssdk.services.tnb.model.GetSolNetworkOperationRequest;
import software.amazon.awssdk.services.tnb.model.GetSolNetworkOperationResponse;
import software.amazon.awssdk.services.tnb.model.GetSolNetworkPackageContentRequest;
import software.amazon.awssdk.services.tnb.model.GetSolNetworkPackageContentResponse;
import software.amazon.awssdk.services.tnb.model.GetSolNetworkPackageDescriptorRequest;
import software.amazon.awssdk.services.tnb.model.GetSolNetworkPackageDescriptorResponse;
import software.amazon.awssdk.services.tnb.model.GetSolNetworkPackageRequest;
import software.amazon.awssdk.services.tnb.model.GetSolNetworkPackageResponse;
import software.amazon.awssdk.services.tnb.model.InstantiateSolNetworkInstanceRequest;
import software.amazon.awssdk.services.tnb.model.InstantiateSolNetworkInstanceResponse;
import software.amazon.awssdk.services.tnb.model.ListSolFunctionInstancesRequest;
import software.amazon.awssdk.services.tnb.model.ListSolFunctionInstancesResponse;
import software.amazon.awssdk.services.tnb.model.ListSolFunctionPackagesRequest;
import software.amazon.awssdk.services.tnb.model.ListSolFunctionPackagesResponse;
import software.amazon.awssdk.services.tnb.model.ListSolNetworkInstancesRequest;
import software.amazon.awssdk.services.tnb.model.ListSolNetworkInstancesResponse;
import software.amazon.awssdk.services.tnb.model.ListSolNetworkOperationsRequest;
import software.amazon.awssdk.services.tnb.model.ListSolNetworkOperationsResponse;
import software.amazon.awssdk.services.tnb.model.ListSolNetworkPackagesRequest;
import software.amazon.awssdk.services.tnb.model.ListSolNetworkPackagesResponse;
import software.amazon.awssdk.services.tnb.model.ListTagsForResourceRequest;
import software.amazon.awssdk.services.tnb.model.ListTagsForResourceResponse;
import software.amazon.awssdk.services.tnb.model.PutSolFunctionPackageContentRequest;
import software.amazon.awssdk.services.tnb.model.PutSolFunctionPackageContentResponse;
import software.amazon.awssdk.services.tnb.model.PutSolNetworkPackageContentRequest;
import software.amazon.awssdk.services.tnb.model.PutSolNetworkPackageContentResponse;
import software.amazon.awssdk.services.tnb.model.TagResourceRequest;
import software.amazon.awssdk.services.tnb.model.TagResourceResponse;
import software.amazon.awssdk.services.tnb.model.TerminateSolNetworkInstanceRequest;
import software.amazon.awssdk.services.tnb.model.TerminateSolNetworkInstanceResponse;
import software.amazon.awssdk.services.tnb.model.UntagResourceRequest;
import software.amazon.awssdk.services.tnb.model.UntagResourceResponse;
import software.amazon.awssdk.services.tnb.model.UpdateSolFunctionPackageRequest;
import software.amazon.awssdk.services.tnb.model.UpdateSolFunctionPackageResponse;
import software.amazon.awssdk.services.tnb.model.UpdateSolNetworkInstanceRequest;
import software.amazon.awssdk.services.tnb.model.UpdateSolNetworkInstanceResponse;
import software.amazon.awssdk.services.tnb.model.UpdateSolNetworkPackageRequest;
import software.amazon.awssdk.services.tnb.model.UpdateSolNetworkPackageResponse;
import software.amazon.awssdk.services.tnb.model.ValidateSolFunctionPackageContentRequest;
import software.amazon.awssdk.services.tnb.model.ValidateSolFunctionPackageContentResponse;
import software.amazon.awssdk.services.tnb.model.ValidateSolNetworkPackageContentRequest;
import software.amazon.awssdk.services.tnb.model.ValidateSolNetworkPackageContentResponse;
import software.amazon.awssdk.services.tnb.paginators.ListSolFunctionInstancesPublisher;
import software.amazon.awssdk.services.tnb.paginators.ListSolFunctionPackagesPublisher;
import software.amazon.awssdk.services.tnb.paginators.ListSolNetworkInstancesPublisher;
import software.amazon.awssdk.services.tnb.paginators.ListSolNetworkOperationsPublisher;
import software.amazon.awssdk.services.tnb.paginators.ListSolNetworkPackagesPublisher;
/**
* Service client for accessing AWS Telco Network Builder 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.
*
*
* Amazon Web Services Telco Network Builder (TNB) is a network automation service that helps you deploy and manage
* telecom networks. AWS TNB helps you with the lifecycle management of your telecommunication network functions
* throughout planning, deployment, and post-deployment activities.
*
*/
@Generated("software.amazon.awssdk:codegen")
@SdkPublicApi
@ThreadSafe
public interface TnbAsyncClient extends AwsClient {
String SERVICE_NAME = "tnb";
/**
* Value for looking up the service's metadata from the
* {@link software.amazon.awssdk.regions.ServiceMetadataProvider}.
*/
String SERVICE_METADATA_ID = "tnb";
/**
*
* Cancels a network operation.
*
*
* A network operation is any operation that is done to your network, such as network instance instantiation or
* termination.
*
*
* @param cancelSolNetworkOperationRequest
* @return A Java Future containing the result of the CancelSolNetworkOperation 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.CancelSolNetworkOperation
* @see AWS
* API Documentation
*/
default CompletableFuture cancelSolNetworkOperation(
CancelSolNetworkOperationRequest cancelSolNetworkOperationRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Cancels a network operation.
*
*
* A network operation is any operation that is done to your network, such as network instance instantiation or
* termination.
*
*
*
* This is a convenience which creates an instance of the {@link CancelSolNetworkOperationRequest.Builder} avoiding
* the need to create one manually via {@link CancelSolNetworkOperationRequest#builder()}
*
*
* @param cancelSolNetworkOperationRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.CancelSolNetworkOperationRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the CancelSolNetworkOperation 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.CancelSolNetworkOperation
* @see AWS
* API Documentation
*/
default CompletableFuture cancelSolNetworkOperation(
Consumer cancelSolNetworkOperationRequest) {
return cancelSolNetworkOperation(CancelSolNetworkOperationRequest.builder()
.applyMutation(cancelSolNetworkOperationRequest).build());
}
/**
*
* Creates a function package.
*
*
* A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an
* ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to
* describe how the network functions should run on your network. For more information, see Function packages in the Amazon
* Web Services Telco Network Builder User Guide.
*
*
* Creating a function package is the first step for creating a network in AWS TNB. This request creates an empty
* container with an ID. The next step is to upload the actual CSAR zip file into that empty container. To upload
* function package content, see PutSolFunctionPackageContent.
*
*
* @param createSolFunctionPackageRequest
* @return A Java Future containing the result of the CreateSolFunctionPackage 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ServiceQuotaExceededException Service quotas have been exceeded.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.CreateSolFunctionPackage
* @see AWS
* API Documentation
*/
default CompletableFuture createSolFunctionPackage(
CreateSolFunctionPackageRequest createSolFunctionPackageRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a function package.
*
*
* A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an
* ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to
* describe how the network functions should run on your network. For more information, see Function packages in the Amazon
* Web Services Telco Network Builder User Guide.
*
*
* Creating a function package is the first step for creating a network in AWS TNB. This request creates an empty
* container with an ID. The next step is to upload the actual CSAR zip file into that empty container. To upload
* function package content, see PutSolFunctionPackageContent.
*
*
*
* This is a convenience which creates an instance of the {@link CreateSolFunctionPackageRequest.Builder} avoiding
* the need to create one manually via {@link CreateSolFunctionPackageRequest#builder()}
*
*
* @param createSolFunctionPackageRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.CreateSolFunctionPackageRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the CreateSolFunctionPackage 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ServiceQuotaExceededException Service quotas have been exceeded.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.CreateSolFunctionPackage
* @see AWS
* API Documentation
*/
default CompletableFuture createSolFunctionPackage(
Consumer createSolFunctionPackageRequest) {
return createSolFunctionPackage(CreateSolFunctionPackageRequest.builder().applyMutation(createSolFunctionPackageRequest)
.build());
}
/**
*
* Creates a network instance.
*
*
* A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which
* life-cycle operations (like terminate, update, and delete) can be performed. Creating a network instance is the
* third step after creating a network package. For more information about network instances, Network instances in the Amazon
* Web Services Telco Network Builder User Guide.
*
*
* Once you create a network instance, you can instantiate it. To instantiate a network, see InstantiateSolNetworkInstance.
*
*
* @param createSolNetworkInstanceRequest
* @return A Java Future containing the result of the CreateSolNetworkInstance 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ServiceQuotaExceededException Service quotas have been exceeded.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.CreateSolNetworkInstance
* @see AWS
* API Documentation
*/
default CompletableFuture createSolNetworkInstance(
CreateSolNetworkInstanceRequest createSolNetworkInstanceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a network instance.
*
*
* A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which
* life-cycle operations (like terminate, update, and delete) can be performed. Creating a network instance is the
* third step after creating a network package. For more information about network instances, Network instances in the Amazon
* Web Services Telco Network Builder User Guide.
*
*
* Once you create a network instance, you can instantiate it. To instantiate a network, see InstantiateSolNetworkInstance.
*
*
*
* This is a convenience which creates an instance of the {@link CreateSolNetworkInstanceRequest.Builder} avoiding
* the need to create one manually via {@link CreateSolNetworkInstanceRequest#builder()}
*
*
* @param createSolNetworkInstanceRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.CreateSolNetworkInstanceRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the CreateSolNetworkInstance 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ServiceQuotaExceededException Service quotas have been exceeded.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.CreateSolNetworkInstance
* @see AWS
* API Documentation
*/
default CompletableFuture createSolNetworkInstance(
Consumer createSolNetworkInstanceRequest) {
return createSolNetworkInstance(CreateSolNetworkInstanceRequest.builder().applyMutation(createSolNetworkInstanceRequest)
.build());
}
/**
*
* Creates a network package.
*
*
* A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to
* deploy and the Amazon Web Services infrastructure you want to deploy them on. For more information, see Network instances in the Amazon
* Web Services Telco Network Builder User Guide.
*
*
* A network package consists of a network service descriptor (NSD) file (required) and any additional files
* (optional), such as scripts specific to your needs. For example, if you have multiple function packages in your
* network package, you can use the NSD to define which network functions should run in certain VPCs, subnets, or
* EKS clusters.
*
*
* This request creates an empty network package container with an ID. Once you create a network package, you can
* upload the network package content using PutSolNetworkPackageContent.
*
*
* @param createSolNetworkPackageRequest
* @return A Java Future containing the result of the CreateSolNetworkPackage 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ServiceQuotaExceededException Service quotas have been exceeded.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.CreateSolNetworkPackage
* @see AWS
* API Documentation
*/
default CompletableFuture createSolNetworkPackage(
CreateSolNetworkPackageRequest createSolNetworkPackageRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Creates a network package.
*
*
* A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to
* deploy and the Amazon Web Services infrastructure you want to deploy them on. For more information, see Network instances in the Amazon
* Web Services Telco Network Builder User Guide.
*
*
* A network package consists of a network service descriptor (NSD) file (required) and any additional files
* (optional), such as scripts specific to your needs. For example, if you have multiple function packages in your
* network package, you can use the NSD to define which network functions should run in certain VPCs, subnets, or
* EKS clusters.
*
*
* This request creates an empty network package container with an ID. Once you create a network package, you can
* upload the network package content using PutSolNetworkPackageContent.
*
*
*
* This is a convenience which creates an instance of the {@link CreateSolNetworkPackageRequest.Builder} avoiding
* the need to create one manually via {@link CreateSolNetworkPackageRequest#builder()}
*
*
* @param createSolNetworkPackageRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.CreateSolNetworkPackageRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the CreateSolNetworkPackage 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ServiceQuotaExceededException Service quotas have been exceeded.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.CreateSolNetworkPackage
* @see AWS
* API Documentation
*/
default CompletableFuture createSolNetworkPackage(
Consumer createSolNetworkPackageRequest) {
return createSolNetworkPackage(CreateSolNetworkPackageRequest.builder().applyMutation(createSolNetworkPackageRequest)
.build());
}
/**
*
* Deletes a function package.
*
*
* A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an
* ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to
* describe how the network functions should run on your network.
*
*
* To delete a function package, the package must be in a disabled state. To disable a function package, see UpdateSolFunctionPackage
* .
*
*
* @param deleteSolFunctionPackageRequest
* @return A Java Future containing the result of the DeleteSolFunctionPackage 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.DeleteSolFunctionPackage
* @see AWS
* API Documentation
*/
default CompletableFuture deleteSolFunctionPackage(
DeleteSolFunctionPackageRequest deleteSolFunctionPackageRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Deletes a function package.
*
*
* A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an
* ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to
* describe how the network functions should run on your network.
*
*
* To delete a function package, the package must be in a disabled state. To disable a function package, see UpdateSolFunctionPackage
* .
*
*
*
* This is a convenience which creates an instance of the {@link DeleteSolFunctionPackageRequest.Builder} avoiding
* the need to create one manually via {@link DeleteSolFunctionPackageRequest#builder()}
*
*
* @param deleteSolFunctionPackageRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.DeleteSolFunctionPackageRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DeleteSolFunctionPackage 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.DeleteSolFunctionPackage
* @see AWS
* API Documentation
*/
default CompletableFuture deleteSolFunctionPackage(
Consumer deleteSolFunctionPackageRequest) {
return deleteSolFunctionPackage(DeleteSolFunctionPackageRequest.builder().applyMutation(deleteSolFunctionPackageRequest)
.build());
}
/**
*
* Deletes a network instance.
*
*
* A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which
* life-cycle operations (like terminate, update, and delete) can be performed.
*
*
* To delete a network instance, the instance must be in a stopped or terminated state. To terminate a network
* instance, see
* TerminateSolNetworkInstance.
*
*
* @param deleteSolNetworkInstanceRequest
* @return A Java Future containing the result of the DeleteSolNetworkInstance 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.DeleteSolNetworkInstance
* @see AWS
* API Documentation
*/
default CompletableFuture deleteSolNetworkInstance(
DeleteSolNetworkInstanceRequest deleteSolNetworkInstanceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Deletes a network instance.
*
*
* A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which
* life-cycle operations (like terminate, update, and delete) can be performed.
*
*
* To delete a network instance, the instance must be in a stopped or terminated state. To terminate a network
* instance, see
* TerminateSolNetworkInstance.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteSolNetworkInstanceRequest.Builder} avoiding
* the need to create one manually via {@link DeleteSolNetworkInstanceRequest#builder()}
*
*
* @param deleteSolNetworkInstanceRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.DeleteSolNetworkInstanceRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DeleteSolNetworkInstance 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.DeleteSolNetworkInstance
* @see AWS
* API Documentation
*/
default CompletableFuture deleteSolNetworkInstance(
Consumer deleteSolNetworkInstanceRequest) {
return deleteSolNetworkInstance(DeleteSolNetworkInstanceRequest.builder().applyMutation(deleteSolNetworkInstanceRequest)
.build());
}
/**
*
* Deletes network package.
*
*
* A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to
* deploy and the Amazon Web Services infrastructure you want to deploy them on.
*
*
* To delete a network package, the package must be in a disable state. To disable a network package, see UpdateSolNetworkPackage.
*
*
* @param deleteSolNetworkPackageRequest
* @return A Java Future containing the result of the DeleteSolNetworkPackage 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.DeleteSolNetworkPackage
* @see AWS
* API Documentation
*/
default CompletableFuture deleteSolNetworkPackage(
DeleteSolNetworkPackageRequest deleteSolNetworkPackageRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Deletes network package.
*
*
* A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to
* deploy and the Amazon Web Services infrastructure you want to deploy them on.
*
*
* To delete a network package, the package must be in a disable state. To disable a network package, see UpdateSolNetworkPackage.
*
*
*
* This is a convenience which creates an instance of the {@link DeleteSolNetworkPackageRequest.Builder} avoiding
* the need to create one manually via {@link DeleteSolNetworkPackageRequest#builder()}
*
*
* @param deleteSolNetworkPackageRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.DeleteSolNetworkPackageRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the DeleteSolNetworkPackage 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.DeleteSolNetworkPackage
* @see AWS
* API Documentation
*/
default CompletableFuture deleteSolNetworkPackage(
Consumer deleteSolNetworkPackageRequest) {
return deleteSolNetworkPackage(DeleteSolNetworkPackageRequest.builder().applyMutation(deleteSolNetworkPackageRequest)
.build());
}
/**
*
* Gets the details of a network function instance, including the instantiation state and metadata from the function
* package descriptor in the network function package.
*
*
* A network function instance is a function in a function package .
*
*
* @param getSolFunctionInstanceRequest
* @return A Java Future containing the result of the GetSolFunctionInstance 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.GetSolFunctionInstance
* @see AWS
* API Documentation
*/
default CompletableFuture getSolFunctionInstance(
GetSolFunctionInstanceRequest getSolFunctionInstanceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Gets the details of a network function instance, including the instantiation state and metadata from the function
* package descriptor in the network function package.
*
*
* A network function instance is a function in a function package .
*
*
*
* This is a convenience which creates an instance of the {@link GetSolFunctionInstanceRequest.Builder} avoiding the
* need to create one manually via {@link GetSolFunctionInstanceRequest#builder()}
*
*
* @param getSolFunctionInstanceRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.GetSolFunctionInstanceRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the GetSolFunctionInstance 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.GetSolFunctionInstance
* @see AWS
* API Documentation
*/
default CompletableFuture getSolFunctionInstance(
Consumer getSolFunctionInstanceRequest) {
return getSolFunctionInstance(GetSolFunctionInstanceRequest.builder().applyMutation(getSolFunctionInstanceRequest)
.build());
}
/**
*
* Gets the details of an individual function package, such as the operational state and whether the package is in
* use.
*
*
* A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an
* ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to
* describe how the network functions should run on your network..
*
*
* @param getSolFunctionPackageRequest
* @return A Java Future containing the result of the GetSolFunctionPackage 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.GetSolFunctionPackage
* @see AWS API
* Documentation
*/
default CompletableFuture getSolFunctionPackage(
GetSolFunctionPackageRequest getSolFunctionPackageRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Gets the details of an individual function package, such as the operational state and whether the package is in
* use.
*
*
* A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an
* ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to
* describe how the network functions should run on your network..
*
*
*
* This is a convenience which creates an instance of the {@link GetSolFunctionPackageRequest.Builder} avoiding the
* need to create one manually via {@link GetSolFunctionPackageRequest#builder()}
*
*
* @param getSolFunctionPackageRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.GetSolFunctionPackageRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the GetSolFunctionPackage 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.GetSolFunctionPackage
* @see AWS API
* Documentation
*/
default CompletableFuture getSolFunctionPackage(
Consumer getSolFunctionPackageRequest) {
return getSolFunctionPackage(GetSolFunctionPackageRequest.builder().applyMutation(getSolFunctionPackageRequest).build());
}
/**
*
* Gets the contents of a function package.
*
*
* A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an
* ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to
* describe how the network functions should run on your network.
*
*
* @param getSolFunctionPackageContentRequest
* @return A Java Future containing the result of the GetSolFunctionPackageContent 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.GetSolFunctionPackageContent
* @see AWS API Documentation
*/
default CompletableFuture getSolFunctionPackageContent(
GetSolFunctionPackageContentRequest getSolFunctionPackageContentRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Gets the contents of a function package.
*
*
* A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an
* ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to
* describe how the network functions should run on your network.
*
*
*
* This is a convenience which creates an instance of the {@link GetSolFunctionPackageContentRequest.Builder}
* avoiding the need to create one manually via {@link GetSolFunctionPackageContentRequest#builder()}
*
*
* @param getSolFunctionPackageContentRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.GetSolFunctionPackageContentRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the GetSolFunctionPackageContent 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.GetSolFunctionPackageContent
* @see AWS API Documentation
*/
default CompletableFuture getSolFunctionPackageContent(
Consumer getSolFunctionPackageContentRequest) {
return getSolFunctionPackageContent(GetSolFunctionPackageContentRequest.builder()
.applyMutation(getSolFunctionPackageContentRequest).build());
}
/**
*
* Gets a function package descriptor in a function package.
*
*
* A function package descriptor is a .yaml file in a function package that uses the TOSCA standard to describe how
* the network function in the function package should run on your network.
*
*
* A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an
* ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to
* describe how the network functions should run on your network.
*
*
* @param getSolFunctionPackageDescriptorRequest
* @return A Java Future containing the result of the GetSolFunctionPackageDescriptor 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.GetSolFunctionPackageDescriptor
* @see AWS API Documentation
*/
default CompletableFuture getSolFunctionPackageDescriptor(
GetSolFunctionPackageDescriptorRequest getSolFunctionPackageDescriptorRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Gets a function package descriptor in a function package.
*
*
* A function package descriptor is a .yaml file in a function package that uses the TOSCA standard to describe how
* the network function in the function package should run on your network.
*
*
* A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an
* ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to
* describe how the network functions should run on your network.
*
*
*
* This is a convenience which creates an instance of the {@link GetSolFunctionPackageDescriptorRequest.Builder}
* avoiding the need to create one manually via {@link GetSolFunctionPackageDescriptorRequest#builder()}
*
*
* @param getSolFunctionPackageDescriptorRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.GetSolFunctionPackageDescriptorRequest.Builder} to create
* a request.
* @return A Java Future containing the result of the GetSolFunctionPackageDescriptor 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.GetSolFunctionPackageDescriptor
* @see AWS API Documentation
*/
default CompletableFuture getSolFunctionPackageDescriptor(
Consumer getSolFunctionPackageDescriptorRequest) {
return getSolFunctionPackageDescriptor(GetSolFunctionPackageDescriptorRequest.builder()
.applyMutation(getSolFunctionPackageDescriptorRequest).build());
}
/**
*
* Gets the details of the network instance.
*
*
* A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which
* life-cycle operations (like terminate, update, and delete) can be performed.
*
*
* @param getSolNetworkInstanceRequest
* @return A Java Future containing the result of the GetSolNetworkInstance 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.GetSolNetworkInstance
* @see AWS API
* Documentation
*/
default CompletableFuture getSolNetworkInstance(
GetSolNetworkInstanceRequest getSolNetworkInstanceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Gets the details of the network instance.
*
*
* A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which
* life-cycle operations (like terminate, update, and delete) can be performed.
*
*
*
* This is a convenience which creates an instance of the {@link GetSolNetworkInstanceRequest.Builder} avoiding the
* need to create one manually via {@link GetSolNetworkInstanceRequest#builder()}
*
*
* @param getSolNetworkInstanceRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.GetSolNetworkInstanceRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the GetSolNetworkInstance 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.GetSolNetworkInstance
* @see AWS API
* Documentation
*/
default CompletableFuture getSolNetworkInstance(
Consumer getSolNetworkInstanceRequest) {
return getSolNetworkInstance(GetSolNetworkInstanceRequest.builder().applyMutation(getSolNetworkInstanceRequest).build());
}
/**
*
* Gets the details of a network operation, including the tasks involved in the network operation and the status of
* the tasks.
*
*
* A network operation is any operation that is done to your network, such as network instance instantiation or
* termination.
*
*
* @param getSolNetworkOperationRequest
* @return A Java Future containing the result of the GetSolNetworkOperation 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.GetSolNetworkOperation
* @see AWS
* API Documentation
*/
default CompletableFuture getSolNetworkOperation(
GetSolNetworkOperationRequest getSolNetworkOperationRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Gets the details of a network operation, including the tasks involved in the network operation and the status of
* the tasks.
*
*
* A network operation is any operation that is done to your network, such as network instance instantiation or
* termination.
*
*
*
* This is a convenience which creates an instance of the {@link GetSolNetworkOperationRequest.Builder} avoiding the
* need to create one manually via {@link GetSolNetworkOperationRequest#builder()}
*
*
* @param getSolNetworkOperationRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.GetSolNetworkOperationRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the GetSolNetworkOperation 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.GetSolNetworkOperation
* @see AWS
* API Documentation
*/
default CompletableFuture getSolNetworkOperation(
Consumer getSolNetworkOperationRequest) {
return getSolNetworkOperation(GetSolNetworkOperationRequest.builder().applyMutation(getSolNetworkOperationRequest)
.build());
}
/**
*
* Gets the details of a network package.
*
*
* A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to
* deploy and the Amazon Web Services infrastructure you want to deploy them on.
*
*
* @param getSolNetworkPackageRequest
* @return A Java Future containing the result of the GetSolNetworkPackage 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.GetSolNetworkPackage
* @see AWS API
* Documentation
*/
default CompletableFuture getSolNetworkPackage(
GetSolNetworkPackageRequest getSolNetworkPackageRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Gets the details of a network package.
*
*
* A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to
* deploy and the Amazon Web Services infrastructure you want to deploy them on.
*
*
*
* This is a convenience which creates an instance of the {@link GetSolNetworkPackageRequest.Builder} avoiding the
* need to create one manually via {@link GetSolNetworkPackageRequest#builder()}
*
*
* @param getSolNetworkPackageRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.GetSolNetworkPackageRequest.Builder} to create a request.
* @return A Java Future containing the result of the GetSolNetworkPackage 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.GetSolNetworkPackage
* @see AWS API
* Documentation
*/
default CompletableFuture getSolNetworkPackage(
Consumer getSolNetworkPackageRequest) {
return getSolNetworkPackage(GetSolNetworkPackageRequest.builder().applyMutation(getSolNetworkPackageRequest).build());
}
/**
*
* Gets the contents of a network package.
*
*
* A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to
* deploy and the Amazon Web Services infrastructure you want to deploy them on.
*
*
* @param getSolNetworkPackageContentRequest
* @return A Java Future containing the result of the GetSolNetworkPackageContent 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.GetSolNetworkPackageContent
* @see AWS API Documentation
*/
default CompletableFuture getSolNetworkPackageContent(
GetSolNetworkPackageContentRequest getSolNetworkPackageContentRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Gets the contents of a network package.
*
*
* A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to
* deploy and the Amazon Web Services infrastructure you want to deploy them on.
*
*
*
* This is a convenience which creates an instance of the {@link GetSolNetworkPackageContentRequest.Builder}
* avoiding the need to create one manually via {@link GetSolNetworkPackageContentRequest#builder()}
*
*
* @param getSolNetworkPackageContentRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.GetSolNetworkPackageContentRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the GetSolNetworkPackageContent 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.GetSolNetworkPackageContent
* @see AWS API Documentation
*/
default CompletableFuture getSolNetworkPackageContent(
Consumer getSolNetworkPackageContentRequest) {
return getSolNetworkPackageContent(GetSolNetworkPackageContentRequest.builder()
.applyMutation(getSolNetworkPackageContentRequest).build());
}
/**
*
* Gets the content of the network service descriptor.
*
*
* A network service descriptor is a .yaml file in a network package that uses the TOSCA standard to describe the
* network functions you want to deploy and the Amazon Web Services infrastructure you want to deploy the network
* functions on.
*
*
* @param getSolNetworkPackageDescriptorRequest
* @return A Java Future containing the result of the GetSolNetworkPackageDescriptor 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.GetSolNetworkPackageDescriptor
* @see AWS API Documentation
*/
default CompletableFuture getSolNetworkPackageDescriptor(
GetSolNetworkPackageDescriptorRequest getSolNetworkPackageDescriptorRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Gets the content of the network service descriptor.
*
*
* A network service descriptor is a .yaml file in a network package that uses the TOSCA standard to describe the
* network functions you want to deploy and the Amazon Web Services infrastructure you want to deploy the network
* functions on.
*
*
*
* This is a convenience which creates an instance of the {@link GetSolNetworkPackageDescriptorRequest.Builder}
* avoiding the need to create one manually via {@link GetSolNetworkPackageDescriptorRequest#builder()}
*
*
* @param getSolNetworkPackageDescriptorRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.GetSolNetworkPackageDescriptorRequest.Builder} to create
* a request.
* @return A Java Future containing the result of the GetSolNetworkPackageDescriptor 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.GetSolNetworkPackageDescriptor
* @see AWS API Documentation
*/
default CompletableFuture getSolNetworkPackageDescriptor(
Consumer getSolNetworkPackageDescriptorRequest) {
return getSolNetworkPackageDescriptor(GetSolNetworkPackageDescriptorRequest.builder()
.applyMutation(getSolNetworkPackageDescriptorRequest).build());
}
/**
*
* Instantiates a network instance.
*
*
* A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which
* life-cycle operations (like terminate, update, and delete) can be performed.
*
*
* Before you can instantiate a network instance, you have to create a network instance. For more information, see
*
* CreateSolNetworkInstance.
*
*
* @param instantiateSolNetworkInstanceRequest
* @return A Java Future containing the result of the InstantiateSolNetworkInstance 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ServiceQuotaExceededException Service quotas have been exceeded.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.InstantiateSolNetworkInstance
* @see AWS API Documentation
*/
default CompletableFuture instantiateSolNetworkInstance(
InstantiateSolNetworkInstanceRequest instantiateSolNetworkInstanceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Instantiates a network instance.
*
*
* A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which
* life-cycle operations (like terminate, update, and delete) can be performed.
*
*
* Before you can instantiate a network instance, you have to create a network instance. For more information, see
*
* CreateSolNetworkInstance.
*
*
*
* This is a convenience which creates an instance of the {@link InstantiateSolNetworkInstanceRequest.Builder}
* avoiding the need to create one manually via {@link InstantiateSolNetworkInstanceRequest#builder()}
*
*
* @param instantiateSolNetworkInstanceRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.InstantiateSolNetworkInstanceRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the InstantiateSolNetworkInstance 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ServiceQuotaExceededException Service quotas have been exceeded.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.InstantiateSolNetworkInstance
* @see AWS API Documentation
*/
default CompletableFuture instantiateSolNetworkInstance(
Consumer instantiateSolNetworkInstanceRequest) {
return instantiateSolNetworkInstance(InstantiateSolNetworkInstanceRequest.builder()
.applyMutation(instantiateSolNetworkInstanceRequest).build());
}
/**
*
* Lists network function instances.
*
*
* A network function instance is a function in a function package .
*
*
* @param listSolFunctionInstancesRequest
* @return A Java Future containing the result of the ListSolFunctionInstances 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListSolFunctionInstances
* @see AWS
* API Documentation
*/
default CompletableFuture listSolFunctionInstances(
ListSolFunctionInstancesRequest listSolFunctionInstancesRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Lists network function instances.
*
*
* A network function instance is a function in a function package .
*
*
*
* This is a convenience which creates an instance of the {@link ListSolFunctionInstancesRequest.Builder} avoiding
* the need to create one manually via {@link ListSolFunctionInstancesRequest#builder()}
*
*
* @param listSolFunctionInstancesRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.ListSolFunctionInstancesRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the ListSolFunctionInstances 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListSolFunctionInstances
* @see AWS
* API Documentation
*/
default CompletableFuture listSolFunctionInstances(
Consumer listSolFunctionInstancesRequest) {
return listSolFunctionInstances(ListSolFunctionInstancesRequest.builder().applyMutation(listSolFunctionInstancesRequest)
.build());
}
/**
*
* This is a variant of
* {@link #listSolFunctionInstances(software.amazon.awssdk.services.tnb.model.ListSolFunctionInstancesRequest)}
* 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.tnb.paginators.ListSolFunctionInstancesPublisher publisher = client.listSolFunctionInstancesPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.tnb.paginators.ListSolFunctionInstancesPublisher publisher = client.listSolFunctionInstancesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.tnb.model.ListSolFunctionInstancesResponse 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 #listSolFunctionInstances(software.amazon.awssdk.services.tnb.model.ListSolFunctionInstancesRequest)}
* operation.
*
*
* @param listSolFunctionInstancesRequest
* @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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListSolFunctionInstances
* @see AWS
* API Documentation
*/
default ListSolFunctionInstancesPublisher listSolFunctionInstancesPaginator(
ListSolFunctionInstancesRequest listSolFunctionInstancesRequest) {
return new ListSolFunctionInstancesPublisher(this, listSolFunctionInstancesRequest);
}
/**
*
* This is a variant of
* {@link #listSolFunctionInstances(software.amazon.awssdk.services.tnb.model.ListSolFunctionInstancesRequest)}
* 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.tnb.paginators.ListSolFunctionInstancesPublisher publisher = client.listSolFunctionInstancesPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.tnb.paginators.ListSolFunctionInstancesPublisher publisher = client.listSolFunctionInstancesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.tnb.model.ListSolFunctionInstancesResponse 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 #listSolFunctionInstances(software.amazon.awssdk.services.tnb.model.ListSolFunctionInstancesRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link ListSolFunctionInstancesRequest.Builder} avoiding
* the need to create one manually via {@link ListSolFunctionInstancesRequest#builder()}
*
*
* @param listSolFunctionInstancesRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.ListSolFunctionInstancesRequest.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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListSolFunctionInstances
* @see AWS
* API Documentation
*/
default ListSolFunctionInstancesPublisher listSolFunctionInstancesPaginator(
Consumer listSolFunctionInstancesRequest) {
return listSolFunctionInstancesPaginator(ListSolFunctionInstancesRequest.builder()
.applyMutation(listSolFunctionInstancesRequest).build());
}
/**
*
* Lists information about function packages.
*
*
* A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an
* ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to
* describe how the network functions should run on your network.
*
*
* @param listSolFunctionPackagesRequest
* @return A Java Future containing the result of the ListSolFunctionPackages 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListSolFunctionPackages
* @see AWS
* API Documentation
*/
default CompletableFuture listSolFunctionPackages(
ListSolFunctionPackagesRequest listSolFunctionPackagesRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Lists information about function packages.
*
*
* A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an
* ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to
* describe how the network functions should run on your network.
*
*
*
* This is a convenience which creates an instance of the {@link ListSolFunctionPackagesRequest.Builder} avoiding
* the need to create one manually via {@link ListSolFunctionPackagesRequest#builder()}
*
*
* @param listSolFunctionPackagesRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.ListSolFunctionPackagesRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the ListSolFunctionPackages 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListSolFunctionPackages
* @see AWS
* API Documentation
*/
default CompletableFuture listSolFunctionPackages(
Consumer listSolFunctionPackagesRequest) {
return listSolFunctionPackages(ListSolFunctionPackagesRequest.builder().applyMutation(listSolFunctionPackagesRequest)
.build());
}
/**
*
* This is a variant of
* {@link #listSolFunctionPackages(software.amazon.awssdk.services.tnb.model.ListSolFunctionPackagesRequest)}
* 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.tnb.paginators.ListSolFunctionPackagesPublisher publisher = client.listSolFunctionPackagesPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.tnb.paginators.ListSolFunctionPackagesPublisher publisher = client.listSolFunctionPackagesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.tnb.model.ListSolFunctionPackagesResponse 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 #listSolFunctionPackages(software.amazon.awssdk.services.tnb.model.ListSolFunctionPackagesRequest)}
* operation.
*
*
* @param listSolFunctionPackagesRequest
* @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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListSolFunctionPackages
* @see AWS
* API Documentation
*/
default ListSolFunctionPackagesPublisher listSolFunctionPackagesPaginator(
ListSolFunctionPackagesRequest listSolFunctionPackagesRequest) {
return new ListSolFunctionPackagesPublisher(this, listSolFunctionPackagesRequest);
}
/**
*
* This is a variant of
* {@link #listSolFunctionPackages(software.amazon.awssdk.services.tnb.model.ListSolFunctionPackagesRequest)}
* 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.tnb.paginators.ListSolFunctionPackagesPublisher publisher = client.listSolFunctionPackagesPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.tnb.paginators.ListSolFunctionPackagesPublisher publisher = client.listSolFunctionPackagesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.tnb.model.ListSolFunctionPackagesResponse 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 #listSolFunctionPackages(software.amazon.awssdk.services.tnb.model.ListSolFunctionPackagesRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link ListSolFunctionPackagesRequest.Builder} avoiding
* the need to create one manually via {@link ListSolFunctionPackagesRequest#builder()}
*
*
* @param listSolFunctionPackagesRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.ListSolFunctionPackagesRequest.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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListSolFunctionPackages
* @see AWS
* API Documentation
*/
default ListSolFunctionPackagesPublisher listSolFunctionPackagesPaginator(
Consumer listSolFunctionPackagesRequest) {
return listSolFunctionPackagesPaginator(ListSolFunctionPackagesRequest.builder()
.applyMutation(listSolFunctionPackagesRequest).build());
}
/**
*
* Lists your network instances.
*
*
* A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which
* life-cycle operations (like terminate, update, and delete) can be performed.
*
*
* @param listSolNetworkInstancesRequest
* @return A Java Future containing the result of the ListSolNetworkInstances 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListSolNetworkInstances
* @see AWS
* API Documentation
*/
default CompletableFuture listSolNetworkInstances(
ListSolNetworkInstancesRequest listSolNetworkInstancesRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Lists your network instances.
*
*
* A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which
* life-cycle operations (like terminate, update, and delete) can be performed.
*
*
*
* This is a convenience which creates an instance of the {@link ListSolNetworkInstancesRequest.Builder} avoiding
* the need to create one manually via {@link ListSolNetworkInstancesRequest#builder()}
*
*
* @param listSolNetworkInstancesRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.ListSolNetworkInstancesRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the ListSolNetworkInstances 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListSolNetworkInstances
* @see AWS
* API Documentation
*/
default CompletableFuture listSolNetworkInstances(
Consumer listSolNetworkInstancesRequest) {
return listSolNetworkInstances(ListSolNetworkInstancesRequest.builder().applyMutation(listSolNetworkInstancesRequest)
.build());
}
/**
*
* This is a variant of
* {@link #listSolNetworkInstances(software.amazon.awssdk.services.tnb.model.ListSolNetworkInstancesRequest)}
* 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.tnb.paginators.ListSolNetworkInstancesPublisher publisher = client.listSolNetworkInstancesPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.tnb.paginators.ListSolNetworkInstancesPublisher publisher = client.listSolNetworkInstancesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.tnb.model.ListSolNetworkInstancesResponse 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 #listSolNetworkInstances(software.amazon.awssdk.services.tnb.model.ListSolNetworkInstancesRequest)}
* operation.
*
*
* @param listSolNetworkInstancesRequest
* @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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListSolNetworkInstances
* @see AWS
* API Documentation
*/
default ListSolNetworkInstancesPublisher listSolNetworkInstancesPaginator(
ListSolNetworkInstancesRequest listSolNetworkInstancesRequest) {
return new ListSolNetworkInstancesPublisher(this, listSolNetworkInstancesRequest);
}
/**
*
* This is a variant of
* {@link #listSolNetworkInstances(software.amazon.awssdk.services.tnb.model.ListSolNetworkInstancesRequest)}
* 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.tnb.paginators.ListSolNetworkInstancesPublisher publisher = client.listSolNetworkInstancesPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.tnb.paginators.ListSolNetworkInstancesPublisher publisher = client.listSolNetworkInstancesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.tnb.model.ListSolNetworkInstancesResponse 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 #listSolNetworkInstances(software.amazon.awssdk.services.tnb.model.ListSolNetworkInstancesRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link ListSolNetworkInstancesRequest.Builder} avoiding
* the need to create one manually via {@link ListSolNetworkInstancesRequest#builder()}
*
*
* @param listSolNetworkInstancesRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.ListSolNetworkInstancesRequest.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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListSolNetworkInstances
* @see AWS
* API Documentation
*/
default ListSolNetworkInstancesPublisher listSolNetworkInstancesPaginator(
Consumer listSolNetworkInstancesRequest) {
return listSolNetworkInstancesPaginator(ListSolNetworkInstancesRequest.builder()
.applyMutation(listSolNetworkInstancesRequest).build());
}
/**
*
* Lists details for a network operation, including when the operation started and the status of the operation.
*
*
* A network operation is any operation that is done to your network, such as network instance instantiation or
* termination.
*
*
* @param listSolNetworkOperationsRequest
* @return A Java Future containing the result of the ListSolNetworkOperations 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListSolNetworkOperations
* @see AWS
* API Documentation
*/
default CompletableFuture listSolNetworkOperations(
ListSolNetworkOperationsRequest listSolNetworkOperationsRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Lists details for a network operation, including when the operation started and the status of the operation.
*
*
* A network operation is any operation that is done to your network, such as network instance instantiation or
* termination.
*
*
*
* This is a convenience which creates an instance of the {@link ListSolNetworkOperationsRequest.Builder} avoiding
* the need to create one manually via {@link ListSolNetworkOperationsRequest#builder()}
*
*
* @param listSolNetworkOperationsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.ListSolNetworkOperationsRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the ListSolNetworkOperations 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListSolNetworkOperations
* @see AWS
* API Documentation
*/
default CompletableFuture listSolNetworkOperations(
Consumer listSolNetworkOperationsRequest) {
return listSolNetworkOperations(ListSolNetworkOperationsRequest.builder().applyMutation(listSolNetworkOperationsRequest)
.build());
}
/**
*
* This is a variant of
* {@link #listSolNetworkOperations(software.amazon.awssdk.services.tnb.model.ListSolNetworkOperationsRequest)}
* 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.tnb.paginators.ListSolNetworkOperationsPublisher publisher = client.listSolNetworkOperationsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.tnb.paginators.ListSolNetworkOperationsPublisher publisher = client.listSolNetworkOperationsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.tnb.model.ListSolNetworkOperationsResponse 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 #listSolNetworkOperations(software.amazon.awssdk.services.tnb.model.ListSolNetworkOperationsRequest)}
* operation.
*
*
* @param listSolNetworkOperationsRequest
* @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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListSolNetworkOperations
* @see AWS
* API Documentation
*/
default ListSolNetworkOperationsPublisher listSolNetworkOperationsPaginator(
ListSolNetworkOperationsRequest listSolNetworkOperationsRequest) {
return new ListSolNetworkOperationsPublisher(this, listSolNetworkOperationsRequest);
}
/**
*
* This is a variant of
* {@link #listSolNetworkOperations(software.amazon.awssdk.services.tnb.model.ListSolNetworkOperationsRequest)}
* 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.tnb.paginators.ListSolNetworkOperationsPublisher publisher = client.listSolNetworkOperationsPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.tnb.paginators.ListSolNetworkOperationsPublisher publisher = client.listSolNetworkOperationsPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.tnb.model.ListSolNetworkOperationsResponse 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 #listSolNetworkOperations(software.amazon.awssdk.services.tnb.model.ListSolNetworkOperationsRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link ListSolNetworkOperationsRequest.Builder} avoiding
* the need to create one manually via {@link ListSolNetworkOperationsRequest#builder()}
*
*
* @param listSolNetworkOperationsRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.ListSolNetworkOperationsRequest.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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListSolNetworkOperations
* @see AWS
* API Documentation
*/
default ListSolNetworkOperationsPublisher listSolNetworkOperationsPaginator(
Consumer listSolNetworkOperationsRequest) {
return listSolNetworkOperationsPaginator(ListSolNetworkOperationsRequest.builder()
.applyMutation(listSolNetworkOperationsRequest).build());
}
/**
*
* Lists network packages.
*
*
* A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to
* deploy and the Amazon Web Services infrastructure you want to deploy them on.
*
*
* @param listSolNetworkPackagesRequest
* @return A Java Future containing the result of the ListSolNetworkPackages 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListSolNetworkPackages
* @see AWS
* API Documentation
*/
default CompletableFuture listSolNetworkPackages(
ListSolNetworkPackagesRequest listSolNetworkPackagesRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Lists network packages.
*
*
* A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to
* deploy and the Amazon Web Services infrastructure you want to deploy them on.
*
*
*
* This is a convenience which creates an instance of the {@link ListSolNetworkPackagesRequest.Builder} avoiding the
* need to create one manually via {@link ListSolNetworkPackagesRequest#builder()}
*
*
* @param listSolNetworkPackagesRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.ListSolNetworkPackagesRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the ListSolNetworkPackages 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListSolNetworkPackages
* @see AWS
* API Documentation
*/
default CompletableFuture listSolNetworkPackages(
Consumer listSolNetworkPackagesRequest) {
return listSolNetworkPackages(ListSolNetworkPackagesRequest.builder().applyMutation(listSolNetworkPackagesRequest)
.build());
}
/**
*
* This is a variant of
* {@link #listSolNetworkPackages(software.amazon.awssdk.services.tnb.model.ListSolNetworkPackagesRequest)}
* 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.tnb.paginators.ListSolNetworkPackagesPublisher publisher = client.listSolNetworkPackagesPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.tnb.paginators.ListSolNetworkPackagesPublisher publisher = client.listSolNetworkPackagesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.tnb.model.ListSolNetworkPackagesResponse 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 #listSolNetworkPackages(software.amazon.awssdk.services.tnb.model.ListSolNetworkPackagesRequest)}
* operation.
*
*
* @param listSolNetworkPackagesRequest
* @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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListSolNetworkPackages
* @see AWS
* API Documentation
*/
default ListSolNetworkPackagesPublisher listSolNetworkPackagesPaginator(
ListSolNetworkPackagesRequest listSolNetworkPackagesRequest) {
return new ListSolNetworkPackagesPublisher(this, listSolNetworkPackagesRequest);
}
/**
*
* This is a variant of
* {@link #listSolNetworkPackages(software.amazon.awssdk.services.tnb.model.ListSolNetworkPackagesRequest)}
* 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.tnb.paginators.ListSolNetworkPackagesPublisher publisher = client.listSolNetworkPackagesPaginator(request);
* CompletableFuture future = publisher.subscribe(res -> { // Do something with the response });
* future.get();
* }
*
*
* 2) Using a custom subscriber
*
*
* {@code
* software.amazon.awssdk.services.tnb.paginators.ListSolNetworkPackagesPublisher publisher = client.listSolNetworkPackagesPaginator(request);
* publisher.subscribe(new Subscriber() {
*
* public void onSubscribe(org.reactivestreams.Subscriber subscription) { //... };
*
*
* public void onNext(software.amazon.awssdk.services.tnb.model.ListSolNetworkPackagesResponse 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 #listSolNetworkPackages(software.amazon.awssdk.services.tnb.model.ListSolNetworkPackagesRequest)}
* operation.
*
*
*
* This is a convenience which creates an instance of the {@link ListSolNetworkPackagesRequest.Builder} avoiding the
* need to create one manually via {@link ListSolNetworkPackagesRequest#builder()}
*
*
* @param listSolNetworkPackagesRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.ListSolNetworkPackagesRequest.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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListSolNetworkPackages
* @see AWS
* API Documentation
*/
default ListSolNetworkPackagesPublisher listSolNetworkPackagesPaginator(
Consumer listSolNetworkPackagesRequest) {
return listSolNetworkPackagesPaginator(ListSolNetworkPackagesRequest.builder()
.applyMutation(listSolNetworkPackagesRequest).build());
}
/**
*
* Lists tags for AWS TNB resources.
*
*
* @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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListTagsForResource
* @see AWS API
* Documentation
*/
default CompletableFuture listTagsForResource(
ListTagsForResourceRequest listTagsForResourceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Lists tags for AWS TNB resources.
*
*
*
* 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.tnb.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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ListTagsForResource
* @see AWS API
* Documentation
*/
default CompletableFuture listTagsForResource(
Consumer listTagsForResourceRequest) {
return listTagsForResource(ListTagsForResourceRequest.builder().applyMutation(listTagsForResourceRequest).build());
}
/**
*
* Uploads the contents of a function package.
*
*
* A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an
* ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to
* describe how the network functions should run on your network.
*
*
* @param putSolFunctionPackageContentRequest
* @return A Java Future containing the result of the PutSolFunctionPackageContent 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.PutSolFunctionPackageContent
* @see AWS API Documentation
*/
default CompletableFuture putSolFunctionPackageContent(
PutSolFunctionPackageContentRequest putSolFunctionPackageContentRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Uploads the contents of a function package.
*
*
* A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an
* ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to
* describe how the network functions should run on your network.
*
*
*
* This is a convenience which creates an instance of the {@link PutSolFunctionPackageContentRequest.Builder}
* avoiding the need to create one manually via {@link PutSolFunctionPackageContentRequest#builder()}
*
*
* @param putSolFunctionPackageContentRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.PutSolFunctionPackageContentRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the PutSolFunctionPackageContent 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.PutSolFunctionPackageContent
* @see AWS API Documentation
*/
default CompletableFuture putSolFunctionPackageContent(
Consumer putSolFunctionPackageContentRequest) {
return putSolFunctionPackageContent(PutSolFunctionPackageContentRequest.builder()
.applyMutation(putSolFunctionPackageContentRequest).build());
}
/**
*
* Uploads the contents of a network package.
*
*
* A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to
* deploy and the Amazon Web Services infrastructure you want to deploy them on.
*
*
* @param putSolNetworkPackageContentRequest
* @return A Java Future containing the result of the PutSolNetworkPackageContent 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.PutSolNetworkPackageContent
* @see AWS API Documentation
*/
default CompletableFuture putSolNetworkPackageContent(
PutSolNetworkPackageContentRequest putSolNetworkPackageContentRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Uploads the contents of a network package.
*
*
* A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to
* deploy and the Amazon Web Services infrastructure you want to deploy them on.
*
*
*
* This is a convenience which creates an instance of the {@link PutSolNetworkPackageContentRequest.Builder}
* avoiding the need to create one manually via {@link PutSolNetworkPackageContentRequest#builder()}
*
*
* @param putSolNetworkPackageContentRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.PutSolNetworkPackageContentRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the PutSolNetworkPackageContent 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.PutSolNetworkPackageContent
* @see AWS API Documentation
*/
default CompletableFuture putSolNetworkPackageContent(
Consumer putSolNetworkPackageContentRequest) {
return putSolNetworkPackageContent(PutSolNetworkPackageContentRequest.builder()
.applyMutation(putSolNetworkPackageContentRequest).build());
}
/**
*
* Tags an AWS TNB resource.
*
*
* A tag is a label that you assign to an Amazon Web Services resource. Each tag consists of a key and an optional
* value. You can use tags to search and filter your resources or track your Amazon Web Services costs.
*
*
* @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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.TagResource
* @see AWS API
* Documentation
*/
default CompletableFuture tagResource(TagResourceRequest tagResourceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Tags an AWS TNB resource.
*
*
* A tag is a label that you assign to an Amazon Web Services resource. Each tag consists of a key and an optional
* value. You can use tags to search and filter your resources or track your Amazon Web Services costs.
*
*
*
* 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.tnb.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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.TagResource
* @see AWS API
* Documentation
*/
default CompletableFuture tagResource(Consumer tagResourceRequest) {
return tagResource(TagResourceRequest.builder().applyMutation(tagResourceRequest).build());
}
/**
*
* Terminates a network instance.
*
*
* A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which
* life-cycle operations (like terminate, update, and delete) can be performed.
*
*
* You must terminate a network instance before you can delete it.
*
*
* @param terminateSolNetworkInstanceRequest
* @return A Java Future containing the result of the TerminateSolNetworkInstance 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ServiceQuotaExceededException Service quotas have been exceeded.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.TerminateSolNetworkInstance
* @see AWS API Documentation
*/
default CompletableFuture terminateSolNetworkInstance(
TerminateSolNetworkInstanceRequest terminateSolNetworkInstanceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Terminates a network instance.
*
*
* A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which
* life-cycle operations (like terminate, update, and delete) can be performed.
*
*
* You must terminate a network instance before you can delete it.
*
*
*
* This is a convenience which creates an instance of the {@link TerminateSolNetworkInstanceRequest.Builder}
* avoiding the need to create one manually via {@link TerminateSolNetworkInstanceRequest#builder()}
*
*
* @param terminateSolNetworkInstanceRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.TerminateSolNetworkInstanceRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the TerminateSolNetworkInstance 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ServiceQuotaExceededException Service quotas have been exceeded.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.TerminateSolNetworkInstance
* @see AWS API Documentation
*/
default CompletableFuture terminateSolNetworkInstance(
Consumer terminateSolNetworkInstanceRequest) {
return terminateSolNetworkInstance(TerminateSolNetworkInstanceRequest.builder()
.applyMutation(terminateSolNetworkInstanceRequest).build());
}
/**
*
* Untags an AWS TNB resource.
*
*
* A tag is a label that you assign to an Amazon Web Services resource. Each tag consists of a key and an optional
* value. You can use tags to search and filter your resources or track your Amazon Web Services costs.
*
*
* @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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.UntagResource
* @see AWS API
* Documentation
*/
default CompletableFuture untagResource(UntagResourceRequest untagResourceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Untags an AWS TNB resource.
*
*
* A tag is a label that you assign to an Amazon Web Services resource. Each tag consists of a key and an optional
* value. You can use tags to search and filter your resources or track your Amazon Web Services costs.
*
*
*
* 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.tnb.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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.UntagResource
* @see AWS API
* Documentation
*/
default CompletableFuture untagResource(Consumer untagResourceRequest) {
return untagResource(UntagResourceRequest.builder().applyMutation(untagResourceRequest).build());
}
/**
*
* Updates the operational state of function package.
*
*
* A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an
* ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to
* describe how the network functions should run on your network.
*
*
* @param updateSolFunctionPackageRequest
* @return A Java Future containing the result of the UpdateSolFunctionPackage 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.UpdateSolFunctionPackage
* @see AWS
* API Documentation
*/
default CompletableFuture updateSolFunctionPackage(
UpdateSolFunctionPackageRequest updateSolFunctionPackageRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Updates the operational state of function package.
*
*
* A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an
* ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to
* describe how the network functions should run on your network.
*
*
*
* This is a convenience which creates an instance of the {@link UpdateSolFunctionPackageRequest.Builder} avoiding
* the need to create one manually via {@link UpdateSolFunctionPackageRequest#builder()}
*
*
* @param updateSolFunctionPackageRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.UpdateSolFunctionPackageRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the UpdateSolFunctionPackage 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.UpdateSolFunctionPackage
* @see AWS
* API Documentation
*/
default CompletableFuture updateSolFunctionPackage(
Consumer updateSolFunctionPackageRequest) {
return updateSolFunctionPackage(UpdateSolFunctionPackageRequest.builder().applyMutation(updateSolFunctionPackageRequest)
.build());
}
/**
*
* Update a network instance.
*
*
* A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which
* life-cycle operations (like terminate, update, and delete) can be performed.
*
*
* Choose the updateType parameter to target the necessary update of the network instance.
*
*
* @param updateSolNetworkInstanceRequest
* @return A Java Future containing the result of the UpdateSolNetworkInstance 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ServiceQuotaExceededException Service quotas have been exceeded.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.UpdateSolNetworkInstance
* @see AWS
* API Documentation
*/
default CompletableFuture updateSolNetworkInstance(
UpdateSolNetworkInstanceRequest updateSolNetworkInstanceRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Update a network instance.
*
*
* A network instance is a single network created in Amazon Web Services TNB that can be deployed and on which
* life-cycle operations (like terminate, update, and delete) can be performed.
*
*
* Choose the updateType parameter to target the necessary update of the network instance.
*
*
*
* This is a convenience which creates an instance of the {@link UpdateSolNetworkInstanceRequest.Builder} avoiding
* the need to create one manually via {@link UpdateSolNetworkInstanceRequest#builder()}
*
*
* @param updateSolNetworkInstanceRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.UpdateSolNetworkInstanceRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the UpdateSolNetworkInstance 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ServiceQuotaExceededException Service quotas have been exceeded.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.UpdateSolNetworkInstance
* @see AWS
* API Documentation
*/
default CompletableFuture updateSolNetworkInstance(
Consumer updateSolNetworkInstanceRequest) {
return updateSolNetworkInstance(UpdateSolNetworkInstanceRequest.builder().applyMutation(updateSolNetworkInstanceRequest)
.build());
}
/**
*
* Updates the operational state of a network package.
*
*
* A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to
* deploy and the Amazon Web Services infrastructure you want to deploy them on.
*
*
* A network service descriptor is a .yaml file in a network package that uses the TOSCA standard to describe the
* network functions you want to deploy and the Amazon Web Services infrastructure you want to deploy the network
* functions on.
*
*
* @param updateSolNetworkPackageRequest
* @return A Java Future containing the result of the UpdateSolNetworkPackage 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.UpdateSolNetworkPackage
* @see AWS
* API Documentation
*/
default CompletableFuture updateSolNetworkPackage(
UpdateSolNetworkPackageRequest updateSolNetworkPackageRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Updates the operational state of a network package.
*
*
* A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to
* deploy and the Amazon Web Services infrastructure you want to deploy them on.
*
*
* A network service descriptor is a .yaml file in a network package that uses the TOSCA standard to describe the
* network functions you want to deploy and the Amazon Web Services infrastructure you want to deploy the network
* functions on.
*
*
*
* This is a convenience which creates an instance of the {@link UpdateSolNetworkPackageRequest.Builder} avoiding
* the need to create one manually via {@link UpdateSolNetworkPackageRequest#builder()}
*
*
* @param updateSolNetworkPackageRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.UpdateSolNetworkPackageRequest.Builder} to create a
* request.
* @return A Java Future containing the result of the UpdateSolNetworkPackage 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.UpdateSolNetworkPackage
* @see AWS
* API Documentation
*/
default CompletableFuture updateSolNetworkPackage(
Consumer updateSolNetworkPackageRequest) {
return updateSolNetworkPackage(UpdateSolNetworkPackageRequest.builder().applyMutation(updateSolNetworkPackageRequest)
.build());
}
/**
*
* Validates function package content. This can be used as a dry run before uploading function package content with
*
* PutSolFunctionPackageContent.
*
*
* A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an
* ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to
* describe how the network functions should run on your network.
*
*
* @param validateSolFunctionPackageContentRequest
* @return A Java Future containing the result of the ValidateSolFunctionPackageContent 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ValidateSolFunctionPackageContent
* @see AWS API Documentation
*/
default CompletableFuture validateSolFunctionPackageContent(
ValidateSolFunctionPackageContentRequest validateSolFunctionPackageContentRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Validates function package content. This can be used as a dry run before uploading function package content with
*
* PutSolFunctionPackageContent.
*
*
* A function package is a .zip file in CSAR (Cloud Service Archive) format that contains a network function (an
* ETSI standard telecommunication application) and function package descriptor that uses the TOSCA standard to
* describe how the network functions should run on your network.
*
*
*
* This is a convenience which creates an instance of the {@link ValidateSolFunctionPackageContentRequest.Builder}
* avoiding the need to create one manually via {@link ValidateSolFunctionPackageContentRequest#builder()}
*
*
* @param validateSolFunctionPackageContentRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.ValidateSolFunctionPackageContentRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the ValidateSolFunctionPackageContent 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ValidateSolFunctionPackageContent
* @see AWS API Documentation
*/
default CompletableFuture validateSolFunctionPackageContent(
Consumer validateSolFunctionPackageContentRequest) {
return validateSolFunctionPackageContent(ValidateSolFunctionPackageContentRequest.builder()
.applyMutation(validateSolFunctionPackageContentRequest).build());
}
/**
*
* Validates network package content. This can be used as a dry run before uploading network package content with
* PutSolNetworkPackageContent.
*
*
* A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to
* deploy and the Amazon Web Services infrastructure you want to deploy them on.
*
*
* @param validateSolNetworkPackageContentRequest
* @return A Java Future containing the result of the ValidateSolNetworkPackageContent 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ValidateSolNetworkPackageContent
* @see AWS API Documentation
*/
default CompletableFuture validateSolNetworkPackageContent(
ValidateSolNetworkPackageContentRequest validateSolNetworkPackageContentRequest) {
throw new UnsupportedOperationException();
}
/**
*
* Validates network package content. This can be used as a dry run before uploading network package content with
* PutSolNetworkPackageContent.
*
*
* A network package is a .zip file in CSAR (Cloud Service Archive) format defines the function packages you want to
* deploy and the Amazon Web Services infrastructure you want to deploy them on.
*
*
*
* This is a convenience which creates an instance of the {@link ValidateSolNetworkPackageContentRequest.Builder}
* avoiding the need to create one manually via {@link ValidateSolNetworkPackageContentRequest#builder()}
*
*
* @param validateSolNetworkPackageContentRequest
* A {@link Consumer} that will call methods on
* {@link software.amazon.awssdk.services.tnb.model.ValidateSolNetworkPackageContentRequest.Builder} to
* create a request.
* @return A Java Future containing the result of the ValidateSolNetworkPackageContent 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.
*
* - InternalServerException Unexpected error occurred. Problem on the server.
* - ThrottlingException Exception caused by throttling.
* - ValidationException Unable to process the request because the client provided input failed to satisfy
* request constraints.
* - ResourceNotFoundException Request references a resource that doesn't exist.
* - AccessDeniedException Insufficient permissions to make request.
* - 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.
* - TnbException Base class for all service exceptions. Unknown exceptions will be thrown as an instance
* of this type.
*
* @sample TnbAsyncClient.ValidateSolNetworkPackageContent
* @see AWS API Documentation
*/
default CompletableFuture validateSolNetworkPackageContent(
Consumer validateSolNetworkPackageContentRequest) {
return validateSolNetworkPackageContent(ValidateSolNetworkPackageContentRequest.builder()
.applyMutation(validateSolNetworkPackageContentRequest).build());
}
@Override
default TnbServiceClientConfiguration serviceClientConfiguration() {
throw new UnsupportedOperationException();
}
/**
* Create a {@link TnbAsyncClient} 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 TnbAsyncClient create() {
return builder().build();
}
/**
* Create a builder that can be used to configure and create a {@link TnbAsyncClient}.
*/
static TnbAsyncClientBuilder builder() {
return new DefaultTnbAsyncClientBuilder();
}
}