Class AwsClustersClient (1.0.0-beta01)

public abstract class AwsClustersClient

Namespace

Assembly

Google.Cloud.GkeMultiCloud.V1.dll

Remarks

Properties

CreateAwsClusterOperationsClient

public virtual OperationsClient CreateAwsClusterOperationsClient { get; }

CreateAwsNodePoolOperationsClient

public virtual OperationsClient CreateAwsNodePoolOperationsClient { get; }

DefaultEndpoint

public static string DefaultEndpoint { get; }

DefaultScopes

public static IReadOnlyList<string> DefaultScopes { get; }

DeleteAwsClusterOperationsClient

public virtual OperationsClient DeleteAwsClusterOperationsClient { get; }

DeleteAwsNodePoolOperationsClient

public virtual OperationsClient DeleteAwsNodePoolOperationsClient { get; }

GrpcClient

public virtual AwsClusters.AwsClustersClient GrpcClient { get; }

UpdateAwsClusterOperationsClient

public virtual OperationsClient UpdateAwsClusterOperationsClient { get; }

UpdateAwsNodePoolOperationsClient

public virtual OperationsClient UpdateAwsNodePoolOperationsClient { get; }

Methods

Create()

public static AwsClustersClient Create()

CreateAsync(CancellationToken)

public static Task<AwsClustersClient> CreateAsync(CancellationToken cancellationToken = default(CancellationToken))

CreateAwsCluster(LocationName, AwsCluster, String, CallSettings)

public virtual Operation<AwsCluster, OperationMetadata> CreateAwsCluster(LocationName parent, AwsCluster awsCluster, string awsClusterId, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
AwsCluster awsCluster = new AwsCluster();
string awsClusterId = "";
// Make the request
Operation<AwsCluster, OperationMetadata> response = awsClustersClient.CreateAwsCluster(parent, awsCluster, awsClusterId);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceCreateAwsCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

CreateAwsCluster(CreateAwsClusterRequest, CallSettings)

public virtual Operation<AwsCluster, OperationMetadata> CreateAwsCluster(CreateAwsClusterRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
CreateAwsClusterRequest request = new CreateAwsClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AwsCluster = new AwsCluster(),
    AwsClusterId = "",
    ValidateOnly = false,
};
// Make the request
Operation<AwsCluster, OperationMetadata> response = awsClustersClient.CreateAwsCluster(request);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceCreateAwsCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

CreateAwsCluster(String, AwsCluster, String, CallSettings)

public virtual Operation<AwsCluster, OperationMetadata> CreateAwsCluster(string parent, AwsCluster awsCluster, string awsClusterId, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
AwsCluster awsCluster = new AwsCluster();
string awsClusterId = "";
// Make the request
Operation<AwsCluster, OperationMetadata> response = awsClustersClient.CreateAwsCluster(parent, awsCluster, awsClusterId);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceCreateAwsCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

CreateAwsClusterAsync(LocationName, AwsCluster, String, CallSettings)

public virtual Task<Operation<AwsCluster, OperationMetadata>> CreateAwsClusterAsync(LocationName parent, AwsCluster awsCluster, string awsClusterId, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
AwsCluster awsCluster = new AwsCluster();
string awsClusterId = "";
// Make the request
Operation<AwsCluster, OperationMetadata> response = await awsClustersClient.CreateAwsClusterAsync(parent, awsCluster, awsClusterId);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

CreateAwsClusterAsync(LocationName, AwsCluster, String, CancellationToken)

public virtual Task<Operation<AwsCluster, OperationMetadata>> CreateAwsClusterAsync(LocationName parent, AwsCluster awsCluster, string awsClusterId, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
AwsCluster awsCluster = new AwsCluster();
string awsClusterId = "";
// Make the request
Operation<AwsCluster, OperationMetadata> response = await awsClustersClient.CreateAwsClusterAsync(parent, awsCluster, awsClusterId);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

CreateAwsClusterAsync(CreateAwsClusterRequest, CallSettings)

public virtual Task<Operation<AwsCluster, OperationMetadata>> CreateAwsClusterAsync(CreateAwsClusterRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
CreateAwsClusterRequest request = new CreateAwsClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AwsCluster = new AwsCluster(),
    AwsClusterId = "",
    ValidateOnly = false,
};
// Make the request
Operation<AwsCluster, OperationMetadata> response = await awsClustersClient.CreateAwsClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

CreateAwsClusterAsync(CreateAwsClusterRequest, CancellationToken)

public virtual Task<Operation<AwsCluster, OperationMetadata>> CreateAwsClusterAsync(CreateAwsClusterRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
CreateAwsClusterRequest request = new CreateAwsClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AwsCluster = new AwsCluster(),
    AwsClusterId = "",
    ValidateOnly = false,
};
// Make the request
Operation<AwsCluster, OperationMetadata> response = await awsClustersClient.CreateAwsClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

CreateAwsClusterAsync(String, AwsCluster, String, CallSettings)

public virtual Task<Operation<AwsCluster, OperationMetadata>> CreateAwsClusterAsync(string parent, AwsCluster awsCluster, string awsClusterId, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
AwsCluster awsCluster = new AwsCluster();
string awsClusterId = "";
// Make the request
Operation<AwsCluster, OperationMetadata> response = await awsClustersClient.CreateAwsClusterAsync(parent, awsCluster, awsClusterId);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

CreateAwsClusterAsync(String, AwsCluster, String, CancellationToken)

public virtual Task<Operation<AwsCluster, OperationMetadata>> CreateAwsClusterAsync(string parent, AwsCluster awsCluster, string awsClusterId, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
AwsCluster awsCluster = new AwsCluster();
string awsClusterId = "";
// Make the request
Operation<AwsCluster, OperationMetadata> response = await awsClustersClient.CreateAwsClusterAsync(parent, awsCluster, awsClusterId);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

CreateAwsNodePool(AwsClusterName, AwsNodePool, String, CallSettings)

public virtual Operation<AwsNodePool, OperationMetadata> CreateAwsNodePool(AwsClusterName parent, AwsNodePool awsNodePool, string awsNodePoolId, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
AwsClusterName parent = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
AwsNodePool awsNodePool = new AwsNodePool();
string awsNodePoolId = "";
// Make the request
Operation<AwsNodePool, OperationMetadata> response = awsClustersClient.CreateAwsNodePool(parent, awsNodePool, awsNodePoolId);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceCreateAwsNodePool(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

CreateAwsNodePool(CreateAwsNodePoolRequest, CallSettings)

public virtual Operation<AwsNodePool, OperationMetadata> CreateAwsNodePool(CreateAwsNodePoolRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
CreateAwsNodePoolRequest request = new CreateAwsNodePoolRequest
{
    ParentAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
    AwsNodePool = new AwsNodePool(),
    AwsNodePoolId = "",
    ValidateOnly = false,
};
// Make the request
Operation<AwsNodePool, OperationMetadata> response = awsClustersClient.CreateAwsNodePool(request);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceCreateAwsNodePool(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

CreateAwsNodePool(String, AwsNodePool, String, CallSettings)

public virtual Operation<AwsNodePool, OperationMetadata> CreateAwsNodePool(string parent, AwsNodePool awsNodePool, string awsNodePoolId, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
AwsNodePool awsNodePool = new AwsNodePool();
string awsNodePoolId = "";
// Make the request
Operation<AwsNodePool, OperationMetadata> response = awsClustersClient.CreateAwsNodePool(parent, awsNodePool, awsNodePoolId);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceCreateAwsNodePool(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

CreateAwsNodePoolAsync(AwsClusterName, AwsNodePool, String, CallSettings)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> CreateAwsNodePoolAsync(AwsClusterName parent, AwsNodePool awsNodePool, string awsNodePoolId, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsClusterName parent = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
AwsNodePool awsNodePool = new AwsNodePool();
string awsNodePoolId = "";
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.CreateAwsNodePoolAsync(parent, awsNodePool, awsNodePoolId);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

CreateAwsNodePoolAsync(AwsClusterName, AwsNodePool, String, CancellationToken)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> CreateAwsNodePoolAsync(AwsClusterName parent, AwsNodePool awsNodePool, string awsNodePoolId, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsClusterName parent = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
AwsNodePool awsNodePool = new AwsNodePool();
string awsNodePoolId = "";
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.CreateAwsNodePoolAsync(parent, awsNodePool, awsNodePoolId);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

CreateAwsNodePoolAsync(CreateAwsNodePoolRequest, CallSettings)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> CreateAwsNodePoolAsync(CreateAwsNodePoolRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
CreateAwsNodePoolRequest request = new CreateAwsNodePoolRequest
{
    ParentAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
    AwsNodePool = new AwsNodePool(),
    AwsNodePoolId = "",
    ValidateOnly = false,
};
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.CreateAwsNodePoolAsync(request);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

CreateAwsNodePoolAsync(CreateAwsNodePoolRequest, CancellationToken)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> CreateAwsNodePoolAsync(CreateAwsNodePoolRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
CreateAwsNodePoolRequest request = new CreateAwsNodePoolRequest
{
    ParentAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
    AwsNodePool = new AwsNodePool(),
    AwsNodePoolId = "",
    ValidateOnly = false,
};
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.CreateAwsNodePoolAsync(request);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

CreateAwsNodePoolAsync(String, AwsNodePool, String, CallSettings)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> CreateAwsNodePoolAsync(string parent, AwsNodePool awsNodePool, string awsNodePoolId, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
AwsNodePool awsNodePool = new AwsNodePool();
string awsNodePoolId = "";
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.CreateAwsNodePoolAsync(parent, awsNodePool, awsNodePoolId);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

CreateAwsNodePoolAsync(String, AwsNodePool, String, CancellationToken)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> CreateAwsNodePoolAsync(string parent, AwsNodePool awsNodePool, string awsNodePoolId, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
AwsNodePool awsNodePool = new AwsNodePool();
string awsNodePoolId = "";
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.CreateAwsNodePoolAsync(parent, awsNodePool, awsNodePoolId);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceCreateAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

DeleteAwsCluster(AwsClusterName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteAwsCluster(AwsClusterName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
AwsClusterName name = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
// Make the request
Operation<Empty, OperationMetadata> response = awsClustersClient.DeleteAwsCluster(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceDeleteAwsCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsCluster(DeleteAwsClusterRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteAwsCluster(DeleteAwsClusterRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
DeleteAwsClusterRequest request = new DeleteAwsClusterRequest
{
    AwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
    ValidateOnly = false,
    AllowMissing = false,
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = awsClustersClient.DeleteAwsCluster(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceDeleteAwsCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsCluster(String, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteAwsCluster(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
// Make the request
Operation<Empty, OperationMetadata> response = awsClustersClient.DeleteAwsCluster(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceDeleteAwsCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsClusterAsync(AwsClusterName, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsClusterAsync(AwsClusterName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsClusterName name = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsClusterAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsClusterAsync(AwsClusterName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsClusterAsync(AwsClusterName name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsClusterName name = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsClusterAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsClusterAsync(DeleteAwsClusterRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsClusterAsync(DeleteAwsClusterRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
DeleteAwsClusterRequest request = new DeleteAwsClusterRequest
{
    AwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
    ValidateOnly = false,
    AllowMissing = false,
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsClusterAsync(DeleteAwsClusterRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsClusterAsync(DeleteAwsClusterRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
DeleteAwsClusterRequest request = new DeleteAwsClusterRequest
{
    AwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
    ValidateOnly = false,
    AllowMissing = false,
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsClusterAsync(String, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsClusterAsync(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsClusterAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsClusterAsync(String, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsClusterAsync(string name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsClusterAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsNodePool(AwsNodePoolName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteAwsNodePool(AwsNodePoolName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
AwsNodePoolName name = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]");
// Make the request
Operation<Empty, OperationMetadata> response = awsClustersClient.DeleteAwsNodePool(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceDeleteAwsNodePool(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsNodePool(DeleteAwsNodePoolRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteAwsNodePool(DeleteAwsNodePoolRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
DeleteAwsNodePoolRequest request = new DeleteAwsNodePoolRequest
{
    AwsNodePoolName = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]"),
    ValidateOnly = false,
    AllowMissing = false,
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = awsClustersClient.DeleteAwsNodePool(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceDeleteAwsNodePool(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsNodePool(String, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteAwsNodePool(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]/awsNodePools/[AWS_NODE_POOL]";
// Make the request
Operation<Empty, OperationMetadata> response = awsClustersClient.DeleteAwsNodePool(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceDeleteAwsNodePool(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsNodePoolAsync(AwsNodePoolName, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsNodePoolAsync(AwsNodePoolName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsNodePoolName name = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]");
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsNodePoolAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsNodePoolAsync(AwsNodePoolName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsNodePoolAsync(AwsNodePoolName name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsNodePoolName name = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]");
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsNodePoolAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsNodePoolAsync(DeleteAwsNodePoolRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsNodePoolAsync(DeleteAwsNodePoolRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
DeleteAwsNodePoolRequest request = new DeleteAwsNodePoolRequest
{
    AwsNodePoolName = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]"),
    ValidateOnly = false,
    AllowMissing = false,
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsNodePoolAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsNodePoolAsync(DeleteAwsNodePoolRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsNodePoolAsync(DeleteAwsNodePoolRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
DeleteAwsNodePoolRequest request = new DeleteAwsNodePoolRequest
{
    AwsNodePoolName = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]"),
    ValidateOnly = false,
    AllowMissing = false,
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsNodePoolAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsNodePoolAsync(String, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsNodePoolAsync(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]/awsNodePools/[AWS_NODE_POOL]";
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsNodePoolAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

DeleteAwsNodePoolAsync(String, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAwsNodePoolAsync(string name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]/awsNodePools/[AWS_NODE_POOL]";
// Make the request
Operation<Empty, OperationMetadata> response = await awsClustersClient.DeleteAwsNodePoolAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
Empty result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceDeleteAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

GenerateAwsAccessToken(GenerateAwsAccessTokenRequest, CallSettings)

public virtual GenerateAwsAccessTokenResponse GenerateAwsAccessToken(GenerateAwsAccessTokenRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
GenerateAwsAccessTokenRequest request = new GenerateAwsAccessTokenRequest
{
    AwsClusterAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
GenerateAwsAccessTokenResponse response = awsClustersClient.GenerateAwsAccessToken(request);

GenerateAwsAccessTokenAsync(GenerateAwsAccessTokenRequest, CallSettings)

public virtual Task<GenerateAwsAccessTokenResponse> GenerateAwsAccessTokenAsync(GenerateAwsAccessTokenRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GenerateAwsAccessTokenRequest request = new GenerateAwsAccessTokenRequest
{
    AwsClusterAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
GenerateAwsAccessTokenResponse response = await awsClustersClient.GenerateAwsAccessTokenAsync(request);

GenerateAwsAccessTokenAsync(GenerateAwsAccessTokenRequest, CancellationToken)

public virtual Task<GenerateAwsAccessTokenResponse> GenerateAwsAccessTokenAsync(GenerateAwsAccessTokenRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GenerateAwsAccessTokenRequest request = new GenerateAwsAccessTokenRequest
{
    AwsClusterAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
GenerateAwsAccessTokenResponse response = await awsClustersClient.GenerateAwsAccessTokenAsync(request);

GetAwsCluster(AwsClusterName, CallSettings)

public virtual AwsCluster GetAwsCluster(AwsClusterName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
AwsClusterName name = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
// Make the request
AwsCluster response = awsClustersClient.GetAwsCluster(name);

GetAwsCluster(GetAwsClusterRequest, CallSettings)

public virtual AwsCluster GetAwsCluster(GetAwsClusterRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
GetAwsClusterRequest request = new GetAwsClusterRequest
{
    AwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
AwsCluster response = awsClustersClient.GetAwsCluster(request);

GetAwsCluster(String, CallSettings)

public virtual AwsCluster GetAwsCluster(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
// Make the request
AwsCluster response = awsClustersClient.GetAwsCluster(name);

GetAwsClusterAsync(AwsClusterName, CallSettings)

public virtual Task<AwsCluster> GetAwsClusterAsync(AwsClusterName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsClusterName name = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
// Make the request
AwsCluster response = await awsClustersClient.GetAwsClusterAsync(name);

GetAwsClusterAsync(AwsClusterName, CancellationToken)

public virtual Task<AwsCluster> GetAwsClusterAsync(AwsClusterName name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsClusterName name = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
// Make the request
AwsCluster response = await awsClustersClient.GetAwsClusterAsync(name);

GetAwsClusterAsync(GetAwsClusterRequest, CallSettings)

public virtual Task<AwsCluster> GetAwsClusterAsync(GetAwsClusterRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GetAwsClusterRequest request = new GetAwsClusterRequest
{
    AwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
AwsCluster response = await awsClustersClient.GetAwsClusterAsync(request);

GetAwsClusterAsync(GetAwsClusterRequest, CancellationToken)

public virtual Task<AwsCluster> GetAwsClusterAsync(GetAwsClusterRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GetAwsClusterRequest request = new GetAwsClusterRequest
{
    AwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
AwsCluster response = await awsClustersClient.GetAwsClusterAsync(request);

GetAwsClusterAsync(String, CallSettings)

public virtual Task<AwsCluster> GetAwsClusterAsync(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
// Make the request
AwsCluster response = await awsClustersClient.GetAwsClusterAsync(name);

GetAwsClusterAsync(String, CancellationToken)

public virtual Task<AwsCluster> GetAwsClusterAsync(string name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
// Make the request
AwsCluster response = await awsClustersClient.GetAwsClusterAsync(name);

GetAwsNodePool(AwsNodePoolName, CallSettings)

public virtual AwsNodePool GetAwsNodePool(AwsNodePoolName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
AwsNodePoolName name = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]");
// Make the request
AwsNodePool response = awsClustersClient.GetAwsNodePool(name);

GetAwsNodePool(GetAwsNodePoolRequest, CallSettings)

public virtual AwsNodePool GetAwsNodePool(GetAwsNodePoolRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
GetAwsNodePoolRequest request = new GetAwsNodePoolRequest
{
    AwsNodePoolName = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]"),
};
// Make the request
AwsNodePool response = awsClustersClient.GetAwsNodePool(request);

GetAwsNodePool(String, CallSettings)

public virtual AwsNodePool GetAwsNodePool(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]/awsNodePools/[AWS_NODE_POOL]";
// Make the request
AwsNodePool response = awsClustersClient.GetAwsNodePool(name);

GetAwsNodePoolAsync(AwsNodePoolName, CallSettings)

public virtual Task<AwsNodePool> GetAwsNodePoolAsync(AwsNodePoolName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsNodePoolName name = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]");
// Make the request
AwsNodePool response = await awsClustersClient.GetAwsNodePoolAsync(name);

GetAwsNodePoolAsync(AwsNodePoolName, CancellationToken)

public virtual Task<AwsNodePool> GetAwsNodePoolAsync(AwsNodePoolName name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsNodePoolName name = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]");
// Make the request
AwsNodePool response = await awsClustersClient.GetAwsNodePoolAsync(name);

GetAwsNodePoolAsync(GetAwsNodePoolRequest, CallSettings)

public virtual Task<AwsNodePool> GetAwsNodePoolAsync(GetAwsNodePoolRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GetAwsNodePoolRequest request = new GetAwsNodePoolRequest
{
    AwsNodePoolName = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]"),
};
// Make the request
AwsNodePool response = await awsClustersClient.GetAwsNodePoolAsync(request);

GetAwsNodePoolAsync(GetAwsNodePoolRequest, CancellationToken)

public virtual Task<AwsNodePool> GetAwsNodePoolAsync(GetAwsNodePoolRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GetAwsNodePoolRequest request = new GetAwsNodePoolRequest
{
    AwsNodePoolName = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]"),
};
// Make the request
AwsNodePool response = await awsClustersClient.GetAwsNodePoolAsync(request);

GetAwsNodePoolAsync(String, CallSettings)

public virtual Task<AwsNodePool> GetAwsNodePoolAsync(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]/awsNodePools/[AWS_NODE_POOL]";
// Make the request
AwsNodePool response = await awsClustersClient.GetAwsNodePoolAsync(name);

GetAwsNodePoolAsync(String, CancellationToken)

public virtual Task<AwsNodePool> GetAwsNodePoolAsync(string name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]/awsNodePools/[AWS_NODE_POOL]";
// Make the request
AwsNodePool response = await awsClustersClient.GetAwsNodePoolAsync(name);

GetAwsServerConfig(AwsServerConfigName, CallSettings)

public virtual AwsServerConfig GetAwsServerConfig(AwsServerConfigName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
AwsServerConfigName name = AwsServerConfigName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
AwsServerConfig response = awsClustersClient.GetAwsServerConfig(name);

GetAwsServerConfig(GetAwsServerConfigRequest, CallSettings)

public virtual AwsServerConfig GetAwsServerConfig(GetAwsServerConfigRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
GetAwsServerConfigRequest request = new GetAwsServerConfigRequest
{
    AwsServerConfigName = AwsServerConfigName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
AwsServerConfig response = awsClustersClient.GetAwsServerConfig(request);

GetAwsServerConfig(String, CallSettings)

public virtual AwsServerConfig GetAwsServerConfig(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsServerConfig";
// Make the request
AwsServerConfig response = awsClustersClient.GetAwsServerConfig(name);

GetAwsServerConfigAsync(AwsServerConfigName, CallSettings)

public virtual Task<AwsServerConfig> GetAwsServerConfigAsync(AwsServerConfigName name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsServerConfigName name = AwsServerConfigName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
AwsServerConfig response = await awsClustersClient.GetAwsServerConfigAsync(name);

GetAwsServerConfigAsync(AwsServerConfigName, CancellationToken)

public virtual Task<AwsServerConfig> GetAwsServerConfigAsync(AwsServerConfigName name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsServerConfigName name = AwsServerConfigName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
AwsServerConfig response = await awsClustersClient.GetAwsServerConfigAsync(name);

GetAwsServerConfigAsync(GetAwsServerConfigRequest, CallSettings)

public virtual Task<AwsServerConfig> GetAwsServerConfigAsync(GetAwsServerConfigRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GetAwsServerConfigRequest request = new GetAwsServerConfigRequest
{
    AwsServerConfigName = AwsServerConfigName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
AwsServerConfig response = await awsClustersClient.GetAwsServerConfigAsync(request);

GetAwsServerConfigAsync(GetAwsServerConfigRequest, CancellationToken)

public virtual Task<AwsServerConfig> GetAwsServerConfigAsync(GetAwsServerConfigRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GetAwsServerConfigRequest request = new GetAwsServerConfigRequest
{
    AwsServerConfigName = AwsServerConfigName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
AwsServerConfig response = await awsClustersClient.GetAwsServerConfigAsync(request);

GetAwsServerConfigAsync(String, CallSettings)

public virtual Task<AwsServerConfig> GetAwsServerConfigAsync(string name, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsServerConfig";
// Make the request
AwsServerConfig response = await awsClustersClient.GetAwsServerConfigAsync(name);

GetAwsServerConfigAsync(String, CancellationToken)

public virtual Task<AwsServerConfig> GetAwsServerConfigAsync(string name, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/awsServerConfig";
// Make the request
AwsServerConfig response = await awsClustersClient.GetAwsServerConfigAsync(name);

ListAwsClusters(LocationName, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListAwsClustersResponse, AwsCluster> ListAwsClusters(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListAwsClustersResponse, AwsCluster> response = awsClustersClient.ListAwsClusters(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (AwsCluster item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListAwsClustersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsCluster item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsCluster> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsCluster item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsClusters(ListAwsClustersRequest, CallSettings)

public virtual PagedEnumerable<ListAwsClustersResponse, AwsCluster> ListAwsClusters(ListAwsClustersRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
ListAwsClustersRequest request = new ListAwsClustersRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedEnumerable<ListAwsClustersResponse, AwsCluster> response = awsClustersClient.ListAwsClusters(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (AwsCluster item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListAwsClustersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsCluster item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsCluster> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsCluster item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsClusters(String, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListAwsClustersResponse, AwsCluster> ListAwsClusters(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListAwsClustersResponse, AwsCluster> response = awsClustersClient.ListAwsClusters(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (AwsCluster item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListAwsClustersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsCluster item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsCluster> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsCluster item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsClustersAsync(LocationName, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListAwsClustersResponse, AwsCluster> ListAwsClustersAsync(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListAwsClustersResponse, AwsCluster> response = awsClustersClient.ListAwsClustersAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AwsCluster item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListAwsClustersResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsCluster item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsCluster> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsCluster item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsClustersAsync(ListAwsClustersRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListAwsClustersResponse, AwsCluster> ListAwsClustersAsync(ListAwsClustersRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
ListAwsClustersRequest request = new ListAwsClustersRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedAsyncEnumerable<ListAwsClustersResponse, AwsCluster> response = awsClustersClient.ListAwsClustersAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AwsCluster item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListAwsClustersResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsCluster item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsCluster> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsCluster item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsClustersAsync(String, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListAwsClustersResponse, AwsCluster> ListAwsClustersAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListAwsClustersResponse, AwsCluster> response = awsClustersClient.ListAwsClustersAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AwsCluster item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListAwsClustersResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsCluster item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsCluster> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsCluster item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsNodePools(AwsClusterName, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListAwsNodePoolsResponse, AwsNodePool> ListAwsNodePools(AwsClusterName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
AwsClusterName parent = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
// Make the request
PagedEnumerable<ListAwsNodePoolsResponse, AwsNodePool> response = awsClustersClient.ListAwsNodePools(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (AwsNodePool item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListAwsNodePoolsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsNodePool item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsNodePool> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsNodePool item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsNodePools(ListAwsNodePoolsRequest, CallSettings)

public virtual PagedEnumerable<ListAwsNodePoolsResponse, AwsNodePool> ListAwsNodePools(ListAwsNodePoolsRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
ListAwsNodePoolsRequest request = new ListAwsNodePoolsRequest
{
    ParentAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
PagedEnumerable<ListAwsNodePoolsResponse, AwsNodePool> response = awsClustersClient.ListAwsNodePools(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (AwsNodePool item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListAwsNodePoolsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsNodePool item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsNodePool> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsNodePool item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsNodePools(String, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListAwsNodePoolsResponse, AwsNodePool> ListAwsNodePools(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
// Make the request
PagedEnumerable<ListAwsNodePoolsResponse, AwsNodePool> response = awsClustersClient.ListAwsNodePools(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (AwsNodePool item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListAwsNodePoolsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsNodePool item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsNodePool> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsNodePool item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsNodePoolsAsync(AwsClusterName, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListAwsNodePoolsResponse, AwsNodePool> ListAwsNodePoolsAsync(AwsClusterName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsClusterName parent = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]");
// Make the request
PagedAsyncEnumerable<ListAwsNodePoolsResponse, AwsNodePool> response = awsClustersClient.ListAwsNodePoolsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AwsNodePool item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListAwsNodePoolsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsNodePool item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsNodePool> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsNodePool item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsNodePoolsAsync(ListAwsNodePoolsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListAwsNodePoolsResponse, AwsNodePool> ListAwsNodePoolsAsync(ListAwsNodePoolsRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
ListAwsNodePoolsRequest request = new ListAwsNodePoolsRequest
{
    ParentAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
};
// Make the request
PagedAsyncEnumerable<ListAwsNodePoolsResponse, AwsNodePool> response = awsClustersClient.ListAwsNodePoolsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AwsNodePool item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListAwsNodePoolsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsNodePool item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsNodePool> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsNodePool item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListAwsNodePoolsAsync(String, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListAwsNodePoolsResponse, AwsNodePool> ListAwsNodePoolsAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/awsClusters/[AWS_CLUSTER]";
// Make the request
PagedAsyncEnumerable<ListAwsNodePoolsResponse, AwsNodePool> response = awsClustersClient.ListAwsNodePoolsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AwsNodePool item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListAwsNodePoolsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AwsNodePool item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AwsNodePool> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AwsNodePool item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

PollOnceCreateAwsCluster(String, CallSettings)

public virtual Operation<AwsCluster, OperationMetadata> PollOnceCreateAwsCluster(string operationName, CallSettings callSettings = null)

PollOnceCreateAwsClusterAsync(String, CallSettings)

public virtual Task<Operation<AwsCluster, OperationMetadata>> PollOnceCreateAwsClusterAsync(string operationName, CallSettings callSettings = null)

PollOnceCreateAwsNodePool(String, CallSettings)

public virtual Operation<AwsNodePool, OperationMetadata> PollOnceCreateAwsNodePool(string operationName, CallSettings callSettings = null)

PollOnceCreateAwsNodePoolAsync(String, CallSettings)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> PollOnceCreateAwsNodePoolAsync(string operationName, CallSettings callSettings = null)

PollOnceDeleteAwsCluster(String, CallSettings)

public virtual Operation<Empty, OperationMetadata> PollOnceDeleteAwsCluster(string operationName, CallSettings callSettings = null)

PollOnceDeleteAwsClusterAsync(String, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> PollOnceDeleteAwsClusterAsync(string operationName, CallSettings callSettings = null)

PollOnceDeleteAwsNodePool(String, CallSettings)

public virtual Operation<Empty, OperationMetadata> PollOnceDeleteAwsNodePool(string operationName, CallSettings callSettings = null)

PollOnceDeleteAwsNodePoolAsync(String, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> PollOnceDeleteAwsNodePoolAsync(string operationName, CallSettings callSettings = null)

PollOnceUpdateAwsCluster(String, CallSettings)

public virtual Operation<AwsCluster, OperationMetadata> PollOnceUpdateAwsCluster(string operationName, CallSettings callSettings = null)

PollOnceUpdateAwsClusterAsync(String, CallSettings)

public virtual Task<Operation<AwsCluster, OperationMetadata>> PollOnceUpdateAwsClusterAsync(string operationName, CallSettings callSettings = null)

PollOnceUpdateAwsNodePool(String, CallSettings)

public virtual Operation<AwsNodePool, OperationMetadata> PollOnceUpdateAwsNodePool(string operationName, CallSettings callSettings = null)

PollOnceUpdateAwsNodePoolAsync(String, CallSettings)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> PollOnceUpdateAwsNodePoolAsync(string operationName, CallSettings callSettings = null)

ShutdownDefaultChannelsAsync()

public static Task ShutdownDefaultChannelsAsync()

UpdateAwsCluster(AwsCluster, FieldMask, CallSettings)

public virtual Operation<AwsCluster, OperationMetadata> UpdateAwsCluster(AwsCluster awsCluster, FieldMask updateMask, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
AwsCluster awsCluster = new AwsCluster();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<AwsCluster, OperationMetadata> response = awsClustersClient.UpdateAwsCluster(awsCluster, updateMask);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceUpdateAwsCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

UpdateAwsCluster(UpdateAwsClusterRequest, CallSettings)

public virtual Operation<AwsCluster, OperationMetadata> UpdateAwsCluster(UpdateAwsClusterRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
UpdateAwsClusterRequest request = new UpdateAwsClusterRequest
{
    AwsCluster = new AwsCluster(),
    ValidateOnly = false,
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<AwsCluster, OperationMetadata> response = awsClustersClient.UpdateAwsCluster(request);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceUpdateAwsCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

UpdateAwsClusterAsync(AwsCluster, FieldMask, CallSettings)

public virtual Task<Operation<AwsCluster, OperationMetadata>> UpdateAwsClusterAsync(AwsCluster awsCluster, FieldMask updateMask, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsCluster awsCluster = new AwsCluster();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<AwsCluster, OperationMetadata> response = await awsClustersClient.UpdateAwsClusterAsync(awsCluster, updateMask);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceUpdateAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

UpdateAwsClusterAsync(AwsCluster, FieldMask, CancellationToken)

public virtual Task<Operation<AwsCluster, OperationMetadata>> UpdateAwsClusterAsync(AwsCluster awsCluster, FieldMask updateMask, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsCluster awsCluster = new AwsCluster();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<AwsCluster, OperationMetadata> response = await awsClustersClient.UpdateAwsClusterAsync(awsCluster, updateMask);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceUpdateAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

UpdateAwsClusterAsync(UpdateAwsClusterRequest, CallSettings)

public virtual Task<Operation<AwsCluster, OperationMetadata>> UpdateAwsClusterAsync(UpdateAwsClusterRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
UpdateAwsClusterRequest request = new UpdateAwsClusterRequest
{
    AwsCluster = new AwsCluster(),
    ValidateOnly = false,
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<AwsCluster, OperationMetadata> response = await awsClustersClient.UpdateAwsClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceUpdateAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

UpdateAwsClusterAsync(UpdateAwsClusterRequest, CancellationToken)

public virtual Task<Operation<AwsCluster, OperationMetadata>> UpdateAwsClusterAsync(UpdateAwsClusterRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
UpdateAwsClusterRequest request = new UpdateAwsClusterRequest
{
    AwsCluster = new AwsCluster(),
    ValidateOnly = false,
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<AwsCluster, OperationMetadata> response = await awsClustersClient.UpdateAwsClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<AwsCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsCluster result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsCluster, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceUpdateAwsClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsCluster retrievedResult = retrievedResponse.Result;
}

UpdateAwsNodePool(AwsNodePool, FieldMask, CallSettings)

public virtual Operation<AwsNodePool, OperationMetadata> UpdateAwsNodePool(AwsNodePool awsNodePool, FieldMask updateMask, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
AwsNodePool awsNodePool = new AwsNodePool();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<AwsNodePool, OperationMetadata> response = awsClustersClient.UpdateAwsNodePool(awsNodePool, updateMask);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceUpdateAwsNodePool(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

UpdateAwsNodePool(UpdateAwsNodePoolRequest, CallSettings)

public virtual Operation<AwsNodePool, OperationMetadata> UpdateAwsNodePool(UpdateAwsNodePoolRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
UpdateAwsNodePoolRequest request = new UpdateAwsNodePoolRequest
{
    AwsNodePool = new AwsNodePool(),
    ValidateOnly = false,
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<AwsNodePool, OperationMetadata> response = awsClustersClient.UpdateAwsNodePool(request);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = awsClustersClient.PollOnceUpdateAwsNodePool(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

UpdateAwsNodePoolAsync(AwsNodePool, FieldMask, CallSettings)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> UpdateAwsNodePoolAsync(AwsNodePool awsNodePool, FieldMask updateMask, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsNodePool awsNodePool = new AwsNodePool();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.UpdateAwsNodePoolAsync(awsNodePool, updateMask);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceUpdateAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

UpdateAwsNodePoolAsync(AwsNodePool, FieldMask, CancellationToken)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> UpdateAwsNodePoolAsync(AwsNodePool awsNodePool, FieldMask updateMask, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
AwsNodePool awsNodePool = new AwsNodePool();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.UpdateAwsNodePoolAsync(awsNodePool, updateMask);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceUpdateAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

UpdateAwsNodePoolAsync(UpdateAwsNodePoolRequest, CallSettings)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> UpdateAwsNodePoolAsync(UpdateAwsNodePoolRequest request, CallSettings callSettings = null)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
UpdateAwsNodePoolRequest request = new UpdateAwsNodePoolRequest
{
    AwsNodePool = new AwsNodePool(),
    ValidateOnly = false,
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.UpdateAwsNodePoolAsync(request);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceUpdateAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}

UpdateAwsNodePoolAsync(UpdateAwsNodePoolRequest, CancellationToken)

public virtual Task<Operation<AwsNodePool, OperationMetadata>> UpdateAwsNodePoolAsync(UpdateAwsNodePoolRequest request, CancellationToken cancellationToken)

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
UpdateAwsNodePoolRequest request = new UpdateAwsNodePoolRequest
{
    AwsNodePool = new AwsNodePool(),
    ValidateOnly = false,
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.UpdateAwsNodePoolAsync(request);

// Poll until the returned long-running operation is complete
Operation<AwsNodePool, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AwsNodePool result = completedResponse.Result;

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<AwsNodePool, OperationMetadata> retrievedResponse = await awsClustersClient.PollOnceUpdateAwsNodePoolAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AwsNodePool retrievedResult = retrievedResponse.Result;
}