Identity and Access Management (IAM) v3beta API - Class PrincipalAccessBoundaryPoliciesClient (1.0.0-beta01)

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = PrincipalAccessBoundaryPoliciesClient.Create();
// Initialize request argument(s)
CreatePrincipalAccessBoundaryPolicyRequest request = new CreatePrincipalAccessBoundaryPolicyRequest
{
    ParentAsOrganizationLocationName = OrganizationLocationName.FromOrganizationLocation("[ORGANIZATION]", "[LOCATION]"),
    PrincipalAccessBoundaryPolicyId = "",
    PrincipalAccessBoundaryPolicy = new PrincipalAccessBoundaryPolicy(),
    ValidateOnly = false,
};
// Make the request
Operation<PrincipalAccessBoundaryPolicy, OperationMetadata> response = principalAccessBoundaryPoliciesClient.CreatePrincipalAccessBoundaryPolicy(request);

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

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

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = PrincipalAccessBoundaryPoliciesClient.Create();
// Initialize request argument(s)
OrganizationLocationName parent = OrganizationLocationName.FromOrganizationLocation("[ORGANIZATION]", "[LOCATION]");
PrincipalAccessBoundaryPolicy principalAccessBoundaryPolicy = new PrincipalAccessBoundaryPolicy();
string principalAccessBoundaryPolicyId = "";
// Make the request
Operation<PrincipalAccessBoundaryPolicy, OperationMetadata> response = principalAccessBoundaryPoliciesClient.CreatePrincipalAccessBoundaryPolicy(parent, principalAccessBoundaryPolicy, principalAccessBoundaryPolicyId);

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

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

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = PrincipalAccessBoundaryPoliciesClient.Create();
// Initialize request argument(s)
string parent = "organizations/[ORGANIZATION]/locations/[LOCATION]";
PrincipalAccessBoundaryPolicy principalAccessBoundaryPolicy = new PrincipalAccessBoundaryPolicy();
string principalAccessBoundaryPolicyId = "";
// Make the request
Operation<PrincipalAccessBoundaryPolicy, OperationMetadata> response = principalAccessBoundaryPoliciesClient.CreatePrincipalAccessBoundaryPolicy(parent, principalAccessBoundaryPolicy, principalAccessBoundaryPolicyId);

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

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

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
CreatePrincipalAccessBoundaryPolicyRequest request = new CreatePrincipalAccessBoundaryPolicyRequest
{
    ParentAsOrganizationLocationName = OrganizationLocationName.FromOrganizationLocation("[ORGANIZATION]", "[LOCATION]"),
    PrincipalAccessBoundaryPolicyId = "",
    PrincipalAccessBoundaryPolicy = new PrincipalAccessBoundaryPolicy(),
    ValidateOnly = false,
};
// Make the request
Operation<PrincipalAccessBoundaryPolicy, OperationMetadata> response = await principalAccessBoundaryPoliciesClient.CreatePrincipalAccessBoundaryPolicyAsync(request);

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

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

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
CreatePrincipalAccessBoundaryPolicyRequest request = new CreatePrincipalAccessBoundaryPolicyRequest
{
    ParentAsOrganizationLocationName = OrganizationLocationName.FromOrganizationLocation("[ORGANIZATION]", "[LOCATION]"),
    PrincipalAccessBoundaryPolicyId = "",
    PrincipalAccessBoundaryPolicy = new PrincipalAccessBoundaryPolicy(),
    ValidateOnly = false,
};
// Make the request
Operation<PrincipalAccessBoundaryPolicy, OperationMetadata> response = await principalAccessBoundaryPoliciesClient.CreatePrincipalAccessBoundaryPolicyAsync(request);

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

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

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
OrganizationLocationName parent = OrganizationLocationName.FromOrganizationLocation("[ORGANIZATION]", "[LOCATION]");
PrincipalAccessBoundaryPolicy principalAccessBoundaryPolicy = new PrincipalAccessBoundaryPolicy();
string principalAccessBoundaryPolicyId = "";
// Make the request
Operation<PrincipalAccessBoundaryPolicy, OperationMetadata> response = await principalAccessBoundaryPoliciesClient.CreatePrincipalAccessBoundaryPolicyAsync(parent, principalAccessBoundaryPolicy, principalAccessBoundaryPolicyId);

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

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

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
OrganizationLocationName parent = OrganizationLocationName.FromOrganizationLocation("[ORGANIZATION]", "[LOCATION]");
PrincipalAccessBoundaryPolicy principalAccessBoundaryPolicy = new PrincipalAccessBoundaryPolicy();
string principalAccessBoundaryPolicyId = "";
// Make the request
Operation<PrincipalAccessBoundaryPolicy, OperationMetadata> response = await principalAccessBoundaryPoliciesClient.CreatePrincipalAccessBoundaryPolicyAsync(parent, principalAccessBoundaryPolicy, principalAccessBoundaryPolicyId);

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

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

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
string parent = "organizations/[ORGANIZATION]/locations/[LOCATION]";
PrincipalAccessBoundaryPolicy principalAccessBoundaryPolicy = new PrincipalAccessBoundaryPolicy();
string principalAccessBoundaryPolicyId = "";
// Make the request
Operation<PrincipalAccessBoundaryPolicy, OperationMetadata> response = await principalAccessBoundaryPoliciesClient.CreatePrincipalAccessBoundaryPolicyAsync(parent, principalAccessBoundaryPolicy, principalAccessBoundaryPolicyId);

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

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

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
string parent = "organizations/[ORGANIZATION]/locations/[LOCATION]";
PrincipalAccessBoundaryPolicy principalAccessBoundaryPolicy = new PrincipalAccessBoundaryPolicy();
string principalAccessBoundaryPolicyId = "";
// Make the request
Operation<PrincipalAccessBoundaryPolicy, OperationMetadata> response = await principalAccessBoundaryPoliciesClient.CreatePrincipalAccessBoundaryPolicyAsync(parent, principalAccessBoundaryPolicy, principalAccessBoundaryPolicyId);

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

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

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = PrincipalAccessBoundaryPoliciesClient.Create();
// Initialize request argument(s)
DeletePrincipalAccessBoundaryPolicyRequest request = new DeletePrincipalAccessBoundaryPolicyRequest
{
    PrincipalAccessBoundaryPolicyName = PrincipalAccessBoundaryPolicyName.FromOrganizationLocationPrincipalAccessBoundaryPolicy("[ORGANIZATION]", "[LOCATION]", "[PRINCIPAL_ACCESS_BOUNDARY_POLICY]"),
    Etag = "",
    ValidateOnly = false,
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = principalAccessBoundaryPoliciesClient.DeletePrincipalAccessBoundaryPolicy(request);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = principalAccessBoundaryPoliciesClient.PollOnceDeletePrincipalAccessBoundaryPolicy(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
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = PrincipalAccessBoundaryPoliciesClient.Create();
// Initialize request argument(s)
PrincipalAccessBoundaryPolicyName name = PrincipalAccessBoundaryPolicyName.FromOrganizationLocationPrincipalAccessBoundaryPolicy("[ORGANIZATION]", "[LOCATION]", "[PRINCIPAL_ACCESS_BOUNDARY_POLICY]");
// Make the request
Operation<Empty, OperationMetadata> response = principalAccessBoundaryPoliciesClient.DeletePrincipalAccessBoundaryPolicy(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = principalAccessBoundaryPoliciesClient.PollOnceDeletePrincipalAccessBoundaryPolicy(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
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = PrincipalAccessBoundaryPoliciesClient.Create();
// Initialize request argument(s)
string name = "organizations/[ORGANIZATION]/locations/[LOCATION]/principalAccessBoundaryPolicies/[PRINCIPAL_ACCESS_BOUNDARY_POLICY]";
// Make the request
Operation<Empty, OperationMetadata> response = principalAccessBoundaryPoliciesClient.DeletePrincipalAccessBoundaryPolicy(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = principalAccessBoundaryPoliciesClient.PollOnceDeletePrincipalAccessBoundaryPolicy(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
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
DeletePrincipalAccessBoundaryPolicyRequest request = new DeletePrincipalAccessBoundaryPolicyRequest
{
    PrincipalAccessBoundaryPolicyName = PrincipalAccessBoundaryPolicyName.FromOrganizationLocationPrincipalAccessBoundaryPolicy("[ORGANIZATION]", "[LOCATION]", "[PRINCIPAL_ACCESS_BOUNDARY_POLICY]"),
    Etag = "",
    ValidateOnly = false,
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await principalAccessBoundaryPoliciesClient.DeletePrincipalAccessBoundaryPolicyAsync(request);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await principalAccessBoundaryPoliciesClient.PollOnceDeletePrincipalAccessBoundaryPolicyAsync(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
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
DeletePrincipalAccessBoundaryPolicyRequest request = new DeletePrincipalAccessBoundaryPolicyRequest
{
    PrincipalAccessBoundaryPolicyName = PrincipalAccessBoundaryPolicyName.FromOrganizationLocationPrincipalAccessBoundaryPolicy("[ORGANIZATION]", "[LOCATION]", "[PRINCIPAL_ACCESS_BOUNDARY_POLICY]"),
    Etag = "",
    ValidateOnly = false,
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await principalAccessBoundaryPoliciesClient.DeletePrincipalAccessBoundaryPolicyAsync(request);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await principalAccessBoundaryPoliciesClient.PollOnceDeletePrincipalAccessBoundaryPolicyAsync(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
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
PrincipalAccessBoundaryPolicyName name = PrincipalAccessBoundaryPolicyName.FromOrganizationLocationPrincipalAccessBoundaryPolicy("[ORGANIZATION]", "[LOCATION]", "[PRINCIPAL_ACCESS_BOUNDARY_POLICY]");
// Make the request
Operation<Empty, OperationMetadata> response = await principalAccessBoundaryPoliciesClient.DeletePrincipalAccessBoundaryPolicyAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await principalAccessBoundaryPoliciesClient.PollOnceDeletePrincipalAccessBoundaryPolicyAsync(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
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
PrincipalAccessBoundaryPolicyName name = PrincipalAccessBoundaryPolicyName.FromOrganizationLocationPrincipalAccessBoundaryPolicy("[ORGANIZATION]", "[LOCATION]", "[PRINCIPAL_ACCESS_BOUNDARY_POLICY]");
// Make the request
Operation<Empty, OperationMetadata> response = await principalAccessBoundaryPoliciesClient.DeletePrincipalAccessBoundaryPolicyAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await principalAccessBoundaryPoliciesClient.PollOnceDeletePrincipalAccessBoundaryPolicyAsync(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
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
string name = "organizations/[ORGANIZATION]/locations/[LOCATION]/principalAccessBoundaryPolicies/[PRINCIPAL_ACCESS_BOUNDARY_POLICY]";
// Make the request
Operation<Empty, OperationMetadata> response = await principalAccessBoundaryPoliciesClient.DeletePrincipalAccessBoundaryPolicyAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await principalAccessBoundaryPoliciesClient.PollOnceDeletePrincipalAccessBoundaryPolicyAsync(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
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
string name = "organizations/[ORGANIZATION]/locations/[LOCATION]/principalAccessBoundaryPolicies/[PRINCIPAL_ACCESS_BOUNDARY_POLICY]";
// Make the request
Operation<Empty, OperationMetadata> response = await principalAccessBoundaryPoliciesClient.DeletePrincipalAccessBoundaryPolicyAsync(name);

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

// Or get the name of the operation
string operationName = response.Name;
// This name can be stored, then the long-running operation retrieved later by name
Operation<Empty, OperationMetadata> retrievedResponse = await principalAccessBoundaryPoliciesClient.PollOnceDeletePrincipalAccessBoundaryPolicyAsync(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
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = PrincipalAccessBoundaryPoliciesClient.Create();
// Initialize request argument(s)
GetPrincipalAccessBoundaryPolicyRequest request = new GetPrincipalAccessBoundaryPolicyRequest
{
    PrincipalAccessBoundaryPolicyName = PrincipalAccessBoundaryPolicyName.FromOrganizationLocationPrincipalAccessBoundaryPolicy("[ORGANIZATION]", "[LOCATION]", "[PRINCIPAL_ACCESS_BOUNDARY_POLICY]"),
};
// Make the request
PrincipalAccessBoundaryPolicy response = principalAccessBoundaryPoliciesClient.GetPrincipalAccessBoundaryPolicy(request);

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = PrincipalAccessBoundaryPoliciesClient.Create();
// Initialize request argument(s)
PrincipalAccessBoundaryPolicyName name = PrincipalAccessBoundaryPolicyName.FromOrganizationLocationPrincipalAccessBoundaryPolicy("[ORGANIZATION]", "[LOCATION]", "[PRINCIPAL_ACCESS_BOUNDARY_POLICY]");
// Make the request
PrincipalAccessBoundaryPolicy response = principalAccessBoundaryPoliciesClient.GetPrincipalAccessBoundaryPolicy(name);

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = PrincipalAccessBoundaryPoliciesClient.Create();
// Initialize request argument(s)
string name = "organizations/[ORGANIZATION]/locations/[LOCATION]/principalAccessBoundaryPolicies/[PRINCIPAL_ACCESS_BOUNDARY_POLICY]";
// Make the request
PrincipalAccessBoundaryPolicy response = principalAccessBoundaryPoliciesClient.GetPrincipalAccessBoundaryPolicy(name);

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
GetPrincipalAccessBoundaryPolicyRequest request = new GetPrincipalAccessBoundaryPolicyRequest
{
    PrincipalAccessBoundaryPolicyName = PrincipalAccessBoundaryPolicyName.FromOrganizationLocationPrincipalAccessBoundaryPolicy("[ORGANIZATION]", "[LOCATION]", "[PRINCIPAL_ACCESS_BOUNDARY_POLICY]"),
};
// Make the request
PrincipalAccessBoundaryPolicy response = await principalAccessBoundaryPoliciesClient.GetPrincipalAccessBoundaryPolicyAsync(request);

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
GetPrincipalAccessBoundaryPolicyRequest request = new GetPrincipalAccessBoundaryPolicyRequest
{
    PrincipalAccessBoundaryPolicyName = PrincipalAccessBoundaryPolicyName.FromOrganizationLocationPrincipalAccessBoundaryPolicy("[ORGANIZATION]", "[LOCATION]", "[PRINCIPAL_ACCESS_BOUNDARY_POLICY]"),
};
// Make the request
PrincipalAccessBoundaryPolicy response = await principalAccessBoundaryPoliciesClient.GetPrincipalAccessBoundaryPolicyAsync(request);

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
PrincipalAccessBoundaryPolicyName name = PrincipalAccessBoundaryPolicyName.FromOrganizationLocationPrincipalAccessBoundaryPolicy("[ORGANIZATION]", "[LOCATION]", "[PRINCIPAL_ACCESS_BOUNDARY_POLICY]");
// Make the request
PrincipalAccessBoundaryPolicy response = await principalAccessBoundaryPoliciesClient.GetPrincipalAccessBoundaryPolicyAsync(name);

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
PrincipalAccessBoundaryPolicyName name = PrincipalAccessBoundaryPolicyName.FromOrganizationLocationPrincipalAccessBoundaryPolicy("[ORGANIZATION]", "[LOCATION]", "[PRINCIPAL_ACCESS_BOUNDARY_POLICY]");
// Make the request
PrincipalAccessBoundaryPolicy response = await principalAccessBoundaryPoliciesClient.GetPrincipalAccessBoundaryPolicyAsync(name);

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
string name = "organizations/[ORGANIZATION]/locations/[LOCATION]/principalAccessBoundaryPolicies/[PRINCIPAL_ACCESS_BOUNDARY_POLICY]";
// Make the request
PrincipalAccessBoundaryPolicy response = await principalAccessBoundaryPoliciesClient.GetPrincipalAccessBoundaryPolicyAsync(name);

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
string name = "organizations/[ORGANIZATION]/locations/[LOCATION]/principalAccessBoundaryPolicies/[PRINCIPAL_ACCESS_BOUNDARY_POLICY]";
// Make the request
PrincipalAccessBoundaryPolicy response = await principalAccessBoundaryPoliciesClient.GetPrincipalAccessBoundaryPolicyAsync(name);

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = PrincipalAccessBoundaryPoliciesClient.Create();
// Initialize request argument(s)
ListPrincipalAccessBoundaryPoliciesRequest request = new ListPrincipalAccessBoundaryPoliciesRequest
{
    ParentAsOrganizationLocationName = OrganizationLocationName.FromOrganizationLocation("[ORGANIZATION]", "[LOCATION]"),
};
// Make the request
PagedEnumerable<ListPrincipalAccessBoundaryPoliciesResponse, PrincipalAccessBoundaryPolicy> response = principalAccessBoundaryPoliciesClient.ListPrincipalAccessBoundaryPolicies(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (PrincipalAccessBoundaryPolicy 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 (ListPrincipalAccessBoundaryPoliciesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (PrincipalAccessBoundaryPolicy 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<PrincipalAccessBoundaryPolicy> 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 (PrincipalAccessBoundaryPolicy 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
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = PrincipalAccessBoundaryPoliciesClient.Create();
// Initialize request argument(s)
OrganizationLocationName parent = OrganizationLocationName.FromOrganizationLocation("[ORGANIZATION]", "[LOCATION]");
// Make the request
PagedEnumerable<ListPrincipalAccessBoundaryPoliciesResponse, PrincipalAccessBoundaryPolicy> response = principalAccessBoundaryPoliciesClient.ListPrincipalAccessBoundaryPolicies(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (PrincipalAccessBoundaryPolicy 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 (ListPrincipalAccessBoundaryPoliciesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (PrincipalAccessBoundaryPolicy 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<PrincipalAccessBoundaryPolicy> 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 (PrincipalAccessBoundaryPolicy 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
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = PrincipalAccessBoundaryPoliciesClient.Create();
// Initialize request argument(s)
string parent = "organizations/[ORGANIZATION]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListPrincipalAccessBoundaryPoliciesResponse, PrincipalAccessBoundaryPolicy> response = principalAccessBoundaryPoliciesClient.ListPrincipalAccessBoundaryPolicies(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (PrincipalAccessBoundaryPolicy 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 (ListPrincipalAccessBoundaryPoliciesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (PrincipalAccessBoundaryPolicy 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<PrincipalAccessBoundaryPolicy> 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 (PrincipalAccessBoundaryPolicy 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
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
ListPrincipalAccessBoundaryPoliciesRequest request = new ListPrincipalAccessBoundaryPoliciesRequest
{
    ParentAsOrganizationLocationName = OrganizationLocationName.FromOrganizationLocation("[ORGANIZATION]", "[LOCATION]"),
};
// Make the request
PagedAsyncEnumerable<ListPrincipalAccessBoundaryPoliciesResponse, PrincipalAccessBoundaryPolicy> response = principalAccessBoundaryPoliciesClient.ListPrincipalAccessBoundaryPoliciesAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((PrincipalAccessBoundaryPolicy 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((ListPrincipalAccessBoundaryPoliciesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (PrincipalAccessBoundaryPolicy 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<PrincipalAccessBoundaryPolicy> 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 (PrincipalAccessBoundaryPolicy 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
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
OrganizationLocationName parent = OrganizationLocationName.FromOrganizationLocation("[ORGANIZATION]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListPrincipalAccessBoundaryPoliciesResponse, PrincipalAccessBoundaryPolicy> response = principalAccessBoundaryPoliciesClient.ListPrincipalAccessBoundaryPoliciesAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((PrincipalAccessBoundaryPolicy 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((ListPrincipalAccessBoundaryPoliciesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (PrincipalAccessBoundaryPolicy 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<PrincipalAccessBoundaryPolicy> 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 (PrincipalAccessBoundaryPolicy 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
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
string parent = "organizations/[ORGANIZATION]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListPrincipalAccessBoundaryPoliciesResponse, PrincipalAccessBoundaryPolicy> response = principalAccessBoundaryPoliciesClient.ListPrincipalAccessBoundaryPoliciesAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((PrincipalAccessBoundaryPolicy 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((ListPrincipalAccessBoundaryPoliciesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (PrincipalAccessBoundaryPolicy 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<PrincipalAccessBoundaryPolicy> 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 (PrincipalAccessBoundaryPolicy 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
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = PrincipalAccessBoundaryPoliciesClient.Create();
// Initialize request argument(s)
PrincipalAccessBoundaryPolicyName name = PrincipalAccessBoundaryPolicyName.FromOrganizationLocationPrincipalAccessBoundaryPolicy("[ORGANIZATION]", "[LOCATION]", "[PRINCIPAL_ACCESS_BOUNDARY_POLICY]");
// Make the request
PagedEnumerable<SearchPrincipalAccessBoundaryPolicyBindingsResponse, PolicyBinding> response = principalAccessBoundaryPoliciesClient.SearchPrincipalAccessBoundaryPolicyBindings(name);

// Iterate over all response items, lazily performing RPCs as required
foreach (PolicyBinding 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 (SearchPrincipalAccessBoundaryPolicyBindingsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (PolicyBinding 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<PolicyBinding> 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 (PolicyBinding 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
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = PrincipalAccessBoundaryPoliciesClient.Create();
// Initialize request argument(s)
SearchPrincipalAccessBoundaryPolicyBindingsRequest request = new SearchPrincipalAccessBoundaryPolicyBindingsRequest
{
    PrincipalAccessBoundaryPolicyName = PrincipalAccessBoundaryPolicyName.FromOrganizationLocationPrincipalAccessBoundaryPolicy("[ORGANIZATION]", "[LOCATION]", "[PRINCIPAL_ACCESS_BOUNDARY_POLICY]"),
};
// Make the request
PagedEnumerable<SearchPrincipalAccessBoundaryPolicyBindingsResponse, PolicyBinding> response = principalAccessBoundaryPoliciesClient.SearchPrincipalAccessBoundaryPolicyBindings(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (PolicyBinding 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 (SearchPrincipalAccessBoundaryPolicyBindingsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (PolicyBinding 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<PolicyBinding> 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 (PolicyBinding 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
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = PrincipalAccessBoundaryPoliciesClient.Create();
// Initialize request argument(s)
string name = "organizations/[ORGANIZATION]/locations/[LOCATION]/principalAccessBoundaryPolicies/[PRINCIPAL_ACCESS_BOUNDARY_POLICY]";
// Make the request
PagedEnumerable<SearchPrincipalAccessBoundaryPolicyBindingsResponse, PolicyBinding> response = principalAccessBoundaryPoliciesClient.SearchPrincipalAccessBoundaryPolicyBindings(name);

// Iterate over all response items, lazily performing RPCs as required
foreach (PolicyBinding 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 (SearchPrincipalAccessBoundaryPolicyBindingsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (PolicyBinding 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<PolicyBinding> 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 (PolicyBinding 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
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
PrincipalAccessBoundaryPolicyName name = PrincipalAccessBoundaryPolicyName.FromOrganizationLocationPrincipalAccessBoundaryPolicy("[ORGANIZATION]", "[LOCATION]", "[PRINCIPAL_ACCESS_BOUNDARY_POLICY]");
// Make the request
PagedAsyncEnumerable<SearchPrincipalAccessBoundaryPolicyBindingsResponse, PolicyBinding> response = principalAccessBoundaryPoliciesClient.SearchPrincipalAccessBoundaryPolicyBindingsAsync(name);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((PolicyBinding 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((SearchPrincipalAccessBoundaryPolicyBindingsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (PolicyBinding 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<PolicyBinding> 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 (PolicyBinding 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
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
SearchPrincipalAccessBoundaryPolicyBindingsRequest request = new SearchPrincipalAccessBoundaryPolicyBindingsRequest
{
    PrincipalAccessBoundaryPolicyName = PrincipalAccessBoundaryPolicyName.FromOrganizationLocationPrincipalAccessBoundaryPolicy("[ORGANIZATION]", "[LOCATION]", "[PRINCIPAL_ACCESS_BOUNDARY_POLICY]"),
};
// Make the request
PagedAsyncEnumerable<SearchPrincipalAccessBoundaryPolicyBindingsResponse, PolicyBinding> response = principalAccessBoundaryPoliciesClient.SearchPrincipalAccessBoundaryPolicyBindingsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((PolicyBinding 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((SearchPrincipalAccessBoundaryPolicyBindingsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (PolicyBinding 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<PolicyBinding> 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 (PolicyBinding 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
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
string name = "organizations/[ORGANIZATION]/locations/[LOCATION]/principalAccessBoundaryPolicies/[PRINCIPAL_ACCESS_BOUNDARY_POLICY]";
// Make the request
PagedAsyncEnumerable<SearchPrincipalAccessBoundaryPolicyBindingsResponse, PolicyBinding> response = principalAccessBoundaryPoliciesClient.SearchPrincipalAccessBoundaryPolicyBindingsAsync(name);

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

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

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

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = PrincipalAccessBoundaryPoliciesClient.Create();
// Initialize request argument(s)
UpdatePrincipalAccessBoundaryPolicyRequest request = new UpdatePrincipalAccessBoundaryPolicyRequest
{
    PrincipalAccessBoundaryPolicy = new PrincipalAccessBoundaryPolicy(),
    ValidateOnly = false,
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<PrincipalAccessBoundaryPolicy, OperationMetadata> response = principalAccessBoundaryPoliciesClient.UpdatePrincipalAccessBoundaryPolicy(request);

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

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

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
PrincipalAccessBoundaryPolicy principalAccessBoundaryPolicy = new PrincipalAccessBoundaryPolicy();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<PrincipalAccessBoundaryPolicy, OperationMetadata> response = await principalAccessBoundaryPoliciesClient.UpdatePrincipalAccessBoundaryPolicyAsync(principalAccessBoundaryPolicy, updateMask);

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

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

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
PrincipalAccessBoundaryPolicy principalAccessBoundaryPolicy = new PrincipalAccessBoundaryPolicy();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<PrincipalAccessBoundaryPolicy, OperationMetadata> response = await principalAccessBoundaryPoliciesClient.UpdatePrincipalAccessBoundaryPolicyAsync(principalAccessBoundaryPolicy, updateMask);

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

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

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
UpdatePrincipalAccessBoundaryPolicyRequest request = new UpdatePrincipalAccessBoundaryPolicyRequest
{
    PrincipalAccessBoundaryPolicy = new PrincipalAccessBoundaryPolicy(),
    ValidateOnly = false,
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<PrincipalAccessBoundaryPolicy, OperationMetadata> response = await principalAccessBoundaryPoliciesClient.UpdatePrincipalAccessBoundaryPolicyAsync(request);

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

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

// Create client
PrincipalAccessBoundaryPoliciesClient principalAccessBoundaryPoliciesClient = await PrincipalAccessBoundaryPoliciesClient.CreateAsync();
// Initialize request argument(s)
UpdatePrincipalAccessBoundaryPolicyRequest request = new UpdatePrincipalAccessBoundaryPolicyRequest
{
    PrincipalAccessBoundaryPolicy = new PrincipalAccessBoundaryPolicy(),
    ValidateOnly = false,
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<PrincipalAccessBoundaryPolicy, OperationMetadata> response = await principalAccessBoundaryPoliciesClient.UpdatePrincipalAccessBoundaryPolicyAsync(request);

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

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