Anthos Multi-Cloud v1 API - Class AttachedClustersClient (2.6.0)

// Create client
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
AttachedCluster attachedCluster = new AttachedCluster();
string attachedClusterId = "";
// Make the request
Operation<AttachedCluster, OperationMetadata> response = attachedClustersClient.CreateAttachedCluster(parent, attachedCluster, attachedClusterId);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = attachedClustersClient.PollOnceCreateAttachedCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
CreateAttachedClusterRequest request = new CreateAttachedClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AttachedCluster = new AttachedCluster(),
    AttachedClusterId = "",
    ValidateOnly = false,
};
// Make the request
Operation<AttachedCluster, OperationMetadata> response = attachedClustersClient.CreateAttachedCluster(request);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = attachedClustersClient.PollOnceCreateAttachedCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
AttachedCluster attachedCluster = new AttachedCluster();
string attachedClusterId = "";
// Make the request
Operation<AttachedCluster, OperationMetadata> response = attachedClustersClient.CreateAttachedCluster(parent, attachedCluster, attachedClusterId);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = attachedClustersClient.PollOnceCreateAttachedCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
AttachedCluster attachedCluster = new AttachedCluster();
string attachedClusterId = "";
// Make the request
Operation<AttachedCluster, OperationMetadata> response = await attachedClustersClient.CreateAttachedClusterAsync(parent, attachedCluster, attachedClusterId);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = await attachedClustersClient.PollOnceCreateAttachedClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
AttachedCluster attachedCluster = new AttachedCluster();
string attachedClusterId = "";
// Make the request
Operation<AttachedCluster, OperationMetadata> response = await attachedClustersClient.CreateAttachedClusterAsync(parent, attachedCluster, attachedClusterId);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = await attachedClustersClient.PollOnceCreateAttachedClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
CreateAttachedClusterRequest request = new CreateAttachedClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AttachedCluster = new AttachedCluster(),
    AttachedClusterId = "",
    ValidateOnly = false,
};
// Make the request
Operation<AttachedCluster, OperationMetadata> response = await attachedClustersClient.CreateAttachedClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = await attachedClustersClient.PollOnceCreateAttachedClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
CreateAttachedClusterRequest request = new CreateAttachedClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AttachedCluster = new AttachedCluster(),
    AttachedClusterId = "",
    ValidateOnly = false,
};
// Make the request
Operation<AttachedCluster, OperationMetadata> response = await attachedClustersClient.CreateAttachedClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = await attachedClustersClient.PollOnceCreateAttachedClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
AttachedCluster attachedCluster = new AttachedCluster();
string attachedClusterId = "";
// Make the request
Operation<AttachedCluster, OperationMetadata> response = await attachedClustersClient.CreateAttachedClusterAsync(parent, attachedCluster, attachedClusterId);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = await attachedClustersClient.PollOnceCreateAttachedClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
AttachedCluster attachedCluster = new AttachedCluster();
string attachedClusterId = "";
// Make the request
Operation<AttachedCluster, OperationMetadata> response = await attachedClustersClient.CreateAttachedClusterAsync(parent, attachedCluster, attachedClusterId);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = await attachedClustersClient.PollOnceCreateAttachedClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
AttachedClusterName name = AttachedClusterName.FromProjectLocationAttachedCluster("[PROJECT]", "[LOCATION]", "[ATTACHED_CLUSTER]");
// Make the request
Operation<Empty, OperationMetadata> response = attachedClustersClient.DeleteAttachedCluster(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 = attachedClustersClient.PollOnceDeleteAttachedCluster(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
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
DeleteAttachedClusterRequest request = new DeleteAttachedClusterRequest
{
    AttachedClusterName = AttachedClusterName.FromProjectLocationAttachedCluster("[PROJECT]", "[LOCATION]", "[ATTACHED_CLUSTER]"),
    ValidateOnly = false,
    AllowMissing = false,
    Etag = "",
    IgnoreErrors = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = attachedClustersClient.DeleteAttachedCluster(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 = attachedClustersClient.PollOnceDeleteAttachedCluster(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
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/attachedClusters/[ATTACHED_CLUSTER]";
// Make the request
Operation<Empty, OperationMetadata> response = attachedClustersClient.DeleteAttachedCluster(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 = attachedClustersClient.PollOnceDeleteAttachedCluster(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
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
AttachedClusterName name = AttachedClusterName.FromProjectLocationAttachedCluster("[PROJECT]", "[LOCATION]", "[ATTACHED_CLUSTER]");
// Make the request
Operation<Empty, OperationMetadata> response = await attachedClustersClient.DeleteAttachedClusterAsync(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 attachedClustersClient.PollOnceDeleteAttachedClusterAsync(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
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
AttachedClusterName name = AttachedClusterName.FromProjectLocationAttachedCluster("[PROJECT]", "[LOCATION]", "[ATTACHED_CLUSTER]");
// Make the request
Operation<Empty, OperationMetadata> response = await attachedClustersClient.DeleteAttachedClusterAsync(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 attachedClustersClient.PollOnceDeleteAttachedClusterAsync(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
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
DeleteAttachedClusterRequest request = new DeleteAttachedClusterRequest
{
    AttachedClusterName = AttachedClusterName.FromProjectLocationAttachedCluster("[PROJECT]", "[LOCATION]", "[ATTACHED_CLUSTER]"),
    ValidateOnly = false,
    AllowMissing = false,
    Etag = "",
    IgnoreErrors = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await attachedClustersClient.DeleteAttachedClusterAsync(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 attachedClustersClient.PollOnceDeleteAttachedClusterAsync(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
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
DeleteAttachedClusterRequest request = new DeleteAttachedClusterRequest
{
    AttachedClusterName = AttachedClusterName.FromProjectLocationAttachedCluster("[PROJECT]", "[LOCATION]", "[ATTACHED_CLUSTER]"),
    ValidateOnly = false,
    AllowMissing = false,
    Etag = "",
    IgnoreErrors = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await attachedClustersClient.DeleteAttachedClusterAsync(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 attachedClustersClient.PollOnceDeleteAttachedClusterAsync(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
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/attachedClusters/[ATTACHED_CLUSTER]";
// Make the request
Operation<Empty, OperationMetadata> response = await attachedClustersClient.DeleteAttachedClusterAsync(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 attachedClustersClient.PollOnceDeleteAttachedClusterAsync(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
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/attachedClusters/[ATTACHED_CLUSTER]";
// Make the request
Operation<Empty, OperationMetadata> response = await attachedClustersClient.DeleteAttachedClusterAsync(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 attachedClustersClient.PollOnceDeleteAttachedClusterAsync(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
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
GenerateAttachedClusterAgentTokenRequest request = new GenerateAttachedClusterAgentTokenRequest
{
    AttachedClusterAsAttachedClusterName = AttachedClusterName.FromProjectLocationAttachedCluster("[PROJECT]", "[LOCATION]", "[ATTACHED_CLUSTER]"),
    SubjectToken = "",
    SubjectTokenType = "",
    Version = "",
    GrantType = "",
    Audience = "",
    Scope = "",
    RequestedTokenType = "",
    Options = "",
};
// Make the request
GenerateAttachedClusterAgentTokenResponse response = attachedClustersClient.GenerateAttachedClusterAgentToken(request);

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
GenerateAttachedClusterAgentTokenRequest request = new GenerateAttachedClusterAgentTokenRequest
{
    AttachedClusterAsAttachedClusterName = AttachedClusterName.FromProjectLocationAttachedCluster("[PROJECT]", "[LOCATION]", "[ATTACHED_CLUSTER]"),
    SubjectToken = "",
    SubjectTokenType = "",
    Version = "",
    GrantType = "",
    Audience = "",
    Scope = "",
    RequestedTokenType = "",
    Options = "",
};
// Make the request
GenerateAttachedClusterAgentTokenResponse response = await attachedClustersClient.GenerateAttachedClusterAgentTokenAsync(request);

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
GenerateAttachedClusterAgentTokenRequest request = new GenerateAttachedClusterAgentTokenRequest
{
    AttachedClusterAsAttachedClusterName = AttachedClusterName.FromProjectLocationAttachedCluster("[PROJECT]", "[LOCATION]", "[ATTACHED_CLUSTER]"),
    SubjectToken = "",
    SubjectTokenType = "",
    Version = "",
    GrantType = "",
    Audience = "",
    Scope = "",
    RequestedTokenType = "",
    Options = "",
};
// Make the request
GenerateAttachedClusterAgentTokenResponse response = await attachedClustersClient.GenerateAttachedClusterAgentTokenAsync(request);

// Create client
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
string attachedClusterId = "";
// Make the request
GenerateAttachedClusterInstallManifestResponse response = attachedClustersClient.GenerateAttachedClusterInstallManifest(parent, attachedClusterId);

// Create client
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
GenerateAttachedClusterInstallManifestRequest request = new GenerateAttachedClusterInstallManifestRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AttachedClusterId = "",
    PlatformVersion = "",
    ProxyConfig = new AttachedProxyConfig(),
};
// Make the request
GenerateAttachedClusterInstallManifestResponse response = attachedClustersClient.GenerateAttachedClusterInstallManifest(request);

// Create client
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
string attachedClusterId = "";
// Make the request
GenerateAttachedClusterInstallManifestResponse response = attachedClustersClient.GenerateAttachedClusterInstallManifest(parent, attachedClusterId);

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
string attachedClusterId = "";
// Make the request
GenerateAttachedClusterInstallManifestResponse response = await attachedClustersClient.GenerateAttachedClusterInstallManifestAsync(parent, attachedClusterId);

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
string attachedClusterId = "";
// Make the request
GenerateAttachedClusterInstallManifestResponse response = await attachedClustersClient.GenerateAttachedClusterInstallManifestAsync(parent, attachedClusterId);

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
GenerateAttachedClusterInstallManifestRequest request = new GenerateAttachedClusterInstallManifestRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AttachedClusterId = "",
    PlatformVersion = "",
    ProxyConfig = new AttachedProxyConfig(),
};
// Make the request
GenerateAttachedClusterInstallManifestResponse response = await attachedClustersClient.GenerateAttachedClusterInstallManifestAsync(request);

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
GenerateAttachedClusterInstallManifestRequest request = new GenerateAttachedClusterInstallManifestRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AttachedClusterId = "",
    PlatformVersion = "",
    ProxyConfig = new AttachedProxyConfig(),
};
// Make the request
GenerateAttachedClusterInstallManifestResponse response = await attachedClustersClient.GenerateAttachedClusterInstallManifestAsync(request);

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
string attachedClusterId = "";
// Make the request
GenerateAttachedClusterInstallManifestResponse response = await attachedClustersClient.GenerateAttachedClusterInstallManifestAsync(parent, attachedClusterId);

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
string attachedClusterId = "";
// Make the request
GenerateAttachedClusterInstallManifestResponse response = await attachedClustersClient.GenerateAttachedClusterInstallManifestAsync(parent, attachedClusterId);

// Create client
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
AttachedClusterName name = AttachedClusterName.FromProjectLocationAttachedCluster("[PROJECT]", "[LOCATION]", "[ATTACHED_CLUSTER]");
// Make the request
AttachedCluster response = attachedClustersClient.GetAttachedCluster(name);

// Create client
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
GetAttachedClusterRequest request = new GetAttachedClusterRequest
{
    AttachedClusterName = AttachedClusterName.FromProjectLocationAttachedCluster("[PROJECT]", "[LOCATION]", "[ATTACHED_CLUSTER]"),
};
// Make the request
AttachedCluster response = attachedClustersClient.GetAttachedCluster(request);

// Create client
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/attachedClusters/[ATTACHED_CLUSTER]";
// Make the request
AttachedCluster response = attachedClustersClient.GetAttachedCluster(name);

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
AttachedClusterName name = AttachedClusterName.FromProjectLocationAttachedCluster("[PROJECT]", "[LOCATION]", "[ATTACHED_CLUSTER]");
// Make the request
AttachedCluster response = await attachedClustersClient.GetAttachedClusterAsync(name);

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
AttachedClusterName name = AttachedClusterName.FromProjectLocationAttachedCluster("[PROJECT]", "[LOCATION]", "[ATTACHED_CLUSTER]");
// Make the request
AttachedCluster response = await attachedClustersClient.GetAttachedClusterAsync(name);

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
GetAttachedClusterRequest request = new GetAttachedClusterRequest
{
    AttachedClusterName = AttachedClusterName.FromProjectLocationAttachedCluster("[PROJECT]", "[LOCATION]", "[ATTACHED_CLUSTER]"),
};
// Make the request
AttachedCluster response = await attachedClustersClient.GetAttachedClusterAsync(request);

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
GetAttachedClusterRequest request = new GetAttachedClusterRequest
{
    AttachedClusterName = AttachedClusterName.FromProjectLocationAttachedCluster("[PROJECT]", "[LOCATION]", "[ATTACHED_CLUSTER]"),
};
// Make the request
AttachedCluster response = await attachedClustersClient.GetAttachedClusterAsync(request);

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/attachedClusters/[ATTACHED_CLUSTER]";
// Make the request
AttachedCluster response = await attachedClustersClient.GetAttachedClusterAsync(name);

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/attachedClusters/[ATTACHED_CLUSTER]";
// Make the request
AttachedCluster response = await attachedClustersClient.GetAttachedClusterAsync(name);

// Create client
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
AttachedServerConfigName name = AttachedServerConfigName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
AttachedServerConfig response = attachedClustersClient.GetAttachedServerConfig(name);

// Create client
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
GetAttachedServerConfigRequest request = new GetAttachedServerConfigRequest
{
    AttachedServerConfigName = AttachedServerConfigName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
AttachedServerConfig response = attachedClustersClient.GetAttachedServerConfig(request);

// Create client
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/attachedServerConfig";
// Make the request
AttachedServerConfig response = attachedClustersClient.GetAttachedServerConfig(name);

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
AttachedServerConfigName name = AttachedServerConfigName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
AttachedServerConfig response = await attachedClustersClient.GetAttachedServerConfigAsync(name);

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
AttachedServerConfigName name = AttachedServerConfigName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
AttachedServerConfig response = await attachedClustersClient.GetAttachedServerConfigAsync(name);

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
GetAttachedServerConfigRequest request = new GetAttachedServerConfigRequest
{
    AttachedServerConfigName = AttachedServerConfigName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
AttachedServerConfig response = await attachedClustersClient.GetAttachedServerConfigAsync(request);

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
GetAttachedServerConfigRequest request = new GetAttachedServerConfigRequest
{
    AttachedServerConfigName = AttachedServerConfigName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
AttachedServerConfig response = await attachedClustersClient.GetAttachedServerConfigAsync(request);

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/attachedServerConfig";
// Make the request
AttachedServerConfig response = await attachedClustersClient.GetAttachedServerConfigAsync(name);

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/attachedServerConfig";
// Make the request
AttachedServerConfig response = await attachedClustersClient.GetAttachedServerConfigAsync(name);

// Create client
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
string fleetMembership = "";
// Make the request
Operation<AttachedCluster, OperationMetadata> response = attachedClustersClient.ImportAttachedCluster(parent, fleetMembership);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = attachedClustersClient.PollOnceImportAttachedCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
ImportAttachedClusterRequest request = new ImportAttachedClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ValidateOnly = false,
    FleetMembership = "",
    PlatformVersion = "",
    Distribution = "",
    ProxyConfig = new AttachedProxyConfig(),
};
// Make the request
Operation<AttachedCluster, OperationMetadata> response = attachedClustersClient.ImportAttachedCluster(request);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = attachedClustersClient.PollOnceImportAttachedCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
string fleetMembership = "";
// Make the request
Operation<AttachedCluster, OperationMetadata> response = attachedClustersClient.ImportAttachedCluster(parent, fleetMembership);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = attachedClustersClient.PollOnceImportAttachedCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
string fleetMembership = "";
// Make the request
Operation<AttachedCluster, OperationMetadata> response = await attachedClustersClient.ImportAttachedClusterAsync(parent, fleetMembership);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = await attachedClustersClient.PollOnceImportAttachedClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
string fleetMembership = "";
// Make the request
Operation<AttachedCluster, OperationMetadata> response = await attachedClustersClient.ImportAttachedClusterAsync(parent, fleetMembership);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = await attachedClustersClient.PollOnceImportAttachedClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
ImportAttachedClusterRequest request = new ImportAttachedClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ValidateOnly = false,
    FleetMembership = "",
    PlatformVersion = "",
    Distribution = "",
    ProxyConfig = new AttachedProxyConfig(),
};
// Make the request
Operation<AttachedCluster, OperationMetadata> response = await attachedClustersClient.ImportAttachedClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = await attachedClustersClient.PollOnceImportAttachedClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
ImportAttachedClusterRequest request = new ImportAttachedClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ValidateOnly = false,
    FleetMembership = "",
    PlatformVersion = "",
    Distribution = "",
    ProxyConfig = new AttachedProxyConfig(),
};
// Make the request
Operation<AttachedCluster, OperationMetadata> response = await attachedClustersClient.ImportAttachedClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = await attachedClustersClient.PollOnceImportAttachedClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
string fleetMembership = "";
// Make the request
Operation<AttachedCluster, OperationMetadata> response = await attachedClustersClient.ImportAttachedClusterAsync(parent, fleetMembership);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = await attachedClustersClient.PollOnceImportAttachedClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
string fleetMembership = "";
// Make the request
Operation<AttachedCluster, OperationMetadata> response = await attachedClustersClient.ImportAttachedClusterAsync(parent, fleetMembership);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = await attachedClustersClient.PollOnceImportAttachedClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListAttachedClustersResponse, AttachedCluster> response = attachedClustersClient.ListAttachedClusters(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (AttachedCluster 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 (ListAttachedClustersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AttachedCluster 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<AttachedCluster> 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 (AttachedCluster 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
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
ListAttachedClustersRequest request = new ListAttachedClustersRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedEnumerable<ListAttachedClustersResponse, AttachedCluster> response = attachedClustersClient.ListAttachedClusters(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (AttachedCluster 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 (ListAttachedClustersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AttachedCluster 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<AttachedCluster> 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 (AttachedCluster 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
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListAttachedClustersResponse, AttachedCluster> response = attachedClustersClient.ListAttachedClusters(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (AttachedCluster 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 (ListAttachedClustersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AttachedCluster 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<AttachedCluster> 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 (AttachedCluster 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
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListAttachedClustersResponse, AttachedCluster> response = attachedClustersClient.ListAttachedClustersAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AttachedCluster 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((ListAttachedClustersResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AttachedCluster 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<AttachedCluster> 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 (AttachedCluster 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
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
ListAttachedClustersRequest request = new ListAttachedClustersRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedAsyncEnumerable<ListAttachedClustersResponse, AttachedCluster> response = attachedClustersClient.ListAttachedClustersAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AttachedCluster 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((ListAttachedClustersResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AttachedCluster 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<AttachedCluster> 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 (AttachedCluster 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
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListAttachedClustersResponse, AttachedCluster> response = attachedClustersClient.ListAttachedClustersAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AttachedCluster 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((ListAttachedClustersResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AttachedCluster 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<AttachedCluster> 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 (AttachedCluster 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
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
AttachedCluster attachedCluster = new AttachedCluster();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<AttachedCluster, OperationMetadata> response = attachedClustersClient.UpdateAttachedCluster(attachedCluster, updateMask);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = attachedClustersClient.PollOnceUpdateAttachedCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = AttachedClustersClient.Create();
// Initialize request argument(s)
UpdateAttachedClusterRequest request = new UpdateAttachedClusterRequest
{
    AttachedCluster = new AttachedCluster(),
    ValidateOnly = false,
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<AttachedCluster, OperationMetadata> response = attachedClustersClient.UpdateAttachedCluster(request);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = attachedClustersClient.PollOnceUpdateAttachedCluster(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
AttachedCluster attachedCluster = new AttachedCluster();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<AttachedCluster, OperationMetadata> response = await attachedClustersClient.UpdateAttachedClusterAsync(attachedCluster, updateMask);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = await attachedClustersClient.PollOnceUpdateAttachedClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
AttachedCluster attachedCluster = new AttachedCluster();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<AttachedCluster, OperationMetadata> response = await attachedClustersClient.UpdateAttachedClusterAsync(attachedCluster, updateMask);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = await attachedClustersClient.PollOnceUpdateAttachedClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
UpdateAttachedClusterRequest request = new UpdateAttachedClusterRequest
{
    AttachedCluster = new AttachedCluster(),
    ValidateOnly = false,
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<AttachedCluster, OperationMetadata> response = await attachedClustersClient.UpdateAttachedClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = await attachedClustersClient.PollOnceUpdateAttachedClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}

// Create client
AttachedClustersClient attachedClustersClient = await AttachedClustersClient.CreateAsync();
// Initialize request argument(s)
UpdateAttachedClusterRequest request = new UpdateAttachedClusterRequest
{
    AttachedCluster = new AttachedCluster(),
    ValidateOnly = false,
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<AttachedCluster, OperationMetadata> response = await attachedClustersClient.UpdateAttachedClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<AttachedCluster, OperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
AttachedCluster 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<AttachedCluster, OperationMetadata> retrievedResponse = await attachedClustersClient.PollOnceUpdateAttachedClusterAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    AttachedCluster retrievedResult = retrievedResponse.Result;
}