Backup for GKE v1 API - Class BackupForGKEClient (2.1.0)

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
BackupPlanName parent = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]");
Backup backup = new Backup();
string backupId = "";
// Make the request
Operation<Backup, OperationMetadata> response = backupForGKEClient.CreateBackup(parent, backup, backupId);

// Poll until the returned long-running operation is complete
Operation<Backup, OperationMetadata> 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, OperationMetadata> retrievedResponse = backupForGKEClient.PollOnceCreateBackup(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
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
CreateBackupRequest request = new CreateBackupRequest
{
    ParentAsBackupPlanName = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]"),
    Backup = new Backup(),
    BackupId = "",
};
// Make the request
Operation<Backup, OperationMetadata> response = backupForGKEClient.CreateBackup(request);

// Poll until the returned long-running operation is complete
Operation<Backup, OperationMetadata> 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, OperationMetadata> retrievedResponse = backupForGKEClient.PollOnceCreateBackup(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
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/backupPlans/[BACKUP_PLAN]";
Backup backup = new Backup();
string backupId = "";
// Make the request
Operation<Backup, OperationMetadata> response = backupForGKEClient.CreateBackup(parent, backup, backupId);

// Poll until the returned long-running operation is complete
Operation<Backup, OperationMetadata> 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, OperationMetadata> retrievedResponse = backupForGKEClient.PollOnceCreateBackup(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
BackupPlanName parent = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]");
Backup backup = new Backup();
string backupId = "";
// Make the request
Operation<Backup, OperationMetadata> response = await backupForGKEClient.CreateBackupAsync(parent, backup, backupId);

// Poll until the returned long-running operation is complete
Operation<Backup, OperationMetadata> 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, OperationMetadata> retrievedResponse = await backupForGKEClient.PollOnceCreateBackupAsync(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
BackupPlanName parent = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]");
Backup backup = new Backup();
string backupId = "";
// Make the request
Operation<Backup, OperationMetadata> response = await backupForGKEClient.CreateBackupAsync(parent, backup, backupId);

// Poll until the returned long-running operation is complete
Operation<Backup, OperationMetadata> 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, OperationMetadata> retrievedResponse = await backupForGKEClient.PollOnceCreateBackupAsync(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
CreateBackupRequest request = new CreateBackupRequest
{
    ParentAsBackupPlanName = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]"),
    Backup = new Backup(),
    BackupId = "",
};
// Make the request
Operation<Backup, OperationMetadata> response = await backupForGKEClient.CreateBackupAsync(request);

// Poll until the returned long-running operation is complete
Operation<Backup, OperationMetadata> 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, OperationMetadata> retrievedResponse = await backupForGKEClient.PollOnceCreateBackupAsync(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
CreateBackupRequest request = new CreateBackupRequest
{
    ParentAsBackupPlanName = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]"),
    Backup = new Backup(),
    BackupId = "",
};
// Make the request
Operation<Backup, OperationMetadata> response = await backupForGKEClient.CreateBackupAsync(request);

// Poll until the returned long-running operation is complete
Operation<Backup, OperationMetadata> 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, OperationMetadata> retrievedResponse = await backupForGKEClient.PollOnceCreateBackupAsync(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/backupPlans/[BACKUP_PLAN]";
Backup backup = new Backup();
string backupId = "";
// Make the request
Operation<Backup, OperationMetadata> response = await backupForGKEClient.CreateBackupAsync(parent, backup, backupId);

// Poll until the returned long-running operation is complete
Operation<Backup, OperationMetadata> 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, OperationMetadata> retrievedResponse = await backupForGKEClient.PollOnceCreateBackupAsync(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/backupPlans/[BACKUP_PLAN]";
Backup backup = new Backup();
string backupId = "";
// Make the request
Operation<Backup, OperationMetadata> response = await backupForGKEClient.CreateBackupAsync(parent, backup, backupId);

// Poll until the returned long-running operation is complete
Operation<Backup, OperationMetadata> 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, OperationMetadata> retrievedResponse = await backupForGKEClient.PollOnceCreateBackupAsync(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
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
BackupPlan backupPlan = new BackupPlan();
string backupPlanId = "";
// Make the request
Operation<BackupPlan, OperationMetadata> response = backupForGKEClient.CreateBackupPlan(parent, backupPlan, backupPlanId);

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

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
CreateBackupPlanRequest request = new CreateBackupPlanRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    BackupPlan = new BackupPlan(),
    BackupPlanId = "",
};
// Make the request
Operation<BackupPlan, OperationMetadata> response = backupForGKEClient.CreateBackupPlan(request);

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

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
BackupPlan backupPlan = new BackupPlan();
string backupPlanId = "";
// Make the request
Operation<BackupPlan, OperationMetadata> response = backupForGKEClient.CreateBackupPlan(parent, backupPlan, backupPlanId);

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

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
BackupPlan backupPlan = new BackupPlan();
string backupPlanId = "";
// Make the request
Operation<BackupPlan, OperationMetadata> response = await backupForGKEClient.CreateBackupPlanAsync(parent, backupPlan, backupPlanId);

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

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
BackupPlan backupPlan = new BackupPlan();
string backupPlanId = "";
// Make the request
Operation<BackupPlan, OperationMetadata> response = await backupForGKEClient.CreateBackupPlanAsync(parent, backupPlan, backupPlanId);

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

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
CreateBackupPlanRequest request = new CreateBackupPlanRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    BackupPlan = new BackupPlan(),
    BackupPlanId = "",
};
// Make the request
Operation<BackupPlan, OperationMetadata> response = await backupForGKEClient.CreateBackupPlanAsync(request);

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

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
CreateBackupPlanRequest request = new CreateBackupPlanRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    BackupPlan = new BackupPlan(),
    BackupPlanId = "",
};
// Make the request
Operation<BackupPlan, OperationMetadata> response = await backupForGKEClient.CreateBackupPlanAsync(request);

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

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
BackupPlan backupPlan = new BackupPlan();
string backupPlanId = "";
// Make the request
Operation<BackupPlan, OperationMetadata> response = await backupForGKEClient.CreateBackupPlanAsync(parent, backupPlan, backupPlanId);

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

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
BackupPlan backupPlan = new BackupPlan();
string backupPlanId = "";
// Make the request
Operation<BackupPlan, OperationMetadata> response = await backupForGKEClient.CreateBackupPlanAsync(parent, backupPlan, backupPlanId);

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

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
CreateRestoreRequest request = new CreateRestoreRequest
{
    ParentAsRestorePlanName = RestorePlanName.FromProjectLocationRestorePlan("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]"),
    Restore = new Restore(),
    RestoreId = "",
};
// Make the request
Operation<Restore, OperationMetadata> response = backupForGKEClient.CreateRestore(request);

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

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
RestorePlanName parent = RestorePlanName.FromProjectLocationRestorePlan("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]");
Restore restore = new Restore();
string restoreId = "";
// Make the request
Operation<Restore, OperationMetadata> response = backupForGKEClient.CreateRestore(parent, restore, restoreId);

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

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/restorePlans/[RESTORE_PLAN]";
Restore restore = new Restore();
string restoreId = "";
// Make the request
Operation<Restore, OperationMetadata> response = backupForGKEClient.CreateRestore(parent, restore, restoreId);

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

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
CreateRestoreRequest request = new CreateRestoreRequest
{
    ParentAsRestorePlanName = RestorePlanName.FromProjectLocationRestorePlan("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]"),
    Restore = new Restore(),
    RestoreId = "",
};
// Make the request
Operation<Restore, OperationMetadata> response = await backupForGKEClient.CreateRestoreAsync(request);

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

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
CreateRestoreRequest request = new CreateRestoreRequest
{
    ParentAsRestorePlanName = RestorePlanName.FromProjectLocationRestorePlan("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]"),
    Restore = new Restore(),
    RestoreId = "",
};
// Make the request
Operation<Restore, OperationMetadata> response = await backupForGKEClient.CreateRestoreAsync(request);

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

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
RestorePlanName parent = RestorePlanName.FromProjectLocationRestorePlan("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]");
Restore restore = new Restore();
string restoreId = "";
// Make the request
Operation<Restore, OperationMetadata> response = await backupForGKEClient.CreateRestoreAsync(parent, restore, restoreId);

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

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
RestorePlanName parent = RestorePlanName.FromProjectLocationRestorePlan("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]");
Restore restore = new Restore();
string restoreId = "";
// Make the request
Operation<Restore, OperationMetadata> response = await backupForGKEClient.CreateRestoreAsync(parent, restore, restoreId);

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

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/restorePlans/[RESTORE_PLAN]";
Restore restore = new Restore();
string restoreId = "";
// Make the request
Operation<Restore, OperationMetadata> response = await backupForGKEClient.CreateRestoreAsync(parent, restore, restoreId);

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

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/restorePlans/[RESTORE_PLAN]";
Restore restore = new Restore();
string restoreId = "";
// Make the request
Operation<Restore, OperationMetadata> response = await backupForGKEClient.CreateRestoreAsync(parent, restore, restoreId);

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

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
RestorePlan restorePlan = new RestorePlan();
string restorePlanId = "";
// Make the request
Operation<RestorePlan, OperationMetadata> response = backupForGKEClient.CreateRestorePlan(parent, restorePlan, restorePlanId);

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

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
CreateRestorePlanRequest request = new CreateRestorePlanRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    RestorePlan = new RestorePlan(),
    RestorePlanId = "",
};
// Make the request
Operation<RestorePlan, OperationMetadata> response = backupForGKEClient.CreateRestorePlan(request);

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

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
RestorePlan restorePlan = new RestorePlan();
string restorePlanId = "";
// Make the request
Operation<RestorePlan, OperationMetadata> response = backupForGKEClient.CreateRestorePlan(parent, restorePlan, restorePlanId);

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

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
RestorePlan restorePlan = new RestorePlan();
string restorePlanId = "";
// Make the request
Operation<RestorePlan, OperationMetadata> response = await backupForGKEClient.CreateRestorePlanAsync(parent, restorePlan, restorePlanId);

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

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
RestorePlan restorePlan = new RestorePlan();
string restorePlanId = "";
// Make the request
Operation<RestorePlan, OperationMetadata> response = await backupForGKEClient.CreateRestorePlanAsync(parent, restorePlan, restorePlanId);

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

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
CreateRestorePlanRequest request = new CreateRestorePlanRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    RestorePlan = new RestorePlan(),
    RestorePlanId = "",
};
// Make the request
Operation<RestorePlan, OperationMetadata> response = await backupForGKEClient.CreateRestorePlanAsync(request);

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

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
CreateRestorePlanRequest request = new CreateRestorePlanRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    RestorePlan = new RestorePlan(),
    RestorePlanId = "",
};
// Make the request
Operation<RestorePlan, OperationMetadata> response = await backupForGKEClient.CreateRestorePlanAsync(request);

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

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
RestorePlan restorePlan = new RestorePlan();
string restorePlanId = "";
// Make the request
Operation<RestorePlan, OperationMetadata> response = await backupForGKEClient.CreateRestorePlanAsync(parent, restorePlan, restorePlanId);

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

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
RestorePlan restorePlan = new RestorePlan();
string restorePlanId = "";
// Make the request
Operation<RestorePlan, OperationMetadata> response = await backupForGKEClient.CreateRestorePlanAsync(parent, restorePlan, restorePlanId);

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

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
BackupName name = BackupName.FromProjectLocationBackupPlanBackup("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]", "[BACKUP]");
// Make the request
Operation<Empty, OperationMetadata> response = backupForGKEClient.DeleteBackup(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 = backupForGKEClient.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
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
DeleteBackupRequest request = new DeleteBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupPlanBackup("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]", "[BACKUP]"),
    Etag = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = backupForGKEClient.DeleteBackup(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 = backupForGKEClient.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
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlans/[BACKUP_PLAN]/backups/[BACKUP]";
// Make the request
Operation<Empty, OperationMetadata> response = backupForGKEClient.DeleteBackup(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 = backupForGKEClient.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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
BackupName name = BackupName.FromProjectLocationBackupPlanBackup("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]", "[BACKUP]");
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteBackupAsync(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 backupForGKEClient.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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
BackupName name = BackupName.FromProjectLocationBackupPlanBackup("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]", "[BACKUP]");
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteBackupAsync(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 backupForGKEClient.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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
DeleteBackupRequest request = new DeleteBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupPlanBackup("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]", "[BACKUP]"),
    Etag = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteBackupAsync(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 backupForGKEClient.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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
DeleteBackupRequest request = new DeleteBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupPlanBackup("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]", "[BACKUP]"),
    Etag = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteBackupAsync(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 backupForGKEClient.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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlans/[BACKUP_PLAN]/backups/[BACKUP]";
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteBackupAsync(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 backupForGKEClient.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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlans/[BACKUP_PLAN]/backups/[BACKUP]";
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteBackupAsync(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 backupForGKEClient.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
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
BackupPlanName name = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]");
// Make the request
Operation<Empty, OperationMetadata> response = backupForGKEClient.DeleteBackupPlan(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 = backupForGKEClient.PollOnceDeleteBackupPlan(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
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
DeleteBackupPlanRequest request = new DeleteBackupPlanRequest
{
    BackupPlanName = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]"),
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = backupForGKEClient.DeleteBackupPlan(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 = backupForGKEClient.PollOnceDeleteBackupPlan(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
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlans/[BACKUP_PLAN]";
// Make the request
Operation<Empty, OperationMetadata> response = backupForGKEClient.DeleteBackupPlan(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 = backupForGKEClient.PollOnceDeleteBackupPlan(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
BackupPlanName name = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]");
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteBackupPlanAsync(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 backupForGKEClient.PollOnceDeleteBackupPlanAsync(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
BackupPlanName name = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]");
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteBackupPlanAsync(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 backupForGKEClient.PollOnceDeleteBackupPlanAsync(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
DeleteBackupPlanRequest request = new DeleteBackupPlanRequest
{
    BackupPlanName = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]"),
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteBackupPlanAsync(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 backupForGKEClient.PollOnceDeleteBackupPlanAsync(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
DeleteBackupPlanRequest request = new DeleteBackupPlanRequest
{
    BackupPlanName = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]"),
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteBackupPlanAsync(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 backupForGKEClient.PollOnceDeleteBackupPlanAsync(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlans/[BACKUP_PLAN]";
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteBackupPlanAsync(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 backupForGKEClient.PollOnceDeleteBackupPlanAsync(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlans/[BACKUP_PLAN]";
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteBackupPlanAsync(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 backupForGKEClient.PollOnceDeleteBackupPlanAsync(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
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
DeleteRestoreRequest request = new DeleteRestoreRequest
{
    RestoreName = RestoreName.FromProjectLocationRestorePlanRestore("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]", "[RESTORE]"),
    Etag = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = backupForGKEClient.DeleteRestore(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 = backupForGKEClient.PollOnceDeleteRestore(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
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
RestoreName name = RestoreName.FromProjectLocationRestorePlanRestore("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]", "[RESTORE]");
// Make the request
Operation<Empty, OperationMetadata> response = backupForGKEClient.DeleteRestore(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 = backupForGKEClient.PollOnceDeleteRestore(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
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/restorePlans/[RESTORE_PLAN]/restores/[RESTORE]";
// Make the request
Operation<Empty, OperationMetadata> response = backupForGKEClient.DeleteRestore(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 = backupForGKEClient.PollOnceDeleteRestore(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
DeleteRestoreRequest request = new DeleteRestoreRequest
{
    RestoreName = RestoreName.FromProjectLocationRestorePlanRestore("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]", "[RESTORE]"),
    Etag = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteRestoreAsync(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 backupForGKEClient.PollOnceDeleteRestoreAsync(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
DeleteRestoreRequest request = new DeleteRestoreRequest
{
    RestoreName = RestoreName.FromProjectLocationRestorePlanRestore("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]", "[RESTORE]"),
    Etag = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteRestoreAsync(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 backupForGKEClient.PollOnceDeleteRestoreAsync(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
RestoreName name = RestoreName.FromProjectLocationRestorePlanRestore("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]", "[RESTORE]");
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteRestoreAsync(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 backupForGKEClient.PollOnceDeleteRestoreAsync(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
RestoreName name = RestoreName.FromProjectLocationRestorePlanRestore("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]", "[RESTORE]");
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteRestoreAsync(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 backupForGKEClient.PollOnceDeleteRestoreAsync(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/restorePlans/[RESTORE_PLAN]/restores/[RESTORE]";
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteRestoreAsync(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 backupForGKEClient.PollOnceDeleteRestoreAsync(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/restorePlans/[RESTORE_PLAN]/restores/[RESTORE]";
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteRestoreAsync(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 backupForGKEClient.PollOnceDeleteRestoreAsync(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
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
DeleteRestorePlanRequest request = new DeleteRestorePlanRequest
{
    RestorePlanName = RestorePlanName.FromProjectLocationRestorePlan("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]"),
    Etag = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = backupForGKEClient.DeleteRestorePlan(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 = backupForGKEClient.PollOnceDeleteRestorePlan(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
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
RestorePlanName name = RestorePlanName.FromProjectLocationRestorePlan("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]");
// Make the request
Operation<Empty, OperationMetadata> response = backupForGKEClient.DeleteRestorePlan(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 = backupForGKEClient.PollOnceDeleteRestorePlan(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
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/restorePlans/[RESTORE_PLAN]";
// Make the request
Operation<Empty, OperationMetadata> response = backupForGKEClient.DeleteRestorePlan(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 = backupForGKEClient.PollOnceDeleteRestorePlan(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
DeleteRestorePlanRequest request = new DeleteRestorePlanRequest
{
    RestorePlanName = RestorePlanName.FromProjectLocationRestorePlan("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]"),
    Etag = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteRestorePlanAsync(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 backupForGKEClient.PollOnceDeleteRestorePlanAsync(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
DeleteRestorePlanRequest request = new DeleteRestorePlanRequest
{
    RestorePlanName = RestorePlanName.FromProjectLocationRestorePlan("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]"),
    Etag = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteRestorePlanAsync(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 backupForGKEClient.PollOnceDeleteRestorePlanAsync(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
RestorePlanName name = RestorePlanName.FromProjectLocationRestorePlan("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]");
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteRestorePlanAsync(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 backupForGKEClient.PollOnceDeleteRestorePlanAsync(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
RestorePlanName name = RestorePlanName.FromProjectLocationRestorePlan("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]");
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteRestorePlanAsync(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 backupForGKEClient.PollOnceDeleteRestorePlanAsync(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/restorePlans/[RESTORE_PLAN]";
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteRestorePlanAsync(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 backupForGKEClient.PollOnceDeleteRestorePlanAsync(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
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/restorePlans/[RESTORE_PLAN]";
// Make the request
Operation<Empty, OperationMetadata> response = await backupForGKEClient.DeleteRestorePlanAsync(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 backupForGKEClient.PollOnceDeleteRestorePlanAsync(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
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
BackupName name = BackupName.FromProjectLocationBackupPlanBackup("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]", "[BACKUP]");
// Make the request
Backup response = backupForGKEClient.GetBackup(name);

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
GetBackupRequest request = new GetBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupPlanBackup("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]", "[BACKUP]"),
};
// Make the request
Backup response = backupForGKEClient.GetBackup(request);

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlans/[BACKUP_PLAN]/backups/[BACKUP]";
// Make the request
Backup response = backupForGKEClient.GetBackup(name);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
BackupName name = BackupName.FromProjectLocationBackupPlanBackup("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]", "[BACKUP]");
// Make the request
Backup response = await backupForGKEClient.GetBackupAsync(name);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
BackupName name = BackupName.FromProjectLocationBackupPlanBackup("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]", "[BACKUP]");
// Make the request
Backup response = await backupForGKEClient.GetBackupAsync(name);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
GetBackupRequest request = new GetBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupPlanBackup("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]", "[BACKUP]"),
};
// Make the request
Backup response = await backupForGKEClient.GetBackupAsync(request);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
GetBackupRequest request = new GetBackupRequest
{
    BackupName = BackupName.FromProjectLocationBackupPlanBackup("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]", "[BACKUP]"),
};
// Make the request
Backup response = await backupForGKEClient.GetBackupAsync(request);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlans/[BACKUP_PLAN]/backups/[BACKUP]";
// Make the request
Backup response = await backupForGKEClient.GetBackupAsync(name);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlans/[BACKUP_PLAN]/backups/[BACKUP]";
// Make the request
Backup response = await backupForGKEClient.GetBackupAsync(name);

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
BackupPlanName name = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]");
// Make the request
BackupPlan response = backupForGKEClient.GetBackupPlan(name);

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
GetBackupPlanRequest request = new GetBackupPlanRequest
{
    BackupPlanName = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]"),
};
// Make the request
BackupPlan response = backupForGKEClient.GetBackupPlan(request);

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlans/[BACKUP_PLAN]";
// Make the request
BackupPlan response = backupForGKEClient.GetBackupPlan(name);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
BackupPlanName name = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]");
// Make the request
BackupPlan response = await backupForGKEClient.GetBackupPlanAsync(name);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
BackupPlanName name = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]");
// Make the request
BackupPlan response = await backupForGKEClient.GetBackupPlanAsync(name);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
GetBackupPlanRequest request = new GetBackupPlanRequest
{
    BackupPlanName = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]"),
};
// Make the request
BackupPlan response = await backupForGKEClient.GetBackupPlanAsync(request);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
GetBackupPlanRequest request = new GetBackupPlanRequest
{
    BackupPlanName = BackupPlanName.FromProjectLocationBackupPlan("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]"),
};
// Make the request
BackupPlan response = await backupForGKEClient.GetBackupPlanAsync(request);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlans/[BACKUP_PLAN]";
// Make the request
BackupPlan response = await backupForGKEClient.GetBackupPlanAsync(name);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlans/[BACKUP_PLAN]";
// Make the request
BackupPlan response = await backupForGKEClient.GetBackupPlanAsync(name);

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
GetRestoreRequest request = new GetRestoreRequest
{
    RestoreName = RestoreName.FromProjectLocationRestorePlanRestore("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]", "[RESTORE]"),
};
// Make the request
Restore response = backupForGKEClient.GetRestore(request);

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
RestoreName name = RestoreName.FromProjectLocationRestorePlanRestore("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]", "[RESTORE]");
// Make the request
Restore response = backupForGKEClient.GetRestore(name);

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/restorePlans/[RESTORE_PLAN]/restores/[RESTORE]";
// Make the request
Restore response = backupForGKEClient.GetRestore(name);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
GetRestoreRequest request = new GetRestoreRequest
{
    RestoreName = RestoreName.FromProjectLocationRestorePlanRestore("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]", "[RESTORE]"),
};
// Make the request
Restore response = await backupForGKEClient.GetRestoreAsync(request);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
GetRestoreRequest request = new GetRestoreRequest
{
    RestoreName = RestoreName.FromProjectLocationRestorePlanRestore("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]", "[RESTORE]"),
};
// Make the request
Restore response = await backupForGKEClient.GetRestoreAsync(request);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
RestoreName name = RestoreName.FromProjectLocationRestorePlanRestore("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]", "[RESTORE]");
// Make the request
Restore response = await backupForGKEClient.GetRestoreAsync(name);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
RestoreName name = RestoreName.FromProjectLocationRestorePlanRestore("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]", "[RESTORE]");
// Make the request
Restore response = await backupForGKEClient.GetRestoreAsync(name);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/restorePlans/[RESTORE_PLAN]/restores/[RESTORE]";
// Make the request
Restore response = await backupForGKEClient.GetRestoreAsync(name);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/restorePlans/[RESTORE_PLAN]/restores/[RESTORE]";
// Make the request
Restore response = await backupForGKEClient.GetRestoreAsync(name);

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
GetRestorePlanRequest request = new GetRestorePlanRequest
{
    RestorePlanName = RestorePlanName.FromProjectLocationRestorePlan("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]"),
};
// Make the request
RestorePlan response = backupForGKEClient.GetRestorePlan(request);

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
RestorePlanName name = RestorePlanName.FromProjectLocationRestorePlan("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]");
// Make the request
RestorePlan response = backupForGKEClient.GetRestorePlan(name);

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/restorePlans/[RESTORE_PLAN]";
// Make the request
RestorePlan response = backupForGKEClient.GetRestorePlan(name);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
GetRestorePlanRequest request = new GetRestorePlanRequest
{
    RestorePlanName = RestorePlanName.FromProjectLocationRestorePlan("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]"),
};
// Make the request
RestorePlan response = await backupForGKEClient.GetRestorePlanAsync(request);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
GetRestorePlanRequest request = new GetRestorePlanRequest
{
    RestorePlanName = RestorePlanName.FromProjectLocationRestorePlan("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]"),
};
// Make the request
RestorePlan response = await backupForGKEClient.GetRestorePlanAsync(request);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
RestorePlanName name = RestorePlanName.FromProjectLocationRestorePlan("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]");
// Make the request
RestorePlan response = await backupForGKEClient.GetRestorePlanAsync(name);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
RestorePlanName name = RestorePlanName.FromProjectLocationRestorePlan("[PROJECT]", "[LOCATION]", "[RESTORE_PLAN]");
// Make the request
RestorePlan response = await backupForGKEClient.GetRestorePlanAsync(name);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/restorePlans/[RESTORE_PLAN]";
// Make the request
RestorePlan response = await backupForGKEClient.GetRestorePlanAsync(name);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/restorePlans/[RESTORE_PLAN]";
// Make the request
RestorePlan response = await backupForGKEClient.GetRestorePlanAsync(name);

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
GetVolumeBackupRequest request = new GetVolumeBackupRequest
{
    VolumeBackupName = VolumeBackupName.FromProjectLocationBackupPlanBackupVolumeBackup("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]", "[BACKUP]", "[VOLUME_BACKUP]"),
};
// Make the request
VolumeBackup response = backupForGKEClient.GetVolumeBackup(request);

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
VolumeBackupName name = VolumeBackupName.FromProjectLocationBackupPlanBackupVolumeBackup("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]", "[BACKUP]", "[VOLUME_BACKUP]");
// Make the request
VolumeBackup response = backupForGKEClient.GetVolumeBackup(name);

// Create client
BackupForGKEClient backupForGKEClient = BackupForGKEClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/backupPlans/[BACKUP_PLAN]/backups/[BACKUP]/volumeBackups/[VOLUME_BACKUP]";
// Make the request
VolumeBackup response = backupForGKEClient.GetVolumeBackup(name);

// Create client
BackupForGKEClient backupForGKEClient = await BackupForGKEClient.CreateAsync();
// Initialize request argument(s)
GetVolumeBackupRequest request = new GetVolumeBackupRequest
{
    VolumeBackupName = VolumeBackupName.FromProjectLocationBackupPlanBackupVolumeBackup("[PROJECT]", "[LOCATION]", "[BACKUP_PLAN]", "[BACKUP]", "[VOLUME_BACKUP]"),
};
// Make the request
VolumeBackup response = await backupForGKEClient.GetVolumeBackupAsync(request);