GKE Hub v1 API - Class GkeHubClient (2.8.0)

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Feature resource = new Feature();
string featureId = "";
// Make the request
Operation<Feature, OperationMetadata> response = gkeHubClient.CreateFeature(parent, resource, featureId);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
CreateFeatureRequest request = new CreateFeatureRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    FeatureId = "",
    Resource = new Feature(),
    RequestId = "",
};
// Make the request
Operation<Feature, OperationMetadata> response = gkeHubClient.CreateFeature(request);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Feature resource = new Feature();
string featureId = "";
// Make the request
Operation<Feature, OperationMetadata> response = gkeHubClient.CreateFeature(parent, resource, featureId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Feature resource = new Feature();
string featureId = "";
// Make the request
Operation<Feature, OperationMetadata> response = await gkeHubClient.CreateFeatureAsync(parent, resource, featureId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Feature resource = new Feature();
string featureId = "";
// Make the request
Operation<Feature, OperationMetadata> response = await gkeHubClient.CreateFeatureAsync(parent, resource, featureId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
CreateFeatureRequest request = new CreateFeatureRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    FeatureId = "",
    Resource = new Feature(),
    RequestId = "",
};
// Make the request
Operation<Feature, OperationMetadata> response = await gkeHubClient.CreateFeatureAsync(request);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
CreateFeatureRequest request = new CreateFeatureRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    FeatureId = "",
    Resource = new Feature(),
    RequestId = "",
};
// Make the request
Operation<Feature, OperationMetadata> response = await gkeHubClient.CreateFeatureAsync(request);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Feature resource = new Feature();
string featureId = "";
// Make the request
Operation<Feature, OperationMetadata> response = await gkeHubClient.CreateFeatureAsync(parent, resource, featureId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Feature resource = new Feature();
string featureId = "";
// Make the request
Operation<Feature, OperationMetadata> response = await gkeHubClient.CreateFeatureAsync(parent, resource, featureId);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Fleet fleet = new Fleet();
// Make the request
Operation<Fleet, OperationMetadata> response = gkeHubClient.CreateFleet(parent, fleet);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
CreateFleetRequest request = new CreateFleetRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Fleet = new Fleet(),
};
// Make the request
Operation<Fleet, OperationMetadata> response = gkeHubClient.CreateFleet(request);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Fleet fleet = new Fleet();
// Make the request
Operation<Fleet, OperationMetadata> response = gkeHubClient.CreateFleet(parent, fleet);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Fleet fleet = new Fleet();
// Make the request
Operation<Fleet, OperationMetadata> response = await gkeHubClient.CreateFleetAsync(parent, fleet);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Fleet fleet = new Fleet();
// Make the request
Operation<Fleet, OperationMetadata> response = await gkeHubClient.CreateFleetAsync(parent, fleet);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
CreateFleetRequest request = new CreateFleetRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Fleet = new Fleet(),
};
// Make the request
Operation<Fleet, OperationMetadata> response = await gkeHubClient.CreateFleetAsync(request);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
CreateFleetRequest request = new CreateFleetRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Fleet = new Fleet(),
};
// Make the request
Operation<Fleet, OperationMetadata> response = await gkeHubClient.CreateFleetAsync(request);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Fleet fleet = new Fleet();
// Make the request
Operation<Fleet, OperationMetadata> response = await gkeHubClient.CreateFleetAsync(parent, fleet);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Fleet fleet = new Fleet();
// Make the request
Operation<Fleet, OperationMetadata> response = await gkeHubClient.CreateFleetAsync(parent, fleet);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Membership resource = new Membership();
string membershipId = "";
// Make the request
Operation<Membership, OperationMetadata> response = gkeHubClient.CreateMembership(parent, resource, membershipId);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
CreateMembershipRequest request = new CreateMembershipRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    MembershipId = "",
    Resource = new Membership(),
    RequestId = "",
};
// Make the request
Operation<Membership, OperationMetadata> response = gkeHubClient.CreateMembership(request);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Membership resource = new Membership();
string membershipId = "";
// Make the request
Operation<Membership, OperationMetadata> response = gkeHubClient.CreateMembership(parent, resource, membershipId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Membership resource = new Membership();
string membershipId = "";
// Make the request
Operation<Membership, OperationMetadata> response = await gkeHubClient.CreateMembershipAsync(parent, resource, membershipId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Membership resource = new Membership();
string membershipId = "";
// Make the request
Operation<Membership, OperationMetadata> response = await gkeHubClient.CreateMembershipAsync(parent, resource, membershipId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
CreateMembershipRequest request = new CreateMembershipRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    MembershipId = "",
    Resource = new Membership(),
    RequestId = "",
};
// Make the request
Operation<Membership, OperationMetadata> response = await gkeHubClient.CreateMembershipAsync(request);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
CreateMembershipRequest request = new CreateMembershipRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    MembershipId = "",
    Resource = new Membership(),
    RequestId = "",
};
// Make the request
Operation<Membership, OperationMetadata> response = await gkeHubClient.CreateMembershipAsync(request);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Membership resource = new Membership();
string membershipId = "";
// Make the request
Operation<Membership, OperationMetadata> response = await gkeHubClient.CreateMembershipAsync(parent, resource, membershipId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Membership resource = new Membership();
string membershipId = "";
// Make the request
Operation<Membership, OperationMetadata> response = await gkeHubClient.CreateMembershipAsync(parent, resource, membershipId);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
CreateMembershipBindingRequest request = new CreateMembershipBindingRequest
{
    ParentAsMembershipName = MembershipName.FromProjectLocationMembership("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]"),
    MembershipBinding = new MembershipBinding(),
    MembershipBindingId = "",
};
// Make the request
Operation<MembershipBinding, OperationMetadata> response = gkeHubClient.CreateMembershipBinding(request);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
MembershipName parent = MembershipName.FromProjectLocationMembership("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]");
MembershipBinding membershipBinding = new MembershipBinding();
string membershipBindingId = "";
// Make the request
Operation<MembershipBinding, OperationMetadata> response = gkeHubClient.CreateMembershipBinding(parent, membershipBinding, membershipBindingId);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/memberships/[MEMBERSHIP]";
MembershipBinding membershipBinding = new MembershipBinding();
string membershipBindingId = "";
// Make the request
Operation<MembershipBinding, OperationMetadata> response = gkeHubClient.CreateMembershipBinding(parent, membershipBinding, membershipBindingId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
CreateMembershipBindingRequest request = new CreateMembershipBindingRequest
{
    ParentAsMembershipName = MembershipName.FromProjectLocationMembership("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]"),
    MembershipBinding = new MembershipBinding(),
    MembershipBindingId = "",
};
// Make the request
Operation<MembershipBinding, OperationMetadata> response = await gkeHubClient.CreateMembershipBindingAsync(request);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
CreateMembershipBindingRequest request = new CreateMembershipBindingRequest
{
    ParentAsMembershipName = MembershipName.FromProjectLocationMembership("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]"),
    MembershipBinding = new MembershipBinding(),
    MembershipBindingId = "",
};
// Make the request
Operation<MembershipBinding, OperationMetadata> response = await gkeHubClient.CreateMembershipBindingAsync(request);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
MembershipName parent = MembershipName.FromProjectLocationMembership("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]");
MembershipBinding membershipBinding = new MembershipBinding();
string membershipBindingId = "";
// Make the request
Operation<MembershipBinding, OperationMetadata> response = await gkeHubClient.CreateMembershipBindingAsync(parent, membershipBinding, membershipBindingId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
MembershipName parent = MembershipName.FromProjectLocationMembership("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]");
MembershipBinding membershipBinding = new MembershipBinding();
string membershipBindingId = "";
// Make the request
Operation<MembershipBinding, OperationMetadata> response = await gkeHubClient.CreateMembershipBindingAsync(parent, membershipBinding, membershipBindingId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/memberships/[MEMBERSHIP]";
MembershipBinding membershipBinding = new MembershipBinding();
string membershipBindingId = "";
// Make the request
Operation<MembershipBinding, OperationMetadata> response = await gkeHubClient.CreateMembershipBindingAsync(parent, membershipBinding, membershipBindingId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/memberships/[MEMBERSHIP]";
MembershipBinding membershipBinding = new MembershipBinding();
string membershipBindingId = "";
// Make the request
Operation<MembershipBinding, OperationMetadata> response = await gkeHubClient.CreateMembershipBindingAsync(parent, membershipBinding, membershipBindingId);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
CreateMembershipRBACRoleBindingRequest request = new CreateMembershipRBACRoleBindingRequest
{
    ParentAsScopeName = ScopeName.FromProjectLocationScope("[PROJECT]", "[LOCATION]", "[SCOPE]"),
    RbacrolebindingId = "",
    Rbacrolebinding = new RBACRoleBinding(),
};
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = gkeHubClient.CreateMembershipRBACRoleBinding(request);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
MembershipName parent = MembershipName.FromProjectLocationMembership("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]");
RBACRoleBinding rbacrolebinding = new RBACRoleBinding();
string rbacrolebindingId = "";
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = gkeHubClient.CreateMembershipRBACRoleBinding(parent, rbacrolebinding, rbacrolebindingId);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
ScopeName parent = ScopeName.FromProjectLocationScope("[PROJECT]", "[LOCATION]", "[SCOPE]");
RBACRoleBinding rbacrolebinding = new RBACRoleBinding();
string rbacrolebindingId = "";
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = gkeHubClient.CreateMembershipRBACRoleBinding(parent, rbacrolebinding, rbacrolebindingId);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/scopes/[SCOPE]";
RBACRoleBinding rbacrolebinding = new RBACRoleBinding();
string rbacrolebindingId = "";
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = gkeHubClient.CreateMembershipRBACRoleBinding(parent, rbacrolebinding, rbacrolebindingId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
CreateMembershipRBACRoleBindingRequest request = new CreateMembershipRBACRoleBindingRequest
{
    ParentAsScopeName = ScopeName.FromProjectLocationScope("[PROJECT]", "[LOCATION]", "[SCOPE]"),
    RbacrolebindingId = "",
    Rbacrolebinding = new RBACRoleBinding(),
};
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = await gkeHubClient.CreateMembershipRBACRoleBindingAsync(request);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
CreateMembershipRBACRoleBindingRequest request = new CreateMembershipRBACRoleBindingRequest
{
    ParentAsScopeName = ScopeName.FromProjectLocationScope("[PROJECT]", "[LOCATION]", "[SCOPE]"),
    RbacrolebindingId = "",
    Rbacrolebinding = new RBACRoleBinding(),
};
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = await gkeHubClient.CreateMembershipRBACRoleBindingAsync(request);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
MembershipName parent = MembershipName.FromProjectLocationMembership("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]");
RBACRoleBinding rbacrolebinding = new RBACRoleBinding();
string rbacrolebindingId = "";
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = await gkeHubClient.CreateMembershipRBACRoleBindingAsync(parent, rbacrolebinding, rbacrolebindingId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
MembershipName parent = MembershipName.FromProjectLocationMembership("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]");
RBACRoleBinding rbacrolebinding = new RBACRoleBinding();
string rbacrolebindingId = "";
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = await gkeHubClient.CreateMembershipRBACRoleBindingAsync(parent, rbacrolebinding, rbacrolebindingId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
ScopeName parent = ScopeName.FromProjectLocationScope("[PROJECT]", "[LOCATION]", "[SCOPE]");
RBACRoleBinding rbacrolebinding = new RBACRoleBinding();
string rbacrolebindingId = "";
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = await gkeHubClient.CreateMembershipRBACRoleBindingAsync(parent, rbacrolebinding, rbacrolebindingId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
ScopeName parent = ScopeName.FromProjectLocationScope("[PROJECT]", "[LOCATION]", "[SCOPE]");
RBACRoleBinding rbacrolebinding = new RBACRoleBinding();
string rbacrolebindingId = "";
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = await gkeHubClient.CreateMembershipRBACRoleBindingAsync(parent, rbacrolebinding, rbacrolebindingId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/scopes/[SCOPE]";
RBACRoleBinding rbacrolebinding = new RBACRoleBinding();
string rbacrolebindingId = "";
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = await gkeHubClient.CreateMembershipRBACRoleBindingAsync(parent, rbacrolebinding, rbacrolebindingId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/scopes/[SCOPE]";
RBACRoleBinding rbacrolebinding = new RBACRoleBinding();
string rbacrolebindingId = "";
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = await gkeHubClient.CreateMembershipRBACRoleBindingAsync(parent, rbacrolebinding, rbacrolebindingId);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Scope scope = new Scope();
string scopeId = "";
// Make the request
Operation<Scope, OperationMetadata> response = gkeHubClient.CreateScope(parent, scope, scopeId);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
CreateScopeRequest request = new CreateScopeRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ScopeId = "",
    Scope = new Scope(),
};
// Make the request
Operation<Scope, OperationMetadata> response = gkeHubClient.CreateScope(request);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Scope scope = new Scope();
string scopeId = "";
// Make the request
Operation<Scope, OperationMetadata> response = gkeHubClient.CreateScope(parent, scope, scopeId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Scope scope = new Scope();
string scopeId = "";
// Make the request
Operation<Scope, OperationMetadata> response = await gkeHubClient.CreateScopeAsync(parent, scope, scopeId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Scope scope = new Scope();
string scopeId = "";
// Make the request
Operation<Scope, OperationMetadata> response = await gkeHubClient.CreateScopeAsync(parent, scope, scopeId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
CreateScopeRequest request = new CreateScopeRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ScopeId = "",
    Scope = new Scope(),
};
// Make the request
Operation<Scope, OperationMetadata> response = await gkeHubClient.CreateScopeAsync(request);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
CreateScopeRequest request = new CreateScopeRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ScopeId = "",
    Scope = new Scope(),
};
// Make the request
Operation<Scope, OperationMetadata> response = await gkeHubClient.CreateScopeAsync(request);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Scope scope = new Scope();
string scopeId = "";
// Make the request
Operation<Scope, OperationMetadata> response = await gkeHubClient.CreateScopeAsync(parent, scope, scopeId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Scope scope = new Scope();
string scopeId = "";
// Make the request
Operation<Scope, OperationMetadata> response = await gkeHubClient.CreateScopeAsync(parent, scope, scopeId);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
CreateScopeNamespaceRequest request = new CreateScopeNamespaceRequest
{
    ParentAsScopeName = ScopeName.FromProjectLocationScope("[PROJECT]", "[LOCATION]", "[SCOPE]"),
    ScopeNamespaceId = "",
    ScopeNamespace = new Namespace(),
};
// Make the request
Operation<Namespace, OperationMetadata> response = gkeHubClient.CreateScopeNamespace(request);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
ScopeName parent = ScopeName.FromProjectLocationScope("[PROJECT]", "[LOCATION]", "[SCOPE]");
Namespace scopeNamespace = new Namespace();
string scopeNamespaceId = "";
// Make the request
Operation<Namespace, OperationMetadata> response = gkeHubClient.CreateScopeNamespace(parent, scopeNamespace, scopeNamespaceId);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/scopes/[SCOPE]";
Namespace scopeNamespace = new Namespace();
string scopeNamespaceId = "";
// Make the request
Operation<Namespace, OperationMetadata> response = gkeHubClient.CreateScopeNamespace(parent, scopeNamespace, scopeNamespaceId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
CreateScopeNamespaceRequest request = new CreateScopeNamespaceRequest
{
    ParentAsScopeName = ScopeName.FromProjectLocationScope("[PROJECT]", "[LOCATION]", "[SCOPE]"),
    ScopeNamespaceId = "",
    ScopeNamespace = new Namespace(),
};
// Make the request
Operation<Namespace, OperationMetadata> response = await gkeHubClient.CreateScopeNamespaceAsync(request);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
CreateScopeNamespaceRequest request = new CreateScopeNamespaceRequest
{
    ParentAsScopeName = ScopeName.FromProjectLocationScope("[PROJECT]", "[LOCATION]", "[SCOPE]"),
    ScopeNamespaceId = "",
    ScopeNamespace = new Namespace(),
};
// Make the request
Operation<Namespace, OperationMetadata> response = await gkeHubClient.CreateScopeNamespaceAsync(request);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
ScopeName parent = ScopeName.FromProjectLocationScope("[PROJECT]", "[LOCATION]", "[SCOPE]");
Namespace scopeNamespace = new Namespace();
string scopeNamespaceId = "";
// Make the request
Operation<Namespace, OperationMetadata> response = await gkeHubClient.CreateScopeNamespaceAsync(parent, scopeNamespace, scopeNamespaceId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
ScopeName parent = ScopeName.FromProjectLocationScope("[PROJECT]", "[LOCATION]", "[SCOPE]");
Namespace scopeNamespace = new Namespace();
string scopeNamespaceId = "";
// Make the request
Operation<Namespace, OperationMetadata> response = await gkeHubClient.CreateScopeNamespaceAsync(parent, scopeNamespace, scopeNamespaceId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/scopes/[SCOPE]";
Namespace scopeNamespace = new Namespace();
string scopeNamespaceId = "";
// Make the request
Operation<Namespace, OperationMetadata> response = await gkeHubClient.CreateScopeNamespaceAsync(parent, scopeNamespace, scopeNamespaceId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/scopes/[SCOPE]";
Namespace scopeNamespace = new Namespace();
string scopeNamespaceId = "";
// Make the request
Operation<Namespace, OperationMetadata> response = await gkeHubClient.CreateScopeNamespaceAsync(parent, scopeNamespace, scopeNamespaceId);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
CreateScopeRBACRoleBindingRequest request = new CreateScopeRBACRoleBindingRequest
{
    ParentAsScopeName = ScopeName.FromProjectLocationScope("[PROJECT]", "[LOCATION]", "[SCOPE]"),
    RbacrolebindingId = "",
    Rbacrolebinding = new RBACRoleBinding(),
};
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = gkeHubClient.CreateScopeRBACRoleBinding(request);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
MembershipName parent = MembershipName.FromProjectLocationMembership("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]");
RBACRoleBinding rbacrolebinding = new RBACRoleBinding();
string rbacrolebindingId = "";
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = gkeHubClient.CreateScopeRBACRoleBinding(parent, rbacrolebinding, rbacrolebindingId);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
ScopeName parent = ScopeName.FromProjectLocationScope("[PROJECT]", "[LOCATION]", "[SCOPE]");
RBACRoleBinding rbacrolebinding = new RBACRoleBinding();
string rbacrolebindingId = "";
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = gkeHubClient.CreateScopeRBACRoleBinding(parent, rbacrolebinding, rbacrolebindingId);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/scopes/[SCOPE]";
RBACRoleBinding rbacrolebinding = new RBACRoleBinding();
string rbacrolebindingId = "";
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = gkeHubClient.CreateScopeRBACRoleBinding(parent, rbacrolebinding, rbacrolebindingId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
CreateScopeRBACRoleBindingRequest request = new CreateScopeRBACRoleBindingRequest
{
    ParentAsScopeName = ScopeName.FromProjectLocationScope("[PROJECT]", "[LOCATION]", "[SCOPE]"),
    RbacrolebindingId = "",
    Rbacrolebinding = new RBACRoleBinding(),
};
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = await gkeHubClient.CreateScopeRBACRoleBindingAsync(request);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
CreateScopeRBACRoleBindingRequest request = new CreateScopeRBACRoleBindingRequest
{
    ParentAsScopeName = ScopeName.FromProjectLocationScope("[PROJECT]", "[LOCATION]", "[SCOPE]"),
    RbacrolebindingId = "",
    Rbacrolebinding = new RBACRoleBinding(),
};
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = await gkeHubClient.CreateScopeRBACRoleBindingAsync(request);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
MembershipName parent = MembershipName.FromProjectLocationMembership("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]");
RBACRoleBinding rbacrolebinding = new RBACRoleBinding();
string rbacrolebindingId = "";
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = await gkeHubClient.CreateScopeRBACRoleBindingAsync(parent, rbacrolebinding, rbacrolebindingId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
MembershipName parent = MembershipName.FromProjectLocationMembership("[PROJECT]", "[LOCATION]", "[MEMBERSHIP]");
RBACRoleBinding rbacrolebinding = new RBACRoleBinding();
string rbacrolebindingId = "";
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = await gkeHubClient.CreateScopeRBACRoleBindingAsync(parent, rbacrolebinding, rbacrolebindingId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
ScopeName parent = ScopeName.FromProjectLocationScope("[PROJECT]", "[LOCATION]", "[SCOPE]");
RBACRoleBinding rbacrolebinding = new RBACRoleBinding();
string rbacrolebindingId = "";
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = await gkeHubClient.CreateScopeRBACRoleBindingAsync(parent, rbacrolebinding, rbacrolebindingId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
ScopeName parent = ScopeName.FromProjectLocationScope("[PROJECT]", "[LOCATION]", "[SCOPE]");
RBACRoleBinding rbacrolebinding = new RBACRoleBinding();
string rbacrolebindingId = "";
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = await gkeHubClient.CreateScopeRBACRoleBindingAsync(parent, rbacrolebinding, rbacrolebindingId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/scopes/[SCOPE]";
RBACRoleBinding rbacrolebinding = new RBACRoleBinding();
string rbacrolebindingId = "";
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = await gkeHubClient.CreateScopeRBACRoleBindingAsync(parent, rbacrolebinding, rbacrolebindingId);

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

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

// Create client
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/scopes/[SCOPE]";
RBACRoleBinding rbacrolebinding = new RBACRoleBinding();
string rbacrolebindingId = "";
// Make the request
Operation<RBACRoleBinding, OperationMetadata> response = await gkeHubClient.CreateScopeRBACRoleBindingAsync(parent, rbacrolebinding, rbacrolebindingId);

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

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

// Create client
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
DeleteFeatureRequest request = new DeleteFeatureRequest
{
    FeatureName = FeatureName.FromProjectLocationFeature("[PROJECT]", "[LOCATION]", "[FEATURE]"),
    Force = false,
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = gkeHubClient.DeleteFeature(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 = gkeHubClient.PollOnceDeleteFeature(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
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
FeatureName name = FeatureName.FromProjectLocationFeature("[PROJECT]", "[LOCATION]", "[FEATURE]");
// Make the request
Operation<Empty, OperationMetadata> response = gkeHubClient.DeleteFeature(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 = gkeHubClient.PollOnceDeleteFeature(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
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/features/[FEATURE]";
// Make the request
Operation<Empty, OperationMetadata> response = gkeHubClient.DeleteFeature(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 = gkeHubClient.PollOnceDeleteFeature(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
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
DeleteFeatureRequest request = new DeleteFeatureRequest
{
    FeatureName = FeatureName.FromProjectLocationFeature("[PROJECT]", "[LOCATION]", "[FEATURE]"),
    Force = false,
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await gkeHubClient.DeleteFeatureAsync(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 gkeHubClient.PollOnceDeleteFeatureAsync(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
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
DeleteFeatureRequest request = new DeleteFeatureRequest
{
    FeatureName = FeatureName.FromProjectLocationFeature("[PROJECT]", "[LOCATION]", "[FEATURE]"),
    Force = false,
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await gkeHubClient.DeleteFeatureAsync(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 gkeHubClient.PollOnceDeleteFeatureAsync(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
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
FeatureName name = FeatureName.FromProjectLocationFeature("[PROJECT]", "[LOCATION]", "[FEATURE]");
// Make the request
Operation<Empty, OperationMetadata> response = await gkeHubClient.DeleteFeatureAsync(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 gkeHubClient.PollOnceDeleteFeatureAsync(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
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
FeatureName name = FeatureName.FromProjectLocationFeature("[PROJECT]", "[LOCATION]", "[FEATURE]");
// Make the request
Operation<Empty, OperationMetadata> response = await gkeHubClient.DeleteFeatureAsync(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 gkeHubClient.PollOnceDeleteFeatureAsync(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
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/features/[FEATURE]";
// Make the request
Operation<Empty, OperationMetadata> response = await gkeHubClient.DeleteFeatureAsync(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 gkeHubClient.PollOnceDeleteFeatureAsync(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
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/features/[FEATURE]";
// Make the request
Operation<Empty, OperationMetadata> response = await gkeHubClient.DeleteFeatureAsync(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 gkeHubClient.PollOnceDeleteFeatureAsync(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
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
DeleteFleetRequest request = new DeleteFleetRequest
{
    FleetName = FleetName.FromProjectLocationFleet("[PROJECT]", "[LOCATION]", "[FLEET]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = gkeHubClient.DeleteFleet(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 = gkeHubClient.PollOnceDeleteFleet(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
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
FleetName name = FleetName.FromProjectLocationFleet("[PROJECT]", "[LOCATION]", "[FLEET]");
// Make the request
Operation<Empty, OperationMetadata> response = gkeHubClient.DeleteFleet(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 = gkeHubClient.PollOnceDeleteFleet(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
GkeHubClient gkeHubClient = GkeHubClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/fleets/[FLEET]";
// Make the request
Operation<Empty, OperationMetadata> response = gkeHubClient.DeleteFleet(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 = gkeHubClient.PollOnceDeleteFleet(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
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
DeleteFleetRequest request = new DeleteFleetRequest
{
    FleetName = FleetName.FromProjectLocationFleet("[PROJECT]", "[LOCATION]", "[FLEET]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await gkeHubClient.DeleteFleetAsync(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 gkeHubClient.PollOnceDeleteFleetAsync(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
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
DeleteFleetRequest request = new DeleteFleetRequest
{
    FleetName = FleetName.FromProjectLocationFleet("[PROJECT]", "[LOCATION]", "[FLEET]"),
};
// Make the request
Operation<Empty, OperationMetadata> response = await gkeHubClient.DeleteFleetAsync(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 gkeHubClient.PollOnceDeleteFleetAsync(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
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
FleetName name = FleetName.FromProjectLocationFleet("[PROJECT]", "[LOCATION]", "[FLEET]");
// Make the request
Operation<Empty, OperationMetadata> response = await gkeHubClient.DeleteFleetAsync(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 gkeHubClient.PollOnceDeleteFleetAsync(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
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
FleetName name = FleetName.FromProjectLocationFleet("[PROJECT]", "[LOCATION]", "[FLEET]");
// Make the request
Operation<Empty, OperationMetadata> response = await gkeHubClient.DeleteFleetAsync(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 gkeHubClient.PollOnceDeleteFleetAsync(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
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/fleets/[FLEET]";
// Make the request
Operation<Empty, OperationMetadata> response = await gkeHubClient.DeleteFleetAsync(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 gkeHubClient.PollOnceDeleteFleetAsync(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
GkeHubClient gkeHubClient = await GkeHubClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/fleets/[FLEET]";
// Make the request
Operation<Empty, OperationMetadata> response = await gkeHubClient.DeleteFleetAsync(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 gkeHubClient.PollOnceDeleteFleetAsync(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;
}