Google Cloud Memorystore for Redis (cluster management) v1 API - Class CloudRedisClusterClient (1.10.0)

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
AddAuthTokenRequest request = new AddAuthTokenRequest
{
    TokenAuthUserAsTokenAuthUserName = TokenAuthUserName.FromProjectLocationClusterTokenAuthUser("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]"),
    AuthToken = new AuthToken(),
};
// Make the request
Operation<TokenAuthUser, OperationMetadata> response = cloudRedisClusterClient.AddAuthToken(request);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
TokenAuthUserName tokenAuthUser = TokenAuthUserName.FromProjectLocationClusterTokenAuthUser("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]");
AuthToken authToken = new AuthToken();
// Make the request
Operation<TokenAuthUser, OperationMetadata> response = cloudRedisClusterClient.AddAuthToken(tokenAuthUser, authToken);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
string tokenAuthUser = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]/tokenAuthUsers/[TOKEN_AUTH_USER]";
AuthToken authToken = new AuthToken();
// Make the request
Operation<TokenAuthUser, OperationMetadata> response = cloudRedisClusterClient.AddAuthToken(tokenAuthUser, authToken);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
AddAuthTokenRequest request = new AddAuthTokenRequest
{
    TokenAuthUserAsTokenAuthUserName = TokenAuthUserName.FromProjectLocationClusterTokenAuthUser("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]"),
    AuthToken = new AuthToken(),
};
// Make the request
Operation<TokenAuthUser, OperationMetadata> response = await cloudRedisClusterClient.AddAuthTokenAsync(request);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
AddAuthTokenRequest request = new AddAuthTokenRequest
{
    TokenAuthUserAsTokenAuthUserName = TokenAuthUserName.FromProjectLocationClusterTokenAuthUser("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]"),
    AuthToken = new AuthToken(),
};
// Make the request
Operation<TokenAuthUser, OperationMetadata> response = await cloudRedisClusterClient.AddAuthTokenAsync(request);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
TokenAuthUserName tokenAuthUser = TokenAuthUserName.FromProjectLocationClusterTokenAuthUser("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]");
AuthToken authToken = new AuthToken();
// Make the request
Operation<TokenAuthUser, OperationMetadata> response = await cloudRedisClusterClient.AddAuthTokenAsync(tokenAuthUser, authToken);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
TokenAuthUserName tokenAuthUser = TokenAuthUserName.FromProjectLocationClusterTokenAuthUser("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]");
AuthToken authToken = new AuthToken();
// Make the request
Operation<TokenAuthUser, OperationMetadata> response = await cloudRedisClusterClient.AddAuthTokenAsync(tokenAuthUser, authToken);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string tokenAuthUser = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]/tokenAuthUsers/[TOKEN_AUTH_USER]";
AuthToken authToken = new AuthToken();
// Make the request
Operation<TokenAuthUser, OperationMetadata> response = await cloudRedisClusterClient.AddAuthTokenAsync(tokenAuthUser, authToken);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string tokenAuthUser = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]/tokenAuthUsers/[TOKEN_AUTH_USER]";
AuthToken authToken = new AuthToken();
// Make the request
Operation<TokenAuthUser, OperationMetadata> response = await cloudRedisClusterClient.AddAuthTokenAsync(tokenAuthUser, authToken);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
AddTokenAuthUserRequest request = new AddTokenAuthUserRequest
{
    ClusterAsClusterName = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]"),
    TokenAuthUserAsTokenAuthUserName = TokenAuthUserName.FromProjectLocationClusterTokenAuthUser("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]"),
};
// Make the request
Operation<Cluster, OperationMetadata> response = cloudRedisClusterClient.AddTokenAuthUser(request);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
ClusterName cluster = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]");
TokenAuthUserName tokenAuthUser = TokenAuthUserName.FromProjectLocationClusterTokenAuthUser("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]");
// Make the request
Operation<Cluster, OperationMetadata> response = cloudRedisClusterClient.AddTokenAuthUser(cluster, tokenAuthUser);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
string cluster = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]";
string tokenAuthUser = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]/tokenAuthUsers/[TOKEN_AUTH_USER]";
// Make the request
Operation<Cluster, OperationMetadata> response = cloudRedisClusterClient.AddTokenAuthUser(cluster, tokenAuthUser);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
AddTokenAuthUserRequest request = new AddTokenAuthUserRequest
{
    ClusterAsClusterName = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]"),
    TokenAuthUserAsTokenAuthUserName = TokenAuthUserName.FromProjectLocationClusterTokenAuthUser("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]"),
};
// Make the request
Operation<Cluster, OperationMetadata> response = await cloudRedisClusterClient.AddTokenAuthUserAsync(request);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
AddTokenAuthUserRequest request = new AddTokenAuthUserRequest
{
    ClusterAsClusterName = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]"),
    TokenAuthUserAsTokenAuthUserName = TokenAuthUserName.FromProjectLocationClusterTokenAuthUser("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]"),
};
// Make the request
Operation<Cluster, OperationMetadata> response = await cloudRedisClusterClient.AddTokenAuthUserAsync(request);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
ClusterName cluster = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]");
TokenAuthUserName tokenAuthUser = TokenAuthUserName.FromProjectLocationClusterTokenAuthUser("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]");
// Make the request
Operation<Cluster, OperationMetadata> response = await cloudRedisClusterClient.AddTokenAuthUserAsync(cluster, tokenAuthUser);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
ClusterName cluster = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]");
TokenAuthUserName tokenAuthUser = TokenAuthUserName.FromProjectLocationClusterTokenAuthUser("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]");
// Make the request
Operation<Cluster, OperationMetadata> response = await cloudRedisClusterClient.AddTokenAuthUserAsync(cluster, tokenAuthUser);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string cluster = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]";
string tokenAuthUser = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]/tokenAuthUsers/[TOKEN_AUTH_USER]";
// Make the request
Operation<Cluster, OperationMetadata> response = await cloudRedisClusterClient.AddTokenAuthUserAsync(cluster, tokenAuthUser);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string cluster = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]";
string tokenAuthUser = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]/tokenAuthUsers/[TOKEN_AUTH_USER]";
// Make the request
Operation<Cluster, OperationMetadata> response = await cloudRedisClusterClient.AddTokenAuthUserAsync(cluster, tokenAuthUser);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
BackupClusterRequest request = new BackupClusterRequest
{
    ClusterName = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]"),
    Ttl = new Duration(),
    BackupId = "",
};
// Make the request
Operation<Cluster, Any> response = cloudRedisClusterClient.BackupCluster(request);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
ClusterName name = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]");
// Make the request
Operation<Cluster, Any> response = cloudRedisClusterClient.BackupCluster(name);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]";
// Make the request
Operation<Cluster, Any> response = cloudRedisClusterClient.BackupCluster(name);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
BackupClusterRequest request = new BackupClusterRequest
{
    ClusterName = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]"),
    Ttl = new Duration(),
    BackupId = "",
};
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.BackupClusterAsync(request);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
BackupClusterRequest request = new BackupClusterRequest
{
    ClusterName = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]"),
    Ttl = new Duration(),
    BackupId = "",
};
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.BackupClusterAsync(request);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
ClusterName name = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]");
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.BackupClusterAsync(name);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
ClusterName name = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]");
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.BackupClusterAsync(name);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]";
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.BackupClusterAsync(name);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]";
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.BackupClusterAsync(name);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
AclPolicy aclPolicy = new AclPolicy();
string aclPolicyId = "";
// Make the request
AclPolicy response = cloudRedisClusterClient.CreateAclPolicy(parent, aclPolicy, aclPolicyId);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
CreateAclPolicyRequest request = new CreateAclPolicyRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AclPolicyId = "",
    AclPolicy = new AclPolicy(),
    RequestId = "",
};
// Make the request
AclPolicy response = cloudRedisClusterClient.CreateAclPolicy(request);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
AclPolicy aclPolicy = new AclPolicy();
string aclPolicyId = "";
// Make the request
AclPolicy response = cloudRedisClusterClient.CreateAclPolicy(parent, aclPolicy, aclPolicyId);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
AclPolicy aclPolicy = new AclPolicy();
string aclPolicyId = "";
// Make the request
AclPolicy response = await cloudRedisClusterClient.CreateAclPolicyAsync(parent, aclPolicy, aclPolicyId);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
AclPolicy aclPolicy = new AclPolicy();
string aclPolicyId = "";
// Make the request
AclPolicy response = await cloudRedisClusterClient.CreateAclPolicyAsync(parent, aclPolicy, aclPolicyId);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
CreateAclPolicyRequest request = new CreateAclPolicyRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AclPolicyId = "",
    AclPolicy = new AclPolicy(),
    RequestId = "",
};
// Make the request
AclPolicy response = await cloudRedisClusterClient.CreateAclPolicyAsync(request);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
CreateAclPolicyRequest request = new CreateAclPolicyRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    AclPolicyId = "",
    AclPolicy = new AclPolicy(),
    RequestId = "",
};
// Make the request
AclPolicy response = await cloudRedisClusterClient.CreateAclPolicyAsync(request);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
AclPolicy aclPolicy = new AclPolicy();
string aclPolicyId = "";
// Make the request
AclPolicy response = await cloudRedisClusterClient.CreateAclPolicyAsync(parent, aclPolicy, aclPolicyId);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
AclPolicy aclPolicy = new AclPolicy();
string aclPolicyId = "";
// Make the request
AclPolicy response = await cloudRedisClusterClient.CreateAclPolicyAsync(parent, aclPolicy, aclPolicyId);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Cluster cluster = new Cluster();
string clusterId = "";
// Make the request
Operation<Cluster, Any> response = cloudRedisClusterClient.CreateCluster(parent, cluster, clusterId);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
CreateClusterRequest request = new CreateClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ClusterId = "",
    Cluster = new Cluster(),
    RequestId = "",
};
// Make the request
Operation<Cluster, Any> response = cloudRedisClusterClient.CreateCluster(request);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Cluster cluster = new Cluster();
string clusterId = "";
// Make the request
Operation<Cluster, Any> response = cloudRedisClusterClient.CreateCluster(parent, cluster, clusterId);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Cluster cluster = new Cluster();
string clusterId = "";
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.CreateClusterAsync(parent, cluster, clusterId);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Cluster cluster = new Cluster();
string clusterId = "";
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.CreateClusterAsync(parent, cluster, clusterId);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
CreateClusterRequest request = new CreateClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ClusterId = "",
    Cluster = new Cluster(),
    RequestId = "",
};
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.CreateClusterAsync(request);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
CreateClusterRequest request = new CreateClusterRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ClusterId = "",
    Cluster = new Cluster(),
    RequestId = "",
};
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.CreateClusterAsync(request);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Cluster cluster = new Cluster();
string clusterId = "";
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.CreateClusterAsync(parent, cluster, clusterId);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Cluster cluster = new Cluster();
string clusterId = "";
// Make the request
Operation<Cluster, Any> response = await cloudRedisClusterClient.CreateClusterAsync(parent, cluster, clusterId);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
AclPolicyName name = AclPolicyName.FromProjectLocationAclPolicy("[PROJECT]", "[LOCATION]", "[ACL_POLICY]");
// Make the request
Operation<Empty, OperationMetadata> response = cloudRedisClusterClient.DeleteAclPolicy(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 = cloudRedisClusterClient.PollOnceDeleteAclPolicy(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
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
DeleteAclPolicyRequest request = new DeleteAclPolicyRequest
{
    AclPolicyName = AclPolicyName.FromProjectLocationAclPolicy("[PROJECT]", "[LOCATION]", "[ACL_POLICY]"),
    RequestId = "",
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = cloudRedisClusterClient.DeleteAclPolicy(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 = cloudRedisClusterClient.PollOnceDeleteAclPolicy(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
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/aclPolicies/[ACL_POLICY]";
// Make the request
Operation<Empty, OperationMetadata> response = cloudRedisClusterClient.DeleteAclPolicy(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 = cloudRedisClusterClient.PollOnceDeleteAclPolicy(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
AclPolicyName name = AclPolicyName.FromProjectLocationAclPolicy("[PROJECT]", "[LOCATION]", "[ACL_POLICY]");
// Make the request
Operation<Empty, OperationMetadata> response = await cloudRedisClusterClient.DeleteAclPolicyAsync(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 cloudRedisClusterClient.PollOnceDeleteAclPolicyAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
AclPolicyName name = AclPolicyName.FromProjectLocationAclPolicy("[PROJECT]", "[LOCATION]", "[ACL_POLICY]");
// Make the request
Operation<Empty, OperationMetadata> response = await cloudRedisClusterClient.DeleteAclPolicyAsync(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 cloudRedisClusterClient.PollOnceDeleteAclPolicyAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
DeleteAclPolicyRequest request = new DeleteAclPolicyRequest
{
    AclPolicyName = AclPolicyName.FromProjectLocationAclPolicy("[PROJECT]", "[LOCATION]", "[ACL_POLICY]"),
    RequestId = "",
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await cloudRedisClusterClient.DeleteAclPolicyAsync(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 cloudRedisClusterClient.PollOnceDeleteAclPolicyAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
DeleteAclPolicyRequest request = new DeleteAclPolicyRequest
{
    AclPolicyName = AclPolicyName.FromProjectLocationAclPolicy("[PROJECT]", "[LOCATION]", "[ACL_POLICY]"),
    RequestId = "",
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await cloudRedisClusterClient.DeleteAclPolicyAsync(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 cloudRedisClusterClient.PollOnceDeleteAclPolicyAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/aclPolicies/[ACL_POLICY]";
// Make the request
Operation<Empty, OperationMetadata> response = await cloudRedisClusterClient.DeleteAclPolicyAsync(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 cloudRedisClusterClient.PollOnceDeleteAclPolicyAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/aclPolicies/[ACL_POLICY]";
// Make the request
Operation<Empty, OperationMetadata> response = await cloudRedisClusterClient.DeleteAclPolicyAsync(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 cloudRedisClusterClient.PollOnceDeleteAclPolicyAsync(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
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
AuthTokenName name = AuthTokenName.FromProjectLocationClusterTokenAuthUserAuthToken("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]", "[AUTH_TOKEN]");
// Make the request
Operation<Empty, OperationMetadata> response = cloudRedisClusterClient.DeleteAuthToken(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 = cloudRedisClusterClient.PollOnceDeleteAuthToken(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
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
DeleteAuthTokenRequest request = new DeleteAuthTokenRequest
{
    AuthTokenName = AuthTokenName.FromProjectLocationClusterTokenAuthUserAuthToken("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]", "[AUTH_TOKEN]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = cloudRedisClusterClient.DeleteAuthToken(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 = cloudRedisClusterClient.PollOnceDeleteAuthToken(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
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]/tokenAuthUsers/[TOKEN_AUTH_USER]/authTokens/[AUTH_TOKEN]";
// Make the request
Operation<Empty, OperationMetadata> response = cloudRedisClusterClient.DeleteAuthToken(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 = cloudRedisClusterClient.PollOnceDeleteAuthToken(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
AuthTokenName name = AuthTokenName.FromProjectLocationClusterTokenAuthUserAuthToken("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]", "[AUTH_TOKEN]");
// Make the request
Operation<Empty, OperationMetadata> response = await cloudRedisClusterClient.DeleteAuthTokenAsync(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 cloudRedisClusterClient.PollOnceDeleteAuthTokenAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
AuthTokenName name = AuthTokenName.FromProjectLocationClusterTokenAuthUserAuthToken("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]", "[AUTH_TOKEN]");
// Make the request
Operation<Empty, OperationMetadata> response = await cloudRedisClusterClient.DeleteAuthTokenAsync(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 cloudRedisClusterClient.PollOnceDeleteAuthTokenAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
DeleteAuthTokenRequest request = new DeleteAuthTokenRequest
{
    AuthTokenName = AuthTokenName.FromProjectLocationClusterTokenAuthUserAuthToken("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]", "[AUTH_TOKEN]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await cloudRedisClusterClient.DeleteAuthTokenAsync(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 cloudRedisClusterClient.PollOnceDeleteAuthTokenAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
DeleteAuthTokenRequest request = new DeleteAuthTokenRequest
{
    AuthTokenName = AuthTokenName.FromProjectLocationClusterTokenAuthUserAuthToken("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]", "[AUTH_TOKEN]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await cloudRedisClusterClient.DeleteAuthTokenAsync(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 cloudRedisClusterClient.PollOnceDeleteAuthTokenAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]/tokenAuthUsers/[TOKEN_AUTH_USER]/authTokens/[AUTH_TOKEN]";
// Make the request
Operation<Empty, OperationMetadata> response = await cloudRedisClusterClient.DeleteAuthTokenAsync(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 cloudRedisClusterClient.PollOnceDeleteAuthTokenAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]/tokenAuthUsers/[TOKEN_AUTH_USER]/authTokens/[AUTH_TOKEN]";
// Make the request
Operation<Empty, OperationMetadata> response = await cloudRedisClusterClient.DeleteAuthTokenAsync(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 cloudRedisClusterClient.PollOnceDeleteAuthTokenAsync(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
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
BackupName name = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]");
// Make the request
Operation<Empty, Any> response = cloudRedisClusterClient.DeleteBackup(name);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> 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, Any> retrievedResponse = cloudRedisClusterClient.PollOnceDeleteBackup(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
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
DeleteBackupRequest request = new DeleteBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]"),
    RequestId = "",
};
// Make the request
Operation<Empty, Any> response = cloudRedisClusterClient.DeleteBackup(request);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> 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, Any> retrievedResponse = cloudRedisClusterClient.PollOnceDeleteBackup(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
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupCollections/[BACKUP_COLLECTION]/backups/[BACKUP]";
// Make the request
Operation<Empty, Any> response = cloudRedisClusterClient.DeleteBackup(name);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> 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, Any> retrievedResponse = cloudRedisClusterClient.PollOnceDeleteBackup(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
BackupName name = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]");
// Make the request
Operation<Empty, Any> response = await cloudRedisClusterClient.DeleteBackupAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> 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, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceDeleteBackupAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
BackupName name = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]");
// Make the request
Operation<Empty, Any> response = await cloudRedisClusterClient.DeleteBackupAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> 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, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceDeleteBackupAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
DeleteBackupRequest request = new DeleteBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]"),
    RequestId = "",
};
// Make the request
Operation<Empty, Any> response = await cloudRedisClusterClient.DeleteBackupAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> 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, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceDeleteBackupAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
DeleteBackupRequest request = new DeleteBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]"),
    RequestId = "",
};
// Make the request
Operation<Empty, Any> response = await cloudRedisClusterClient.DeleteBackupAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> 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, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceDeleteBackupAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupCollections/[BACKUP_COLLECTION]/backups/[BACKUP]";
// Make the request
Operation<Empty, Any> response = await cloudRedisClusterClient.DeleteBackupAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> 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, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceDeleteBackupAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupCollections/[BACKUP_COLLECTION]/backups/[BACKUP]";
// Make the request
Operation<Empty, Any> response = await cloudRedisClusterClient.DeleteBackupAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> 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, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceDeleteBackupAsync(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
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
ClusterName name = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]");
// Make the request
Operation<Empty, Any> response = cloudRedisClusterClient.DeleteCluster(name);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> 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, Any> retrievedResponse = cloudRedisClusterClient.PollOnceDeleteCluster(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
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
DeleteClusterRequest request = new DeleteClusterRequest
{
    ClusterName = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]"),
    RequestId = "",
};
// Make the request
Operation<Empty, Any> response = cloudRedisClusterClient.DeleteCluster(request);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> 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, Any> retrievedResponse = cloudRedisClusterClient.PollOnceDeleteCluster(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
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]";
// Make the request
Operation<Empty, Any> response = cloudRedisClusterClient.DeleteCluster(name);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> 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, Any> retrievedResponse = cloudRedisClusterClient.PollOnceDeleteCluster(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
ClusterName name = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]");
// Make the request
Operation<Empty, Any> response = await cloudRedisClusterClient.DeleteClusterAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> 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, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceDeleteClusterAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
ClusterName name = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]");
// Make the request
Operation<Empty, Any> response = await cloudRedisClusterClient.DeleteClusterAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> 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, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceDeleteClusterAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
DeleteClusterRequest request = new DeleteClusterRequest
{
    ClusterName = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]"),
    RequestId = "",
};
// Make the request
Operation<Empty, Any> response = await cloudRedisClusterClient.DeleteClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> 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, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceDeleteClusterAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
DeleteClusterRequest request = new DeleteClusterRequest
{
    ClusterName = ClusterName.FromProjectLocationCluster("[PROJECT]", "[LOCATION]", "[CLUSTER]"),
    RequestId = "",
};
// Make the request
Operation<Empty, Any> response = await cloudRedisClusterClient.DeleteClusterAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> 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, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceDeleteClusterAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]";
// Make the request
Operation<Empty, Any> response = await cloudRedisClusterClient.DeleteClusterAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> 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, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceDeleteClusterAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]";
// Make the request
Operation<Empty, Any> response = await cloudRedisClusterClient.DeleteClusterAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, Any> 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, Any> retrievedResponse = await cloudRedisClusterClient.PollOnceDeleteClusterAsync(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
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
DeleteTokenAuthUserRequest request = new DeleteTokenAuthUserRequest
{
    TokenAuthUserName = TokenAuthUserName.FromProjectLocationClusterTokenAuthUser("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = cloudRedisClusterClient.DeleteTokenAuthUser(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 = cloudRedisClusterClient.PollOnceDeleteTokenAuthUser(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
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
TokenAuthUserName name = TokenAuthUserName.FromProjectLocationClusterTokenAuthUser("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]");
// Make the request
Operation<Empty, OperationMetadata> response = cloudRedisClusterClient.DeleteTokenAuthUser(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 = cloudRedisClusterClient.PollOnceDeleteTokenAuthUser(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
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]/tokenAuthUsers/[TOKEN_AUTH_USER]";
// Make the request
Operation<Empty, OperationMetadata> response = cloudRedisClusterClient.DeleteTokenAuthUser(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 = cloudRedisClusterClient.PollOnceDeleteTokenAuthUser(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
DeleteTokenAuthUserRequest request = new DeleteTokenAuthUserRequest
{
    TokenAuthUserName = TokenAuthUserName.FromProjectLocationClusterTokenAuthUser("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await cloudRedisClusterClient.DeleteTokenAuthUserAsync(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 cloudRedisClusterClient.PollOnceDeleteTokenAuthUserAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
DeleteTokenAuthUserRequest request = new DeleteTokenAuthUserRequest
{
    TokenAuthUserName = TokenAuthUserName.FromProjectLocationClusterTokenAuthUser("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await cloudRedisClusterClient.DeleteTokenAuthUserAsync(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 cloudRedisClusterClient.PollOnceDeleteTokenAuthUserAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
TokenAuthUserName name = TokenAuthUserName.FromProjectLocationClusterTokenAuthUser("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]");
// Make the request
Operation<Empty, OperationMetadata> response = await cloudRedisClusterClient.DeleteTokenAuthUserAsync(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 cloudRedisClusterClient.PollOnceDeleteTokenAuthUserAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
TokenAuthUserName name = TokenAuthUserName.FromProjectLocationClusterTokenAuthUser("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]");
// Make the request
Operation<Empty, OperationMetadata> response = await cloudRedisClusterClient.DeleteTokenAuthUserAsync(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 cloudRedisClusterClient.PollOnceDeleteTokenAuthUserAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]/tokenAuthUsers/[TOKEN_AUTH_USER]";
// Make the request
Operation<Empty, OperationMetadata> response = await cloudRedisClusterClient.DeleteTokenAuthUserAsync(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 cloudRedisClusterClient.PollOnceDeleteTokenAuthUserAsync(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
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/clusters/[CLUSTER]/tokenAuthUsers/[TOKEN_AUTH_USER]";
// Make the request
Operation<Empty, OperationMetadata> response = await cloudRedisClusterClient.DeleteTokenAuthUserAsync(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 cloudRedisClusterClient.PollOnceDeleteTokenAuthUserAsync(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
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
ExportBackupRequest request = new ExportBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]"),
    GcsBucket = "",
};
// Make the request
Operation<Backup, Any> response = cloudRedisClusterClient.ExportBackup(request);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
ExportBackupRequest request = new ExportBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]"),
    GcsBucket = "",
};
// Make the request
Operation<Backup, Any> response = await cloudRedisClusterClient.ExportBackupAsync(request);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
ExportBackupRequest request = new ExportBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupCollectionBackup("[PROJECT]", "[LOCATION]", "[BACKUP_COLLECTION]", "[BACKUP]"),
    GcsBucket = "",
};
// Make the request
Operation<Backup, Any> response = await cloudRedisClusterClient.ExportBackupAsync(request);

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

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
AclPolicyName name = AclPolicyName.FromProjectLocationAclPolicy("[PROJECT]", "[LOCATION]", "[ACL_POLICY]");
// Make the request
AclPolicy response = cloudRedisClusterClient.GetAclPolicy(name);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
GetAclPolicyRequest request = new GetAclPolicyRequest
{
    AclPolicyName = AclPolicyName.FromProjectLocationAclPolicy("[PROJECT]", "[LOCATION]", "[ACL_POLICY]"),
};
// Make the request
AclPolicy response = cloudRedisClusterClient.GetAclPolicy(request);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/aclPolicies/[ACL_POLICY]";
// Make the request
AclPolicy response = cloudRedisClusterClient.GetAclPolicy(name);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
AclPolicyName name = AclPolicyName.FromProjectLocationAclPolicy("[PROJECT]", "[LOCATION]", "[ACL_POLICY]");
// Make the request
AclPolicy response = await cloudRedisClusterClient.GetAclPolicyAsync(name);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
AclPolicyName name = AclPolicyName.FromProjectLocationAclPolicy("[PROJECT]", "[LOCATION]", "[ACL_POLICY]");
// Make the request
AclPolicy response = await cloudRedisClusterClient.GetAclPolicyAsync(name);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
GetAclPolicyRequest request = new GetAclPolicyRequest
{
    AclPolicyName = AclPolicyName.FromProjectLocationAclPolicy("[PROJECT]", "[LOCATION]", "[ACL_POLICY]"),
};
// Make the request
AclPolicy response = await cloudRedisClusterClient.GetAclPolicyAsync(request);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
GetAclPolicyRequest request = new GetAclPolicyRequest
{
    AclPolicyName = AclPolicyName.FromProjectLocationAclPolicy("[PROJECT]", "[LOCATION]", "[ACL_POLICY]"),
};
// Make the request
AclPolicy response = await cloudRedisClusterClient.GetAclPolicyAsync(request);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/aclPolicies/[ACL_POLICY]";
// Make the request
AclPolicy response = await cloudRedisClusterClient.GetAclPolicyAsync(name);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/aclPolicies/[ACL_POLICY]";
// Make the request
AclPolicy response = await cloudRedisClusterClient.GetAclPolicyAsync(name);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
AclPolicyRevisionName name = AclPolicyRevisionName.FromProjectLocationAclPolicyRevision("[PROJECT]", "[LOCATION]", "[ACL_POLICY]", "[REVISION]");
// Make the request
AclPolicyRevision response = cloudRedisClusterClient.GetAclPolicyRevision(name);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
GetAclPolicyRevisionRequest request = new GetAclPolicyRevisionRequest
{
    AclPolicyRevisionName = AclPolicyRevisionName.FromProjectLocationAclPolicyRevision("[PROJECT]", "[LOCATION]", "[ACL_POLICY]", "[REVISION]"),
};
// Make the request
AclPolicyRevision response = cloudRedisClusterClient.GetAclPolicyRevision(request);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/aclPolicies/[ACL_POLICY]/revisions/[REVISION]";
// Make the request
AclPolicyRevision response = cloudRedisClusterClient.GetAclPolicyRevision(name);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
AclPolicyRevisionName name = AclPolicyRevisionName.FromProjectLocationAclPolicyRevision("[PROJECT]", "[LOCATION]", "[ACL_POLICY]", "[REVISION]");
// Make the request
AclPolicyRevision response = await cloudRedisClusterClient.GetAclPolicyRevisionAsync(name);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
AclPolicyRevisionName name = AclPolicyRevisionName.FromProjectLocationAclPolicyRevision("[PROJECT]", "[LOCATION]", "[ACL_POLICY]", "[REVISION]");
// Make the request
AclPolicyRevision response = await cloudRedisClusterClient.GetAclPolicyRevisionAsync(name);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
GetAclPolicyRevisionRequest request = new GetAclPolicyRevisionRequest
{
    AclPolicyRevisionName = AclPolicyRevisionName.FromProjectLocationAclPolicyRevision("[PROJECT]", "[LOCATION]", "[ACL_POLICY]", "[REVISION]"),
};
// Make the request
AclPolicyRevision response = await cloudRedisClusterClient.GetAclPolicyRevisionAsync(request);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
GetAclPolicyRevisionRequest request = new GetAclPolicyRevisionRequest
{
    AclPolicyRevisionName = AclPolicyRevisionName.FromProjectLocationAclPolicyRevision("[PROJECT]", "[LOCATION]", "[ACL_POLICY]", "[REVISION]"),
};
// Make the request
AclPolicyRevision response = await cloudRedisClusterClient.GetAclPolicyRevisionAsync(request);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/aclPolicies/[ACL_POLICY]/revisions/[REVISION]";
// Make the request
AclPolicyRevision response = await cloudRedisClusterClient.GetAclPolicyRevisionAsync(name);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = await CloudRedisClusterClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/aclPolicies/[ACL_POLICY]/revisions/[REVISION]";
// Make the request
AclPolicyRevision response = await cloudRedisClusterClient.GetAclPolicyRevisionAsync(name);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
AuthTokenName name = AuthTokenName.FromProjectLocationClusterTokenAuthUserAuthToken("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]", "[AUTH_TOKEN]");
// Make the request
AuthToken response = cloudRedisClusterClient.GetAuthToken(name);

// Create client
CloudRedisClusterClient cloudRedisClusterClient = CloudRedisClusterClient.Create();
// Initialize request argument(s)
GetAuthTokenRequest request = new GetAuthTokenRequest
{
    AuthTokenName = AuthTokenName.FromProjectLocationClusterTokenAuthUserAuthToken("[PROJECT]", "[LOCATION]", "[CLUSTER]", "[TOKEN_AUTH_USER]", "[AUTH_TOKEN]"),
};
// Make the request
AuthToken response = cloudRedisClusterClient.GetAuthToken(request);