Anthos Multi-Cloud v1 API - Class AwsClustersClient (2.7.0)

// 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;
}

// 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;
}

// 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;
}

// 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;
}

// 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;
}

// 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;
}

// 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;
}

// 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;
}

// 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;
}

// 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;
}

// 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;
}

// 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;
}

// 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;
}

// 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;
}

// 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;
}

// 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;
}

// 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;
}

// 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;
}

// 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;
}

// 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 = "",
    IgnoreErrors = false,
};
// 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;
}

// 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;
}

// 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;
}

// 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;
}

// 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 = "",
    IgnoreErrors = false,
};
// 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;
}

// 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 = "",
    IgnoreErrors = false,
};
// 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;
}

// 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;
}

// 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;
}

// 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;
}

// 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 = "",
    IgnoreErrors = false,
};
// 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;
}

// 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;
}

// 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;
}

// 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;
}

// 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 = "",
    IgnoreErrors = false,
};
// 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;
}

// 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 = "",
    IgnoreErrors = false,
};
// 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;
}

// 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;
}

// 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;
}

// 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);

// 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);

// 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);

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
GenerateAwsClusterAgentTokenRequest request = new GenerateAwsClusterAgentTokenRequest
{
    AwsClusterAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
    SubjectToken = "",
    SubjectTokenType = "",
    Version = "",
    NodePoolId = "",
    GrantType = "",
    Audience = "",
    Scope = "",
    RequestedTokenType = "",
    Options = "",
};
// Make the request
GenerateAwsClusterAgentTokenResponse response = awsClustersClient.GenerateAwsClusterAgentToken(request);

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GenerateAwsClusterAgentTokenRequest request = new GenerateAwsClusterAgentTokenRequest
{
    AwsClusterAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
    SubjectToken = "",
    SubjectTokenType = "",
    Version = "",
    NodePoolId = "",
    GrantType = "",
    Audience = "",
    Scope = "",
    RequestedTokenType = "",
    Options = "",
};
// Make the request
GenerateAwsClusterAgentTokenResponse response = await awsClustersClient.GenerateAwsClusterAgentTokenAsync(request);

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
GenerateAwsClusterAgentTokenRequest request = new GenerateAwsClusterAgentTokenRequest
{
    AwsClusterAsAwsClusterName = AwsClusterName.FromProjectLocationAwsCluster("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]"),
    SubjectToken = "",
    SubjectTokenType = "",
    Version = "",
    NodePoolId = "",
    GrantType = "",
    Audience = "",
    Scope = "",
    RequestedTokenType = "",
    Options = "",
};
// Make the request
GenerateAwsClusterAgentTokenResponse response = await awsClustersClient.GenerateAwsClusterAgentTokenAsync(request);

// 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);

// 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);

// 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);

// 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);

// 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);

// 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);

// 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);

// 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);

// 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);

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

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

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

// 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);

// 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);

// 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);

// 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);

// 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);

// 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);

// 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);

// 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);

// 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);

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

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

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

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

// 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);

// 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);

// 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);

// 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);

// 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);

// 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);

// 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);

// 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);

// 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;

// 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;

// 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;

// 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;

// 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;

// 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;

// 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;

// 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;

// 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;

// 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;

// 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;

// 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;

// 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<AwsNodePool, OperationMetadata> response = awsClustersClient.RollbackAwsNodePoolUpdate(name);

// 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.PollOnceRollbackAwsNodePoolUpdate(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;
}

// Create client
AwsClustersClient awsClustersClient = AwsClustersClient.Create();
// Initialize request argument(s)
RollbackAwsNodePoolUpdateRequest request = new RollbackAwsNodePoolUpdateRequest
{
    AwsNodePoolName = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]"),
    RespectPdb = false,
};
// Make the request
Operation<AwsNodePool, OperationMetadata> response = awsClustersClient.RollbackAwsNodePoolUpdate(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.PollOnceRollbackAwsNodePoolUpdate(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;
}

// 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<AwsNodePool, OperationMetadata> response = awsClustersClient.RollbackAwsNodePoolUpdate(name);

// 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.PollOnceRollbackAwsNodePoolUpdate(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;
}

// 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<AwsNodePool, OperationMetadata> response = await awsClustersClient.RollbackAwsNodePoolUpdateAsync(name);

// 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.PollOnceRollbackAwsNodePoolUpdateAsync(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;
}

// 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<AwsNodePool, OperationMetadata> response = await awsClustersClient.RollbackAwsNodePoolUpdateAsync(name);

// 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.PollOnceRollbackAwsNodePoolUpdateAsync(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;
}

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
RollbackAwsNodePoolUpdateRequest request = new RollbackAwsNodePoolUpdateRequest
{
    AwsNodePoolName = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]"),
    RespectPdb = false,
};
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.RollbackAwsNodePoolUpdateAsync(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.PollOnceRollbackAwsNodePoolUpdateAsync(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;
}

// Create client
AwsClustersClient awsClustersClient = await AwsClustersClient.CreateAsync();
// Initialize request argument(s)
RollbackAwsNodePoolUpdateRequest request = new RollbackAwsNodePoolUpdateRequest
{
    AwsNodePoolName = AwsNodePoolName.FromProjectLocationAwsClusterAwsNodePool("[PROJECT]", "[LOCATION]", "[AWS_CLUSTER]", "[AWS_NODE_POOL]"),
    RespectPdb = false,
};
// Make the request
Operation<AwsNodePool, OperationMetadata> response = await awsClustersClient.RollbackAwsNodePoolUpdateAsync(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.PollOnceRollbackAwsNodePoolUpdateAsync(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;
}

// 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<AwsNodePool, OperationMetadata> response = await awsClustersClient.RollbackAwsNodePoolUpdateAsync(name);

// 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.PollOnceRollbackAwsNodePoolUpdateAsync(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;
}

// 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<AwsNodePool, OperationMetadata> response = await awsClustersClient.RollbackAwsNodePoolUpdateAsync(name);

// 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.PollOnceRollbackAwsNodePoolUpdateAsync(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;
}

// 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;
}