Privileged Access Manager v1 API - Class PrivilegedAccessManagerClient (1.0.0)

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
ApproveGrantRequest request = new ApproveGrantRequest
{
    GrantName = GrantName.FromProjectLocationEntitlementGrant("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]", "[GRANT]"),
    Reason = "",
};
// Make the request
Grant response = privilegedAccessManagerClient.ApproveGrant(request);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
ApproveGrantRequest request = new ApproveGrantRequest
{
    GrantName = GrantName.FromProjectLocationEntitlementGrant("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]", "[GRANT]"),
    Reason = "",
};
// Make the request
Grant response = await privilegedAccessManagerClient.ApproveGrantAsync(request);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
ApproveGrantRequest request = new ApproveGrantRequest
{
    GrantName = GrantName.FromProjectLocationEntitlementGrant("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]", "[GRANT]"),
    Reason = "",
};
// Make the request
Grant response = await privilegedAccessManagerClient.ApproveGrantAsync(request);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
CheckOnboardingStatusRequest request = new CheckOnboardingStatusRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
CheckOnboardingStatusResponse response = privilegedAccessManagerClient.CheckOnboardingStatus(request);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
CheckOnboardingStatusRequest request = new CheckOnboardingStatusRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
CheckOnboardingStatusResponse response = await privilegedAccessManagerClient.CheckOnboardingStatusAsync(request);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
CheckOnboardingStatusRequest request = new CheckOnboardingStatusRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
CheckOnboardingStatusResponse response = await privilegedAccessManagerClient.CheckOnboardingStatusAsync(request);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Entitlement entitlement = new Entitlement();
string entitlementId = "";
// Make the request
Operation<Entitlement, OperationMetadata> response = privilegedAccessManagerClient.CreateEntitlement(parent, entitlement, entitlementId);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
CreateEntitlementRequest request = new CreateEntitlementRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    EntitlementId = "",
    Entitlement = new Entitlement(),
    RequestId = "",
};
// Make the request
Operation<Entitlement, OperationMetadata> response = privilegedAccessManagerClient.CreateEntitlement(request);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
FolderLocationName parent = FolderLocationName.FromFolderLocation("[FOLDER]", "[LOCATION]");
Entitlement entitlement = new Entitlement();
string entitlementId = "";
// Make the request
Operation<Entitlement, OperationMetadata> response = privilegedAccessManagerClient.CreateEntitlement(parent, entitlement, entitlementId);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
OrganizationLocationName parent = OrganizationLocationName.FromOrganizationLocation("[ORGANIZATION]", "[LOCATION]");
Entitlement entitlement = new Entitlement();
string entitlementId = "";
// Make the request
Operation<Entitlement, OperationMetadata> response = privilegedAccessManagerClient.CreateEntitlement(parent, entitlement, entitlementId);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Entitlement entitlement = new Entitlement();
string entitlementId = "";
// Make the request
Operation<Entitlement, OperationMetadata> response = privilegedAccessManagerClient.CreateEntitlement(parent, entitlement, entitlementId);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Entitlement entitlement = new Entitlement();
string entitlementId = "";
// Make the request
Operation<Entitlement, OperationMetadata> response = await privilegedAccessManagerClient.CreateEntitlementAsync(parent, entitlement, entitlementId);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Entitlement entitlement = new Entitlement();
string entitlementId = "";
// Make the request
Operation<Entitlement, OperationMetadata> response = await privilegedAccessManagerClient.CreateEntitlementAsync(parent, entitlement, entitlementId);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
CreateEntitlementRequest request = new CreateEntitlementRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    EntitlementId = "",
    Entitlement = new Entitlement(),
    RequestId = "",
};
// Make the request
Operation<Entitlement, OperationMetadata> response = await privilegedAccessManagerClient.CreateEntitlementAsync(request);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
CreateEntitlementRequest request = new CreateEntitlementRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    EntitlementId = "",
    Entitlement = new Entitlement(),
    RequestId = "",
};
// Make the request
Operation<Entitlement, OperationMetadata> response = await privilegedAccessManagerClient.CreateEntitlementAsync(request);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
FolderLocationName parent = FolderLocationName.FromFolderLocation("[FOLDER]", "[LOCATION]");
Entitlement entitlement = new Entitlement();
string entitlementId = "";
// Make the request
Operation<Entitlement, OperationMetadata> response = await privilegedAccessManagerClient.CreateEntitlementAsync(parent, entitlement, entitlementId);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
FolderLocationName parent = FolderLocationName.FromFolderLocation("[FOLDER]", "[LOCATION]");
Entitlement entitlement = new Entitlement();
string entitlementId = "";
// Make the request
Operation<Entitlement, OperationMetadata> response = await privilegedAccessManagerClient.CreateEntitlementAsync(parent, entitlement, entitlementId);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
OrganizationLocationName parent = OrganizationLocationName.FromOrganizationLocation("[ORGANIZATION]", "[LOCATION]");
Entitlement entitlement = new Entitlement();
string entitlementId = "";
// Make the request
Operation<Entitlement, OperationMetadata> response = await privilegedAccessManagerClient.CreateEntitlementAsync(parent, entitlement, entitlementId);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
OrganizationLocationName parent = OrganizationLocationName.FromOrganizationLocation("[ORGANIZATION]", "[LOCATION]");
Entitlement entitlement = new Entitlement();
string entitlementId = "";
// Make the request
Operation<Entitlement, OperationMetadata> response = await privilegedAccessManagerClient.CreateEntitlementAsync(parent, entitlement, entitlementId);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Entitlement entitlement = new Entitlement();
string entitlementId = "";
// Make the request
Operation<Entitlement, OperationMetadata> response = await privilegedAccessManagerClient.CreateEntitlementAsync(parent, entitlement, entitlementId);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Entitlement entitlement = new Entitlement();
string entitlementId = "";
// Make the request
Operation<Entitlement, OperationMetadata> response = await privilegedAccessManagerClient.CreateEntitlementAsync(parent, entitlement, entitlementId);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
CreateGrantRequest request = new CreateGrantRequest
{
    ParentAsEntitlementName = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]"),
    Grant = new Grant(),
    RequestId = "",
};
// Make the request
Grant response = privilegedAccessManagerClient.CreateGrant(request);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
EntitlementName parent = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]");
Grant grant = new Grant();
// Make the request
Grant response = privilegedAccessManagerClient.CreateGrant(parent, grant);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/entitlements/[ENTITLEMENT]";
Grant grant = new Grant();
// Make the request
Grant response = privilegedAccessManagerClient.CreateGrant(parent, grant);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
CreateGrantRequest request = new CreateGrantRequest
{
    ParentAsEntitlementName = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]"),
    Grant = new Grant(),
    RequestId = "",
};
// Make the request
Grant response = await privilegedAccessManagerClient.CreateGrantAsync(request);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
CreateGrantRequest request = new CreateGrantRequest
{
    ParentAsEntitlementName = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]"),
    Grant = new Grant(),
    RequestId = "",
};
// Make the request
Grant response = await privilegedAccessManagerClient.CreateGrantAsync(request);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
EntitlementName parent = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]");
Grant grant = new Grant();
// Make the request
Grant response = await privilegedAccessManagerClient.CreateGrantAsync(parent, grant);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
EntitlementName parent = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]");
Grant grant = new Grant();
// Make the request
Grant response = await privilegedAccessManagerClient.CreateGrantAsync(parent, grant);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/entitlements/[ENTITLEMENT]";
Grant grant = new Grant();
// Make the request
Grant response = await privilegedAccessManagerClient.CreateGrantAsync(parent, grant);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/entitlements/[ENTITLEMENT]";
Grant grant = new Grant();
// Make the request
Grant response = await privilegedAccessManagerClient.CreateGrantAsync(parent, grant);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
DeleteEntitlementRequest request = new DeleteEntitlementRequest
{
    EntitlementName = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Entitlement, OperationMetadata> response = privilegedAccessManagerClient.DeleteEntitlement(request);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
EntitlementName name = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]");
// Make the request
Operation<Entitlement, OperationMetadata> response = privilegedAccessManagerClient.DeleteEntitlement(name);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/entitlements/[ENTITLEMENT]";
// Make the request
Operation<Entitlement, OperationMetadata> response = privilegedAccessManagerClient.DeleteEntitlement(name);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
DeleteEntitlementRequest request = new DeleteEntitlementRequest
{
    EntitlementName = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Entitlement, OperationMetadata> response = await privilegedAccessManagerClient.DeleteEntitlementAsync(request);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
DeleteEntitlementRequest request = new DeleteEntitlementRequest
{
    EntitlementName = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Entitlement, OperationMetadata> response = await privilegedAccessManagerClient.DeleteEntitlementAsync(request);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
EntitlementName name = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]");
// Make the request
Operation<Entitlement, OperationMetadata> response = await privilegedAccessManagerClient.DeleteEntitlementAsync(name);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
EntitlementName name = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]");
// Make the request
Operation<Entitlement, OperationMetadata> response = await privilegedAccessManagerClient.DeleteEntitlementAsync(name);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/entitlements/[ENTITLEMENT]";
// Make the request
Operation<Entitlement, OperationMetadata> response = await privilegedAccessManagerClient.DeleteEntitlementAsync(name);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/entitlements/[ENTITLEMENT]";
// Make the request
Operation<Entitlement, OperationMetadata> response = await privilegedAccessManagerClient.DeleteEntitlementAsync(name);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
DenyGrantRequest request = new DenyGrantRequest
{
    GrantName = GrantName.FromProjectLocationEntitlementGrant("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]", "[GRANT]"),
    Reason = "",
};
// Make the request
Grant response = privilegedAccessManagerClient.DenyGrant(request);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
DenyGrantRequest request = new DenyGrantRequest
{
    GrantName = GrantName.FromProjectLocationEntitlementGrant("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]", "[GRANT]"),
    Reason = "",
};
// Make the request
Grant response = await privilegedAccessManagerClient.DenyGrantAsync(request);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
DenyGrantRequest request = new DenyGrantRequest
{
    GrantName = GrantName.FromProjectLocationEntitlementGrant("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]", "[GRANT]"),
    Reason = "",
};
// Make the request
Grant response = await privilegedAccessManagerClient.DenyGrantAsync(request);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
EntitlementName name = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]");
// Make the request
Entitlement response = privilegedAccessManagerClient.GetEntitlement(name);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
GetEntitlementRequest request = new GetEntitlementRequest
{
    EntitlementName = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]"),
};
// Make the request
Entitlement response = privilegedAccessManagerClient.GetEntitlement(request);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/entitlements/[ENTITLEMENT]";
// Make the request
Entitlement response = privilegedAccessManagerClient.GetEntitlement(name);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
EntitlementName name = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]");
// Make the request
Entitlement response = await privilegedAccessManagerClient.GetEntitlementAsync(name);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
EntitlementName name = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]");
// Make the request
Entitlement response = await privilegedAccessManagerClient.GetEntitlementAsync(name);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
GetEntitlementRequest request = new GetEntitlementRequest
{
    EntitlementName = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]"),
};
// Make the request
Entitlement response = await privilegedAccessManagerClient.GetEntitlementAsync(request);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
GetEntitlementRequest request = new GetEntitlementRequest
{
    EntitlementName = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]"),
};
// Make the request
Entitlement response = await privilegedAccessManagerClient.GetEntitlementAsync(request);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/entitlements/[ENTITLEMENT]";
// Make the request
Entitlement response = await privilegedAccessManagerClient.GetEntitlementAsync(name);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/entitlements/[ENTITLEMENT]";
// Make the request
Entitlement response = await privilegedAccessManagerClient.GetEntitlementAsync(name);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
GetGrantRequest request = new GetGrantRequest
{
    GrantName = GrantName.FromProjectLocationEntitlementGrant("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]", "[GRANT]"),
};
// Make the request
Grant response = privilegedAccessManagerClient.GetGrant(request);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
GrantName name = GrantName.FromProjectLocationEntitlementGrant("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]", "[GRANT]");
// Make the request
Grant response = privilegedAccessManagerClient.GetGrant(name);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/entitlements/[ENTITLEMENT]/grants/[GRANT]";
// Make the request
Grant response = privilegedAccessManagerClient.GetGrant(name);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
GetGrantRequest request = new GetGrantRequest
{
    GrantName = GrantName.FromProjectLocationEntitlementGrant("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]", "[GRANT]"),
};
// Make the request
Grant response = await privilegedAccessManagerClient.GetGrantAsync(request);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
GetGrantRequest request = new GetGrantRequest
{
    GrantName = GrantName.FromProjectLocationEntitlementGrant("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]", "[GRANT]"),
};
// Make the request
Grant response = await privilegedAccessManagerClient.GetGrantAsync(request);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
GrantName name = GrantName.FromProjectLocationEntitlementGrant("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]", "[GRANT]");
// Make the request
Grant response = await privilegedAccessManagerClient.GetGrantAsync(name);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
GrantName name = GrantName.FromProjectLocationEntitlementGrant("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]", "[GRANT]");
// Make the request
Grant response = await privilegedAccessManagerClient.GetGrantAsync(name);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/entitlements/[ENTITLEMENT]/grants/[GRANT]";
// Make the request
Grant response = await privilegedAccessManagerClient.GetGrantAsync(name);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/entitlements/[ENTITLEMENT]/grants/[GRANT]";
// Make the request
Grant response = await privilegedAccessManagerClient.GetGrantAsync(name);

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListEntitlementsResponse, Entitlement> response = privilegedAccessManagerClient.ListEntitlements(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Entitlement 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 (ListEntitlementsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Entitlement 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<Entitlement> 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 (Entitlement 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
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
FolderLocationName parent = FolderLocationName.FromFolderLocation("[FOLDER]", "[LOCATION]");
// Make the request
PagedEnumerable<ListEntitlementsResponse, Entitlement> response = privilegedAccessManagerClient.ListEntitlements(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Entitlement 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 (ListEntitlementsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Entitlement 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<Entitlement> 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 (Entitlement 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
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
ListEntitlementsRequest request = new ListEntitlementsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<ListEntitlementsResponse, Entitlement> response = privilegedAccessManagerClient.ListEntitlements(request);

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

// Iterate over all response items, lazily performing RPCs as required
foreach (Entitlement 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 (ListEntitlementsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Entitlement 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<Entitlement> 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 (Entitlement 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
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListEntitlementsResponse, Entitlement> response = privilegedAccessManagerClient.ListEntitlements(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Entitlement 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 (ListEntitlementsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Entitlement 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<Entitlement> 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 (Entitlement 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
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListEntitlementsResponse, Entitlement> response = privilegedAccessManagerClient.ListEntitlementsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Entitlement 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((ListEntitlementsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Entitlement 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<Entitlement> 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 (Entitlement 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
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
FolderLocationName parent = FolderLocationName.FromFolderLocation("[FOLDER]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListEntitlementsResponse, Entitlement> response = privilegedAccessManagerClient.ListEntitlementsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Entitlement 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((ListEntitlementsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Entitlement 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<Entitlement> 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 (Entitlement 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
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
ListEntitlementsRequest request = new ListEntitlementsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<ListEntitlementsResponse, Entitlement> response = privilegedAccessManagerClient.ListEntitlementsAsync(request);

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

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Entitlement 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((ListEntitlementsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Entitlement 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<Entitlement> 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 (Entitlement 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
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListEntitlementsResponse, Entitlement> response = privilegedAccessManagerClient.ListEntitlementsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Entitlement 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((ListEntitlementsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Entitlement 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<Entitlement> 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 (Entitlement 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
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
EntitlementName parent = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]");
// Make the request
PagedEnumerable<ListGrantsResponse, Grant> response = privilegedAccessManagerClient.ListGrants(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Grant 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 (ListGrantsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Grant 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<Grant> 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 (Grant 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
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
ListGrantsRequest request = new ListGrantsRequest
{
    ParentAsEntitlementName = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<ListGrantsResponse, Grant> response = privilegedAccessManagerClient.ListGrants(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (Grant 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 (ListGrantsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Grant 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<Grant> 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 (Grant 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
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/entitlements/[ENTITLEMENT]";
// Make the request
PagedEnumerable<ListGrantsResponse, Grant> response = privilegedAccessManagerClient.ListGrants(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (Grant 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 (ListGrantsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Grant 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<Grant> 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 (Grant 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
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
EntitlementName parent = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]");
// Make the request
PagedAsyncEnumerable<ListGrantsResponse, Grant> response = privilegedAccessManagerClient.ListGrantsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Grant 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((ListGrantsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Grant 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<Grant> 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 (Grant 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
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
ListGrantsRequest request = new ListGrantsRequest
{
    ParentAsEntitlementName = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<ListGrantsResponse, Grant> response = privilegedAccessManagerClient.ListGrantsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Grant 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((ListGrantsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Grant 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<Grant> 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 (Grant 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
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/entitlements/[ENTITLEMENT]";
// Make the request
PagedAsyncEnumerable<ListGrantsResponse, Grant> response = privilegedAccessManagerClient.ListGrantsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Grant 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((ListGrantsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Grant 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<Grant> 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 (Grant 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
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
RevokeGrantRequest request = new RevokeGrantRequest
{
    GrantName = GrantName.FromProjectLocationEntitlementGrant("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]", "[GRANT]"),
    Reason = "",
};
// Make the request
Operation<Grant, OperationMetadata> response = privilegedAccessManagerClient.RevokeGrant(request);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
RevokeGrantRequest request = new RevokeGrantRequest
{
    GrantName = GrantName.FromProjectLocationEntitlementGrant("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]", "[GRANT]"),
    Reason = "",
};
// Make the request
Operation<Grant, OperationMetadata> response = await privilegedAccessManagerClient.RevokeGrantAsync(request);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
RevokeGrantRequest request = new RevokeGrantRequest
{
    GrantName = GrantName.FromProjectLocationEntitlementGrant("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]", "[GRANT]"),
    Reason = "",
};
// Make the request
Operation<Grant, OperationMetadata> response = await privilegedAccessManagerClient.RevokeGrantAsync(request);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
SearchEntitlementsRequest request = new SearchEntitlementsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    CallerAccessType = SearchEntitlementsRequest.Types.CallerAccessType.Unspecified,
    Filter = "",
};
// Make the request
PagedEnumerable<SearchEntitlementsResponse, Entitlement> response = privilegedAccessManagerClient.SearchEntitlements(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (Entitlement 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 (SearchEntitlementsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Entitlement 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<Entitlement> 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 (Entitlement 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
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
SearchEntitlementsRequest request = new SearchEntitlementsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    CallerAccessType = SearchEntitlementsRequest.Types.CallerAccessType.Unspecified,
    Filter = "",
};
// Make the request
PagedAsyncEnumerable<SearchEntitlementsResponse, Entitlement> response = privilegedAccessManagerClient.SearchEntitlementsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Entitlement 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((SearchEntitlementsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Entitlement 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<Entitlement> 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 (Entitlement 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
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
SearchGrantsRequest request = new SearchGrantsRequest
{
    ParentAsEntitlementName = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]"),
    CallerRelationship = SearchGrantsRequest.Types.CallerRelationshipType.Unspecified,
    Filter = "",
};
// Make the request
PagedEnumerable<SearchGrantsResponse, Grant> response = privilegedAccessManagerClient.SearchGrants(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (Grant 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 (SearchGrantsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Grant 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<Grant> 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 (Grant 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
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
SearchGrantsRequest request = new SearchGrantsRequest
{
    ParentAsEntitlementName = EntitlementName.FromProjectLocationEntitlement("[PROJECT]", "[LOCATION]", "[ENTITLEMENT]"),
    CallerRelationship = SearchGrantsRequest.Types.CallerRelationshipType.Unspecified,
    Filter = "",
};
// Make the request
PagedAsyncEnumerable<SearchGrantsResponse, Grant> response = privilegedAccessManagerClient.SearchGrantsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((Grant 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((SearchGrantsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (Grant 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<Grant> 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 (Grant 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
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
Entitlement entitlement = new Entitlement();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Entitlement, OperationMetadata> response = privilegedAccessManagerClient.UpdateEntitlement(entitlement, updateMask);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = PrivilegedAccessManagerClient.Create();
// Initialize request argument(s)
UpdateEntitlementRequest request = new UpdateEntitlementRequest
{
    Entitlement = new Entitlement(),
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<Entitlement, OperationMetadata> response = privilegedAccessManagerClient.UpdateEntitlement(request);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
Entitlement entitlement = new Entitlement();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Entitlement, OperationMetadata> response = await privilegedAccessManagerClient.UpdateEntitlementAsync(entitlement, updateMask);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
Entitlement entitlement = new Entitlement();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<Entitlement, OperationMetadata> response = await privilegedAccessManagerClient.UpdateEntitlementAsync(entitlement, updateMask);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
UpdateEntitlementRequest request = new UpdateEntitlementRequest
{
    Entitlement = new Entitlement(),
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<Entitlement, OperationMetadata> response = await privilegedAccessManagerClient.UpdateEntitlementAsync(request);

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

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

// Create client
PrivilegedAccessManagerClient privilegedAccessManagerClient = await PrivilegedAccessManagerClient.CreateAsync();
// Initialize request argument(s)
UpdateEntitlementRequest request = new UpdateEntitlementRequest
{
    Entitlement = new Entitlement(),
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<Entitlement, OperationMetadata> response = await privilegedAccessManagerClient.UpdateEntitlementAsync(request);

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

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