Class AccessContextManagerClient (1.5.0)

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
CommitServicePerimetersRequest request = new CommitServicePerimetersRequest
{
    ParentAsAccessPolicyName = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]"),
    Etag = "",
};
// Make the request
Operation<CommitServicePerimetersResponse, AccessContextManagerOperationMetadata> response = accessContextManagerClient.CommitServicePerimeters(request);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
CommitServicePerimetersRequest request = new CommitServicePerimetersRequest
{
    ParentAsAccessPolicyName = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]"),
    Etag = "",
};
// Make the request
Operation<CommitServicePerimetersResponse, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.CommitServicePerimetersAsync(request);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
CommitServicePerimetersRequest request = new CommitServicePerimetersRequest
{
    ParentAsAccessPolicyName = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]"),
    Etag = "",
};
// Make the request
Operation<CommitServicePerimetersResponse, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.CommitServicePerimetersAsync(request);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
AccessPolicyName parent = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]");
AccessLevel accessLevel = new AccessLevel();
// Make the request
Operation<AccessLevel, AccessContextManagerOperationMetadata> response = accessContextManagerClient.CreateAccessLevel(parent, accessLevel);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
CreateAccessLevelRequest request = new CreateAccessLevelRequest
{
    ParentAsAccessPolicyName = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]"),
    AccessLevel = new AccessLevel(),
};
// Make the request
Operation<AccessLevel, AccessContextManagerOperationMetadata> response = accessContextManagerClient.CreateAccessLevel(request);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
string parent = "accessPolicies/[ACCESS_POLICY]";
AccessLevel accessLevel = new AccessLevel();
// Make the request
Operation<AccessLevel, AccessContextManagerOperationMetadata> response = accessContextManagerClient.CreateAccessLevel(parent, accessLevel);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
AccessPolicyName parent = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]");
AccessLevel accessLevel = new AccessLevel();
// Make the request
Operation<AccessLevel, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.CreateAccessLevelAsync(parent, accessLevel);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
AccessPolicyName parent = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]");
AccessLevel accessLevel = new AccessLevel();
// Make the request
Operation<AccessLevel, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.CreateAccessLevelAsync(parent, accessLevel);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
CreateAccessLevelRequest request = new CreateAccessLevelRequest
{
    ParentAsAccessPolicyName = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]"),
    AccessLevel = new AccessLevel(),
};
// Make the request
Operation<AccessLevel, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.CreateAccessLevelAsync(request);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
CreateAccessLevelRequest request = new CreateAccessLevelRequest
{
    ParentAsAccessPolicyName = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]"),
    AccessLevel = new AccessLevel(),
};
// Make the request
Operation<AccessLevel, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.CreateAccessLevelAsync(request);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string parent = "accessPolicies/[ACCESS_POLICY]";
AccessLevel accessLevel = new AccessLevel();
// Make the request
Operation<AccessLevel, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.CreateAccessLevelAsync(parent, accessLevel);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string parent = "accessPolicies/[ACCESS_POLICY]";
AccessLevel accessLevel = new AccessLevel();
// Make the request
Operation<AccessLevel, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.CreateAccessLevelAsync(parent, accessLevel);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
AccessPolicy request = new AccessPolicy
{
    AccessPolicyName = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]"),
    Parent = "",
    Title = "",
    CreateTime = new Timestamp(),
    UpdateTime = new Timestamp(),
    Etag = "",
};
// Make the request
Operation<AccessPolicy, AccessContextManagerOperationMetadata> response = accessContextManagerClient.CreateAccessPolicy(request);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
AccessPolicy request = new AccessPolicy
{
    AccessPolicyName = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]"),
    Parent = "",
    Title = "",
    CreateTime = new Timestamp(),
    UpdateTime = new Timestamp(),
    Etag = "",
};
// Make the request
Operation<AccessPolicy, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.CreateAccessPolicyAsync(request);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
AccessPolicy request = new AccessPolicy
{
    AccessPolicyName = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]"),
    Parent = "",
    Title = "",
    CreateTime = new Timestamp(),
    UpdateTime = new Timestamp(),
    Etag = "",
};
// Make the request
Operation<AccessPolicy, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.CreateAccessPolicyAsync(request);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
OrganizationName parent = OrganizationName.FromOrganization("[ORGANIZATION]");
GcpUserAccessBinding gcpUserAccessBinding = new GcpUserAccessBinding();
// Make the request
Operation<GcpUserAccessBinding, GcpUserAccessBindingOperationMetadata> response = accessContextManagerClient.CreateGcpUserAccessBinding(parent, gcpUserAccessBinding);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
CreateGcpUserAccessBindingRequest request = new CreateGcpUserAccessBindingRequest
{
    ParentAsOrganizationName = OrganizationName.FromOrganization("[ORGANIZATION]"),
    GcpUserAccessBinding = new GcpUserAccessBinding(),
};
// Make the request
Operation<GcpUserAccessBinding, GcpUserAccessBindingOperationMetadata> response = accessContextManagerClient.CreateGcpUserAccessBinding(request);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
string parent = "organizations/[ORGANIZATION]";
GcpUserAccessBinding gcpUserAccessBinding = new GcpUserAccessBinding();
// Make the request
Operation<GcpUserAccessBinding, GcpUserAccessBindingOperationMetadata> response = accessContextManagerClient.CreateGcpUserAccessBinding(parent, gcpUserAccessBinding);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
OrganizationName parent = OrganizationName.FromOrganization("[ORGANIZATION]");
GcpUserAccessBinding gcpUserAccessBinding = new GcpUserAccessBinding();
// Make the request
Operation<GcpUserAccessBinding, GcpUserAccessBindingOperationMetadata> response = await accessContextManagerClient.CreateGcpUserAccessBindingAsync(parent, gcpUserAccessBinding);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
OrganizationName parent = OrganizationName.FromOrganization("[ORGANIZATION]");
GcpUserAccessBinding gcpUserAccessBinding = new GcpUserAccessBinding();
// Make the request
Operation<GcpUserAccessBinding, GcpUserAccessBindingOperationMetadata> response = await accessContextManagerClient.CreateGcpUserAccessBindingAsync(parent, gcpUserAccessBinding);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
CreateGcpUserAccessBindingRequest request = new CreateGcpUserAccessBindingRequest
{
    ParentAsOrganizationName = OrganizationName.FromOrganization("[ORGANIZATION]"),
    GcpUserAccessBinding = new GcpUserAccessBinding(),
};
// Make the request
Operation<GcpUserAccessBinding, GcpUserAccessBindingOperationMetadata> response = await accessContextManagerClient.CreateGcpUserAccessBindingAsync(request);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
CreateGcpUserAccessBindingRequest request = new CreateGcpUserAccessBindingRequest
{
    ParentAsOrganizationName = OrganizationName.FromOrganization("[ORGANIZATION]"),
    GcpUserAccessBinding = new GcpUserAccessBinding(),
};
// Make the request
Operation<GcpUserAccessBinding, GcpUserAccessBindingOperationMetadata> response = await accessContextManagerClient.CreateGcpUserAccessBindingAsync(request);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string parent = "organizations/[ORGANIZATION]";
GcpUserAccessBinding gcpUserAccessBinding = new GcpUserAccessBinding();
// Make the request
Operation<GcpUserAccessBinding, GcpUserAccessBindingOperationMetadata> response = await accessContextManagerClient.CreateGcpUserAccessBindingAsync(parent, gcpUserAccessBinding);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string parent = "organizations/[ORGANIZATION]";
GcpUserAccessBinding gcpUserAccessBinding = new GcpUserAccessBinding();
// Make the request
Operation<GcpUserAccessBinding, GcpUserAccessBindingOperationMetadata> response = await accessContextManagerClient.CreateGcpUserAccessBindingAsync(parent, gcpUserAccessBinding);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
AccessPolicyName parent = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]");
ServicePerimeter servicePerimeter = new ServicePerimeter();
// Make the request
Operation<ServicePerimeter, AccessContextManagerOperationMetadata> response = accessContextManagerClient.CreateServicePerimeter(parent, servicePerimeter);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
CreateServicePerimeterRequest request = new CreateServicePerimeterRequest
{
    ParentAsAccessPolicyName = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]"),
    ServicePerimeter = new ServicePerimeter(),
};
// Make the request
Operation<ServicePerimeter, AccessContextManagerOperationMetadata> response = accessContextManagerClient.CreateServicePerimeter(request);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
string parent = "accessPolicies/[ACCESS_POLICY]";
ServicePerimeter servicePerimeter = new ServicePerimeter();
// Make the request
Operation<ServicePerimeter, AccessContextManagerOperationMetadata> response = accessContextManagerClient.CreateServicePerimeter(parent, servicePerimeter);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
AccessPolicyName parent = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]");
ServicePerimeter servicePerimeter = new ServicePerimeter();
// Make the request
Operation<ServicePerimeter, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.CreateServicePerimeterAsync(parent, servicePerimeter);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
AccessPolicyName parent = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]");
ServicePerimeter servicePerimeter = new ServicePerimeter();
// Make the request
Operation<ServicePerimeter, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.CreateServicePerimeterAsync(parent, servicePerimeter);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
CreateServicePerimeterRequest request = new CreateServicePerimeterRequest
{
    ParentAsAccessPolicyName = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]"),
    ServicePerimeter = new ServicePerimeter(),
};
// Make the request
Operation<ServicePerimeter, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.CreateServicePerimeterAsync(request);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
CreateServicePerimeterRequest request = new CreateServicePerimeterRequest
{
    ParentAsAccessPolicyName = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]"),
    ServicePerimeter = new ServicePerimeter(),
};
// Make the request
Operation<ServicePerimeter, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.CreateServicePerimeterAsync(request);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string parent = "accessPolicies/[ACCESS_POLICY]";
ServicePerimeter servicePerimeter = new ServicePerimeter();
// Make the request
Operation<ServicePerimeter, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.CreateServicePerimeterAsync(parent, servicePerimeter);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string parent = "accessPolicies/[ACCESS_POLICY]";
ServicePerimeter servicePerimeter = new ServicePerimeter();
// Make the request
Operation<ServicePerimeter, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.CreateServicePerimeterAsync(parent, servicePerimeter);

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

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

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
AccessLevelName name = AccessLevelName.FromAccessPolicyAccessLevel("[ACCESS_POLICY]", "[ACCESS_LEVEL]");
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = accessContextManagerClient.DeleteAccessLevel(name);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = accessContextManagerClient.PollOnceDeleteAccessLevel(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
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
DeleteAccessLevelRequest request = new DeleteAccessLevelRequest
{
    AccessLevelName = AccessLevelName.FromAccessPolicyAccessLevel("[ACCESS_POLICY]", "[ACCESS_LEVEL]"),
};
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = accessContextManagerClient.DeleteAccessLevel(request);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = accessContextManagerClient.PollOnceDeleteAccessLevel(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
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]/accessLevels/[ACCESS_LEVEL]";
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = accessContextManagerClient.DeleteAccessLevel(name);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = accessContextManagerClient.PollOnceDeleteAccessLevel(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
AccessLevelName name = AccessLevelName.FromAccessPolicyAccessLevel("[ACCESS_POLICY]", "[ACCESS_LEVEL]");
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteAccessLevelAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteAccessLevelAsync(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
AccessLevelName name = AccessLevelName.FromAccessPolicyAccessLevel("[ACCESS_POLICY]", "[ACCESS_LEVEL]");
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteAccessLevelAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteAccessLevelAsync(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
DeleteAccessLevelRequest request = new DeleteAccessLevelRequest
{
    AccessLevelName = AccessLevelName.FromAccessPolicyAccessLevel("[ACCESS_POLICY]", "[ACCESS_LEVEL]"),
};
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteAccessLevelAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteAccessLevelAsync(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
DeleteAccessLevelRequest request = new DeleteAccessLevelRequest
{
    AccessLevelName = AccessLevelName.FromAccessPolicyAccessLevel("[ACCESS_POLICY]", "[ACCESS_LEVEL]"),
};
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteAccessLevelAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteAccessLevelAsync(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]/accessLevels/[ACCESS_LEVEL]";
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteAccessLevelAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteAccessLevelAsync(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]/accessLevels/[ACCESS_LEVEL]";
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteAccessLevelAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteAccessLevelAsync(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
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
AccessPolicyName name = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]");
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = accessContextManagerClient.DeleteAccessPolicy(name);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = accessContextManagerClient.PollOnceDeleteAccessPolicy(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
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
DeleteAccessPolicyRequest request = new DeleteAccessPolicyRequest
{
    AccessPolicyName = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]"),
};
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = accessContextManagerClient.DeleteAccessPolicy(request);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = accessContextManagerClient.PollOnceDeleteAccessPolicy(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
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]";
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = accessContextManagerClient.DeleteAccessPolicy(name);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = accessContextManagerClient.PollOnceDeleteAccessPolicy(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
AccessPolicyName name = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]");
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteAccessPolicyAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteAccessPolicyAsync(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
AccessPolicyName name = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]");
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteAccessPolicyAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteAccessPolicyAsync(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
DeleteAccessPolicyRequest request = new DeleteAccessPolicyRequest
{
    AccessPolicyName = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]"),
};
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteAccessPolicyAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteAccessPolicyAsync(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
DeleteAccessPolicyRequest request = new DeleteAccessPolicyRequest
{
    AccessPolicyName = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]"),
};
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteAccessPolicyAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteAccessPolicyAsync(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]";
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteAccessPolicyAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteAccessPolicyAsync(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]";
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteAccessPolicyAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteAccessPolicyAsync(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
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
DeleteGcpUserAccessBindingRequest request = new DeleteGcpUserAccessBindingRequest
{
    GcpUserAccessBindingName = GcpUserAccessBindingName.FromOrganizationGcpUserAccessBinding("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]"),
};
// Make the request
Operation<Empty, GcpUserAccessBindingOperationMetadata> response = accessContextManagerClient.DeleteGcpUserAccessBinding(request);

// Poll until the returned long-running operation is complete
Operation<Empty, GcpUserAccessBindingOperationMetadata> 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, GcpUserAccessBindingOperationMetadata> retrievedResponse = accessContextManagerClient.PollOnceDeleteGcpUserAccessBinding(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
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
GcpUserAccessBindingName name = GcpUserAccessBindingName.FromOrganizationGcpUserAccessBinding("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]");
// Make the request
Operation<Empty, GcpUserAccessBindingOperationMetadata> response = accessContextManagerClient.DeleteGcpUserAccessBinding(name);

// Poll until the returned long-running operation is complete
Operation<Empty, GcpUserAccessBindingOperationMetadata> 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, GcpUserAccessBindingOperationMetadata> retrievedResponse = accessContextManagerClient.PollOnceDeleteGcpUserAccessBinding(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
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
string name = "organizations/[ORGANIZATION]/gcpUserAccessBindings/[GCP_USER_ACCESS_BINDING]";
// Make the request
Operation<Empty, GcpUserAccessBindingOperationMetadata> response = accessContextManagerClient.DeleteGcpUserAccessBinding(name);

// Poll until the returned long-running operation is complete
Operation<Empty, GcpUserAccessBindingOperationMetadata> 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, GcpUserAccessBindingOperationMetadata> retrievedResponse = accessContextManagerClient.PollOnceDeleteGcpUserAccessBinding(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
DeleteGcpUserAccessBindingRequest request = new DeleteGcpUserAccessBindingRequest
{
    GcpUserAccessBindingName = GcpUserAccessBindingName.FromOrganizationGcpUserAccessBinding("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]"),
};
// Make the request
Operation<Empty, GcpUserAccessBindingOperationMetadata> response = await accessContextManagerClient.DeleteGcpUserAccessBindingAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, GcpUserAccessBindingOperationMetadata> 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, GcpUserAccessBindingOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteGcpUserAccessBindingAsync(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
DeleteGcpUserAccessBindingRequest request = new DeleteGcpUserAccessBindingRequest
{
    GcpUserAccessBindingName = GcpUserAccessBindingName.FromOrganizationGcpUserAccessBinding("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]"),
};
// Make the request
Operation<Empty, GcpUserAccessBindingOperationMetadata> response = await accessContextManagerClient.DeleteGcpUserAccessBindingAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, GcpUserAccessBindingOperationMetadata> 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, GcpUserAccessBindingOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteGcpUserAccessBindingAsync(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
GcpUserAccessBindingName name = GcpUserAccessBindingName.FromOrganizationGcpUserAccessBinding("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]");
// Make the request
Operation<Empty, GcpUserAccessBindingOperationMetadata> response = await accessContextManagerClient.DeleteGcpUserAccessBindingAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, GcpUserAccessBindingOperationMetadata> 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, GcpUserAccessBindingOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteGcpUserAccessBindingAsync(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
GcpUserAccessBindingName name = GcpUserAccessBindingName.FromOrganizationGcpUserAccessBinding("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]");
// Make the request
Operation<Empty, GcpUserAccessBindingOperationMetadata> response = await accessContextManagerClient.DeleteGcpUserAccessBindingAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, GcpUserAccessBindingOperationMetadata> 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, GcpUserAccessBindingOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteGcpUserAccessBindingAsync(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "organizations/[ORGANIZATION]/gcpUserAccessBindings/[GCP_USER_ACCESS_BINDING]";
// Make the request
Operation<Empty, GcpUserAccessBindingOperationMetadata> response = await accessContextManagerClient.DeleteGcpUserAccessBindingAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, GcpUserAccessBindingOperationMetadata> 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, GcpUserAccessBindingOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteGcpUserAccessBindingAsync(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "organizations/[ORGANIZATION]/gcpUserAccessBindings/[GCP_USER_ACCESS_BINDING]";
// Make the request
Operation<Empty, GcpUserAccessBindingOperationMetadata> response = await accessContextManagerClient.DeleteGcpUserAccessBindingAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, GcpUserAccessBindingOperationMetadata> 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, GcpUserAccessBindingOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteGcpUserAccessBindingAsync(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
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
DeleteServicePerimeterRequest request = new DeleteServicePerimeterRequest
{
    ServicePerimeterName = ServicePerimeterName.FromAccessPolicyServicePerimeter("[ACCESS_POLICY]", "[SERVICE_PERIMETER]"),
};
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = accessContextManagerClient.DeleteServicePerimeter(request);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = accessContextManagerClient.PollOnceDeleteServicePerimeter(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
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
ServicePerimeterName name = ServicePerimeterName.FromAccessPolicyServicePerimeter("[ACCESS_POLICY]", "[SERVICE_PERIMETER]");
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = accessContextManagerClient.DeleteServicePerimeter(name);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = accessContextManagerClient.PollOnceDeleteServicePerimeter(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
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]/servicePerimeters/[SERVICE_PERIMETER]";
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = accessContextManagerClient.DeleteServicePerimeter(name);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = accessContextManagerClient.PollOnceDeleteServicePerimeter(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
DeleteServicePerimeterRequest request = new DeleteServicePerimeterRequest
{
    ServicePerimeterName = ServicePerimeterName.FromAccessPolicyServicePerimeter("[ACCESS_POLICY]", "[SERVICE_PERIMETER]"),
};
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteServicePerimeterAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteServicePerimeterAsync(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
DeleteServicePerimeterRequest request = new DeleteServicePerimeterRequest
{
    ServicePerimeterName = ServicePerimeterName.FromAccessPolicyServicePerimeter("[ACCESS_POLICY]", "[SERVICE_PERIMETER]"),
};
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteServicePerimeterAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteServicePerimeterAsync(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
ServicePerimeterName name = ServicePerimeterName.FromAccessPolicyServicePerimeter("[ACCESS_POLICY]", "[SERVICE_PERIMETER]");
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteServicePerimeterAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteServicePerimeterAsync(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
ServicePerimeterName name = ServicePerimeterName.FromAccessPolicyServicePerimeter("[ACCESS_POLICY]", "[SERVICE_PERIMETER]");
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteServicePerimeterAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteServicePerimeterAsync(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]/servicePerimeters/[SERVICE_PERIMETER]";
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteServicePerimeterAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteServicePerimeterAsync(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
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]/servicePerimeters/[SERVICE_PERIMETER]";
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteServicePerimeterAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, AccessContextManagerOperationMetadata> 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, AccessContextManagerOperationMetadata> retrievedResponse = await accessContextManagerClient.PollOnceDeleteServicePerimeterAsync(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
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
AccessLevelName name = AccessLevelName.FromAccessPolicyAccessLevel("[ACCESS_POLICY]", "[ACCESS_LEVEL]");
// Make the request
AccessLevel response = accessContextManagerClient.GetAccessLevel(name);

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
GetAccessLevelRequest request = new GetAccessLevelRequest
{
    AccessLevelName = AccessLevelName.FromAccessPolicyAccessLevel("[ACCESS_POLICY]", "[ACCESS_LEVEL]"),
    AccessLevelFormat = LevelFormat.Unspecified,
};
// Make the request
AccessLevel response = accessContextManagerClient.GetAccessLevel(request);

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]/accessLevels/[ACCESS_LEVEL]";
// Make the request
AccessLevel response = accessContextManagerClient.GetAccessLevel(name);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
AccessLevelName name = AccessLevelName.FromAccessPolicyAccessLevel("[ACCESS_POLICY]", "[ACCESS_LEVEL]");
// Make the request
AccessLevel response = await accessContextManagerClient.GetAccessLevelAsync(name);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
AccessLevelName name = AccessLevelName.FromAccessPolicyAccessLevel("[ACCESS_POLICY]", "[ACCESS_LEVEL]");
// Make the request
AccessLevel response = await accessContextManagerClient.GetAccessLevelAsync(name);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
GetAccessLevelRequest request = new GetAccessLevelRequest
{
    AccessLevelName = AccessLevelName.FromAccessPolicyAccessLevel("[ACCESS_POLICY]", "[ACCESS_LEVEL]"),
    AccessLevelFormat = LevelFormat.Unspecified,
};
// Make the request
AccessLevel response = await accessContextManagerClient.GetAccessLevelAsync(request);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
GetAccessLevelRequest request = new GetAccessLevelRequest
{
    AccessLevelName = AccessLevelName.FromAccessPolicyAccessLevel("[ACCESS_POLICY]", "[ACCESS_LEVEL]"),
    AccessLevelFormat = LevelFormat.Unspecified,
};
// Make the request
AccessLevel response = await accessContextManagerClient.GetAccessLevelAsync(request);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]/accessLevels/[ACCESS_LEVEL]";
// Make the request
AccessLevel response = await accessContextManagerClient.GetAccessLevelAsync(name);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]/accessLevels/[ACCESS_LEVEL]";
// Make the request
AccessLevel response = await accessContextManagerClient.GetAccessLevelAsync(name);

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
AccessPolicyName name = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]");
// Make the request
AccessPolicy response = accessContextManagerClient.GetAccessPolicy(name);

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
GetAccessPolicyRequest request = new GetAccessPolicyRequest
{
    AccessPolicyName = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]"),
};
// Make the request
AccessPolicy response = accessContextManagerClient.GetAccessPolicy(request);

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]";
// Make the request
AccessPolicy response = accessContextManagerClient.GetAccessPolicy(name);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
AccessPolicyName name = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]");
// Make the request
AccessPolicy response = await accessContextManagerClient.GetAccessPolicyAsync(name);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
AccessPolicyName name = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]");
// Make the request
AccessPolicy response = await accessContextManagerClient.GetAccessPolicyAsync(name);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
GetAccessPolicyRequest request = new GetAccessPolicyRequest
{
    AccessPolicyName = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]"),
};
// Make the request
AccessPolicy response = await accessContextManagerClient.GetAccessPolicyAsync(request);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
GetAccessPolicyRequest request = new GetAccessPolicyRequest
{
    AccessPolicyName = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]"),
};
// Make the request
AccessPolicy response = await accessContextManagerClient.GetAccessPolicyAsync(request);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]";
// Make the request
AccessPolicy response = await accessContextManagerClient.GetAccessPolicyAsync(name);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]";
// Make the request
AccessPolicy response = await accessContextManagerClient.GetAccessPolicyAsync(name);

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
GcpUserAccessBindingName name = GcpUserAccessBindingName.FromOrganizationGcpUserAccessBinding("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]");
// Make the request
GcpUserAccessBinding response = accessContextManagerClient.GetGcpUserAccessBinding(name);

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
GetGcpUserAccessBindingRequest request = new GetGcpUserAccessBindingRequest
{
    GcpUserAccessBindingName = GcpUserAccessBindingName.FromOrganizationGcpUserAccessBinding("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]"),
};
// Make the request
GcpUserAccessBinding response = accessContextManagerClient.GetGcpUserAccessBinding(request);

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
string name = "organizations/[ORGANIZATION]/gcpUserAccessBindings/[GCP_USER_ACCESS_BINDING]";
// Make the request
GcpUserAccessBinding response = accessContextManagerClient.GetGcpUserAccessBinding(name);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
GcpUserAccessBindingName name = GcpUserAccessBindingName.FromOrganizationGcpUserAccessBinding("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]");
// Make the request
GcpUserAccessBinding response = await accessContextManagerClient.GetGcpUserAccessBindingAsync(name);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
GcpUserAccessBindingName name = GcpUserAccessBindingName.FromOrganizationGcpUserAccessBinding("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]");
// Make the request
GcpUserAccessBinding response = await accessContextManagerClient.GetGcpUserAccessBindingAsync(name);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
GetGcpUserAccessBindingRequest request = new GetGcpUserAccessBindingRequest
{
    GcpUserAccessBindingName = GcpUserAccessBindingName.FromOrganizationGcpUserAccessBinding("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]"),
};
// Make the request
GcpUserAccessBinding response = await accessContextManagerClient.GetGcpUserAccessBindingAsync(request);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
GetGcpUserAccessBindingRequest request = new GetGcpUserAccessBindingRequest
{
    GcpUserAccessBindingName = GcpUserAccessBindingName.FromOrganizationGcpUserAccessBinding("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]"),
};
// Make the request
GcpUserAccessBinding response = await accessContextManagerClient.GetGcpUserAccessBindingAsync(request);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "organizations/[ORGANIZATION]/gcpUserAccessBindings/[GCP_USER_ACCESS_BINDING]";
// Make the request
GcpUserAccessBinding response = await accessContextManagerClient.GetGcpUserAccessBindingAsync(name);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "organizations/[ORGANIZATION]/gcpUserAccessBindings/[GCP_USER_ACCESS_BINDING]";
// Make the request
GcpUserAccessBinding response = await accessContextManagerClient.GetGcpUserAccessBindingAsync(name);

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
GetServicePerimeterRequest request = new GetServicePerimeterRequest
{
    ServicePerimeterName = ServicePerimeterName.FromAccessPolicyServicePerimeter("[ACCESS_POLICY]", "[SERVICE_PERIMETER]"),
};
// Make the request
ServicePerimeter response = accessContextManagerClient.GetServicePerimeter(request);

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
ServicePerimeterName name = ServicePerimeterName.FromAccessPolicyServicePerimeter("[ACCESS_POLICY]", "[SERVICE_PERIMETER]");
// Make the request
ServicePerimeter response = accessContextManagerClient.GetServicePerimeter(name);

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]/servicePerimeters/[SERVICE_PERIMETER]";
// Make the request
ServicePerimeter response = accessContextManagerClient.GetServicePerimeter(name);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
GetServicePerimeterRequest request = new GetServicePerimeterRequest
{
    ServicePerimeterName = ServicePerimeterName.FromAccessPolicyServicePerimeter("[ACCESS_POLICY]", "[SERVICE_PERIMETER]"),
};
// Make the request
ServicePerimeter response = await accessContextManagerClient.GetServicePerimeterAsync(request);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
GetServicePerimeterRequest request = new GetServicePerimeterRequest
{
    ServicePerimeterName = ServicePerimeterName.FromAccessPolicyServicePerimeter("[ACCESS_POLICY]", "[SERVICE_PERIMETER]"),
};
// Make the request
ServicePerimeter response = await accessContextManagerClient.GetServicePerimeterAsync(request);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
ServicePerimeterName name = ServicePerimeterName.FromAccessPolicyServicePerimeter("[ACCESS_POLICY]", "[SERVICE_PERIMETER]");
// Make the request
ServicePerimeter response = await accessContextManagerClient.GetServicePerimeterAsync(name);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
ServicePerimeterName name = ServicePerimeterName.FromAccessPolicyServicePerimeter("[ACCESS_POLICY]", "[SERVICE_PERIMETER]");
// Make the request
ServicePerimeter response = await accessContextManagerClient.GetServicePerimeterAsync(name);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]/servicePerimeters/[SERVICE_PERIMETER]";
// Make the request
ServicePerimeter response = await accessContextManagerClient.GetServicePerimeterAsync(name);

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]/servicePerimeters/[SERVICE_PERIMETER]";
// Make the request
ServicePerimeter response = await accessContextManagerClient.GetServicePerimeterAsync(name);

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
AccessPolicyName parent = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]");
// Make the request
PagedEnumerable<ListAccessLevelsResponse, AccessLevel> response = accessContextManagerClient.ListAccessLevels(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (AccessLevel item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListAccessLevelsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AccessLevel item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AccessLevel> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AccessLevel item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
ListAccessLevelsRequest request = new ListAccessLevelsRequest
{
    ParentAsAccessPolicyName = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]"),
    AccessLevelFormat = LevelFormat.Unspecified,
};
// Make the request
PagedEnumerable<ListAccessLevelsResponse, AccessLevel> response = accessContextManagerClient.ListAccessLevels(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (AccessLevel item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListAccessLevelsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AccessLevel item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AccessLevel> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AccessLevel item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
string parent = "accessPolicies/[ACCESS_POLICY]";
// Make the request
PagedEnumerable<ListAccessLevelsResponse, AccessLevel> response = accessContextManagerClient.ListAccessLevels(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (AccessLevel item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListAccessLevelsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AccessLevel item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AccessLevel> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AccessLevel item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
AccessPolicyName parent = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]");
// Make the request
PagedAsyncEnumerable<ListAccessLevelsResponse, AccessLevel> response = accessContextManagerClient.ListAccessLevelsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AccessLevel item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListAccessLevelsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AccessLevel item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AccessLevel> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AccessLevel item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
ListAccessLevelsRequest request = new ListAccessLevelsRequest
{
    ParentAsAccessPolicyName = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]"),
    AccessLevelFormat = LevelFormat.Unspecified,
};
// Make the request
PagedAsyncEnumerable<ListAccessLevelsResponse, AccessLevel> response = accessContextManagerClient.ListAccessLevelsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AccessLevel item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListAccessLevelsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AccessLevel item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AccessLevel> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AccessLevel item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string parent = "accessPolicies/[ACCESS_POLICY]";
// Make the request
PagedAsyncEnumerable<ListAccessLevelsResponse, AccessLevel> response = accessContextManagerClient.ListAccessLevelsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AccessLevel item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListAccessLevelsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AccessLevel item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AccessLevel> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AccessLevel item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
ListAccessPoliciesRequest request = new ListAccessPoliciesRequest
{
    ParentAsOrganizationName = OrganizationName.FromOrganization("[ORGANIZATION]"),
};
// Make the request
PagedEnumerable<ListAccessPoliciesResponse, AccessPolicy> response = accessContextManagerClient.ListAccessPolicies(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (AccessPolicy item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListAccessPoliciesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AccessPolicy item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AccessPolicy> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AccessPolicy item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
ListAccessPoliciesRequest request = new ListAccessPoliciesRequest
{
    ParentAsOrganizationName = OrganizationName.FromOrganization("[ORGANIZATION]"),
};
// Make the request
PagedAsyncEnumerable<ListAccessPoliciesResponse, AccessPolicy> response = accessContextManagerClient.ListAccessPoliciesAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((AccessPolicy item) =>
{
    // Do something with each item
    Console.WriteLine(item);
});

// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListAccessPoliciesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (AccessPolicy item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<AccessPolicy> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (AccessPolicy item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
OrganizationName parent = OrganizationName.FromOrganization("[ORGANIZATION]");
// Make the request
PagedEnumerable<ListGcpUserAccessBindingsResponse, GcpUserAccessBinding> response = accessContextManagerClient.ListGcpUserAccessBindings(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (GcpUserAccessBinding item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListGcpUserAccessBindingsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (GcpUserAccessBinding item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<GcpUserAccessBinding> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (GcpUserAccessBinding item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
ListGcpUserAccessBindingsRequest request = new ListGcpUserAccessBindingsRequest
{
    ParentAsOrganizationName = OrganizationName.FromOrganization("[ORGANIZATION]"),
};
// Make the request
PagedEnumerable<ListGcpUserAccessBindingsResponse, GcpUserAccessBinding> response = accessContextManagerClient.ListGcpUserAccessBindings(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (GcpUserAccessBinding item in response)
{
    // Do something with each item
    Console.WriteLine(item);
}

// Or iterate over pages (of server-defined size), performing one RPC per page
foreach (ListGcpUserAccessBindingsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (GcpUserAccessBinding item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
}

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<GcpUserAccessBinding> singlePage = response.ReadPage(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (GcpUserAccessBinding item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;