Class AccessContextManagerClient (1.4.0)

public abstract class AccessContextManagerClient

Namespace

Assembly

Google.Identity.AccessContextManager.V1.dll

Remarks

Properties

CommitServicePerimetersOperationsClient

public virtual OperationsClient CommitServicePerimetersOperationsClient { get; }

CreateAccessLevelOperationsClient

public virtual OperationsClient CreateAccessLevelOperationsClient { get; }

CreateAccessPolicyOperationsClient

public virtual OperationsClient CreateAccessPolicyOperationsClient { get; }

CreateGcpUserAccessBindingOperationsClient

public virtual OperationsClient CreateGcpUserAccessBindingOperationsClient { get; }

CreateServicePerimeterOperationsClient

public virtual OperationsClient CreateServicePerimeterOperationsClient { get; }

DefaultEndpoint

public static string DefaultEndpoint { get; }

DefaultScopes

public static IReadOnlyList<string> DefaultScopes { get; }

DeleteAccessLevelOperationsClient

public virtual OperationsClient DeleteAccessLevelOperationsClient { get; }

DeleteAccessPolicyOperationsClient

public virtual OperationsClient DeleteAccessPolicyOperationsClient { get; }

DeleteGcpUserAccessBindingOperationsClient

public virtual OperationsClient DeleteGcpUserAccessBindingOperationsClient { get; }

DeleteServicePerimeterOperationsClient

public virtual OperationsClient DeleteServicePerimeterOperationsClient { get; }

GrpcClient

public virtual AccessContextManager.AccessContextManagerClient GrpcClient { get; }

ReplaceAccessLevelsOperationsClient

public virtual OperationsClient ReplaceAccessLevelsOperationsClient { get; }

ReplaceServicePerimetersOperationsClient

public virtual OperationsClient ReplaceServicePerimetersOperationsClient { get; }

UpdateAccessLevelOperationsClient

public virtual OperationsClient UpdateAccessLevelOperationsClient { get; }

UpdateAccessPolicyOperationsClient

public virtual OperationsClient UpdateAccessPolicyOperationsClient { get; }

UpdateGcpUserAccessBindingOperationsClient

public virtual OperationsClient UpdateGcpUserAccessBindingOperationsClient { get; }

UpdateServicePerimeterOperationsClient

public virtual OperationsClient UpdateServicePerimeterOperationsClient { get; }

Methods

CommitServicePerimeters(CommitServicePerimetersRequest, CallSettings)

public virtual Operation<CommitServicePerimetersResponse, AccessContextManagerOperationMetadata> CommitServicePerimeters(CommitServicePerimetersRequest request, CallSettings callSettings = null)

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

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

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

CommitServicePerimetersAsync(CommitServicePerimetersRequest, CallSettings)

public virtual Task<Operation<CommitServicePerimetersResponse, AccessContextManagerOperationMetadata>> CommitServicePerimetersAsync(CommitServicePerimetersRequest request, CallSettings callSettings = null)

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

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

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

CommitServicePerimetersAsync(CommitServicePerimetersRequest, CancellationToken)

public virtual Task<Operation<CommitServicePerimetersResponse, AccessContextManagerOperationMetadata>> CommitServicePerimetersAsync(CommitServicePerimetersRequest request, CancellationToken cancellationToken)

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

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

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

Create()

public static AccessContextManagerClient Create()

CreateAccessLevel(AccessPolicyName, AccessLevel, CallSettings)

public virtual Operation<AccessLevel, AccessContextManagerOperationMetadata> CreateAccessLevel(AccessPolicyName parent, AccessLevel accessLevel, CallSettings callSettings = null)

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

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

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

CreateAccessLevel(CreateAccessLevelRequest, CallSettings)

public virtual Operation<AccessLevel, AccessContextManagerOperationMetadata> CreateAccessLevel(CreateAccessLevelRequest request, CallSettings callSettings = null)

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

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

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

CreateAccessLevel(String, AccessLevel, CallSettings)

public virtual Operation<AccessLevel, AccessContextManagerOperationMetadata> CreateAccessLevel(string parent, AccessLevel accessLevel, CallSettings callSettings = null)

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

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

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

CreateAccessLevelAsync(AccessPolicyName, AccessLevel, CallSettings)

public virtual Task<Operation<AccessLevel, AccessContextManagerOperationMetadata>> CreateAccessLevelAsync(AccessPolicyName parent, AccessLevel accessLevel, CallSettings callSettings = null)

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

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

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

CreateAccessLevelAsync(AccessPolicyName, AccessLevel, CancellationToken)

public virtual Task<Operation<AccessLevel, AccessContextManagerOperationMetadata>> CreateAccessLevelAsync(AccessPolicyName parent, AccessLevel accessLevel, CancellationToken cancellationToken)

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

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

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

CreateAccessLevelAsync(CreateAccessLevelRequest, CallSettings)

public virtual Task<Operation<AccessLevel, AccessContextManagerOperationMetadata>> CreateAccessLevelAsync(CreateAccessLevelRequest request, CallSettings callSettings = null)

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

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

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

CreateAccessLevelAsync(CreateAccessLevelRequest, CancellationToken)

public virtual Task<Operation<AccessLevel, AccessContextManagerOperationMetadata>> CreateAccessLevelAsync(CreateAccessLevelRequest request, CancellationToken cancellationToken)

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

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

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

CreateAccessLevelAsync(String, AccessLevel, CallSettings)

public virtual Task<Operation<AccessLevel, AccessContextManagerOperationMetadata>> CreateAccessLevelAsync(string parent, AccessLevel accessLevel, CallSettings callSettings = null)

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

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

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

CreateAccessLevelAsync(String, AccessLevel, CancellationToken)

public virtual Task<Operation<AccessLevel, AccessContextManagerOperationMetadata>> CreateAccessLevelAsync(string parent, AccessLevel accessLevel, CancellationToken cancellationToken)

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

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

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

CreateAccessPolicy(AccessPolicy, CallSettings)

public virtual Operation<AccessPolicy, AccessContextManagerOperationMetadata> CreateAccessPolicy(AccessPolicy request, CallSettings callSettings = null)

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

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

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

CreateAccessPolicyAsync(AccessPolicy, CallSettings)

public virtual Task<Operation<AccessPolicy, AccessContextManagerOperationMetadata>> CreateAccessPolicyAsync(AccessPolicy request, CallSettings callSettings = null)

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

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

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

CreateAccessPolicyAsync(AccessPolicy, CancellationToken)

public virtual Task<Operation<AccessPolicy, AccessContextManagerOperationMetadata>> CreateAccessPolicyAsync(AccessPolicy request, CancellationToken cancellationToken)

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

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

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

CreateAsync(CancellationToken)

public static Task<AccessContextManagerClient> CreateAsync(CancellationToken cancellationToken = default(CancellationToken))

CreateGcpUserAccessBinding(OrganizationName, GcpUserAccessBinding, CallSettings)

public virtual Operation<GcpUserAccessBinding, GcpUserAccessBindingOperationMetadata> CreateGcpUserAccessBinding(OrganizationName parent, GcpUserAccessBinding gcpUserAccessBinding, CallSettings callSettings = null)

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

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

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

CreateGcpUserAccessBinding(CreateGcpUserAccessBindingRequest, CallSettings)

public virtual Operation<GcpUserAccessBinding, GcpUserAccessBindingOperationMetadata> CreateGcpUserAccessBinding(CreateGcpUserAccessBindingRequest request, CallSettings callSettings = null)

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

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

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

CreateGcpUserAccessBinding(String, GcpUserAccessBinding, CallSettings)

public virtual Operation<GcpUserAccessBinding, GcpUserAccessBindingOperationMetadata> CreateGcpUserAccessBinding(string parent, GcpUserAccessBinding gcpUserAccessBinding, CallSettings callSettings = null)

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

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

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

CreateGcpUserAccessBindingAsync(OrganizationName, GcpUserAccessBinding, CallSettings)

public virtual Task<Operation<GcpUserAccessBinding, GcpUserAccessBindingOperationMetadata>> CreateGcpUserAccessBindingAsync(OrganizationName parent, GcpUserAccessBinding gcpUserAccessBinding, CallSettings callSettings = null)

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

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

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

CreateGcpUserAccessBindingAsync(OrganizationName, GcpUserAccessBinding, CancellationToken)

public virtual Task<Operation<GcpUserAccessBinding, GcpUserAccessBindingOperationMetadata>> CreateGcpUserAccessBindingAsync(OrganizationName parent, GcpUserAccessBinding gcpUserAccessBinding, CancellationToken cancellationToken)

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

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

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

CreateGcpUserAccessBindingAsync(CreateGcpUserAccessBindingRequest, CallSettings)

public virtual Task<Operation<GcpUserAccessBinding, GcpUserAccessBindingOperationMetadata>> CreateGcpUserAccessBindingAsync(CreateGcpUserAccessBindingRequest request, CallSettings callSettings = null)

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

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

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

CreateGcpUserAccessBindingAsync(CreateGcpUserAccessBindingRequest, CancellationToken)

public virtual Task<Operation<GcpUserAccessBinding, GcpUserAccessBindingOperationMetadata>> CreateGcpUserAccessBindingAsync(CreateGcpUserAccessBindingRequest request, CancellationToken cancellationToken)

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

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

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

CreateGcpUserAccessBindingAsync(String, GcpUserAccessBinding, CallSettings)

public virtual Task<Operation<GcpUserAccessBinding, GcpUserAccessBindingOperationMetadata>> CreateGcpUserAccessBindingAsync(string parent, GcpUserAccessBinding gcpUserAccessBinding, CallSettings callSettings = null)

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

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

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

CreateGcpUserAccessBindingAsync(String, GcpUserAccessBinding, CancellationToken)

public virtual Task<Operation<GcpUserAccessBinding, GcpUserAccessBindingOperationMetadata>> CreateGcpUserAccessBindingAsync(string parent, GcpUserAccessBinding gcpUserAccessBinding, CancellationToken cancellationToken)

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

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

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

CreateServicePerimeter(AccessPolicyName, ServicePerimeter, CallSettings)

public virtual Operation<ServicePerimeter, AccessContextManagerOperationMetadata> CreateServicePerimeter(AccessPolicyName parent, ServicePerimeter servicePerimeter, CallSettings callSettings = null)

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

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

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

CreateServicePerimeter(CreateServicePerimeterRequest, CallSettings)

public virtual Operation<ServicePerimeter, AccessContextManagerOperationMetadata> CreateServicePerimeter(CreateServicePerimeterRequest request, CallSettings callSettings = null)

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

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

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

CreateServicePerimeter(String, ServicePerimeter, CallSettings)

public virtual Operation<ServicePerimeter, AccessContextManagerOperationMetadata> CreateServicePerimeter(string parent, ServicePerimeter servicePerimeter, CallSettings callSettings = null)

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

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

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

CreateServicePerimeterAsync(AccessPolicyName, ServicePerimeter, CallSettings)

public virtual Task<Operation<ServicePerimeter, AccessContextManagerOperationMetadata>> CreateServicePerimeterAsync(AccessPolicyName parent, ServicePerimeter servicePerimeter, CallSettings callSettings = null)

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

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

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

CreateServicePerimeterAsync(AccessPolicyName, ServicePerimeter, CancellationToken)

public virtual Task<Operation<ServicePerimeter, AccessContextManagerOperationMetadata>> CreateServicePerimeterAsync(AccessPolicyName parent, ServicePerimeter servicePerimeter, CancellationToken cancellationToken)

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

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

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

CreateServicePerimeterAsync(CreateServicePerimeterRequest, CallSettings)

public virtual Task<Operation<ServicePerimeter, AccessContextManagerOperationMetadata>> CreateServicePerimeterAsync(CreateServicePerimeterRequest request, CallSettings callSettings = null)

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

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

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

CreateServicePerimeterAsync(CreateServicePerimeterRequest, CancellationToken)

public virtual Task<Operation<ServicePerimeter, AccessContextManagerOperationMetadata>> CreateServicePerimeterAsync(CreateServicePerimeterRequest request, CancellationToken cancellationToken)

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

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

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

CreateServicePerimeterAsync(String, ServicePerimeter, CallSettings)

public virtual Task<Operation<ServicePerimeter, AccessContextManagerOperationMetadata>> CreateServicePerimeterAsync(string parent, ServicePerimeter servicePerimeter, CallSettings callSettings = null)

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

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

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

CreateServicePerimeterAsync(String, ServicePerimeter, CancellationToken)

public virtual Task<Operation<ServicePerimeter, AccessContextManagerOperationMetadata>> CreateServicePerimeterAsync(string parent, ServicePerimeter servicePerimeter, CancellationToken cancellationToken)

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

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

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

DeleteAccessLevel(AccessLevelName, CallSettings)

public virtual Operation<Empty, AccessContextManagerOperationMetadata> DeleteAccessLevel(AccessLevelName name, CallSettings callSettings = null)

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

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

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

DeleteAccessLevel(DeleteAccessLevelRequest, CallSettings)

public virtual Operation<Empty, AccessContextManagerOperationMetadata> DeleteAccessLevel(DeleteAccessLevelRequest request, CallSettings callSettings = null)

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

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

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

DeleteAccessLevel(String, CallSettings)

public virtual Operation<Empty, AccessContextManagerOperationMetadata> DeleteAccessLevel(string name, CallSettings callSettings = null)

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

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

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

DeleteAccessLevelAsync(AccessLevelName, CallSettings)

public virtual Task<Operation<Empty, AccessContextManagerOperationMetadata>> DeleteAccessLevelAsync(AccessLevelName name, CallSettings callSettings = null)

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

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

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

DeleteAccessLevelAsync(AccessLevelName, CancellationToken)

public virtual Task<Operation<Empty, AccessContextManagerOperationMetadata>> DeleteAccessLevelAsync(AccessLevelName name, CancellationToken cancellationToken)

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

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

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

DeleteAccessLevelAsync(DeleteAccessLevelRequest, CallSettings)

public virtual Task<Operation<Empty, AccessContextManagerOperationMetadata>> DeleteAccessLevelAsync(DeleteAccessLevelRequest request, CallSettings callSettings = null)

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
DeleteAccessLevelRequest request = new DeleteAccessLevelRequest
{
    AccessLevelName = AccessLevelName.FromAccessPolicyAccessLevel("[ACCESS_POLICY]", "[ACCESS_LEVEL]"),
};
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteAccessLevelAsync(request);

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

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

DeleteAccessLevelAsync(DeleteAccessLevelRequest, CancellationToken)

public virtual Task<Operation<Empty, AccessContextManagerOperationMetadata>> DeleteAccessLevelAsync(DeleteAccessLevelRequest request, CancellationToken cancellationToken)

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
DeleteAccessLevelRequest request = new DeleteAccessLevelRequest
{
    AccessLevelName = AccessLevelName.FromAccessPolicyAccessLevel("[ACCESS_POLICY]", "[ACCESS_LEVEL]"),
};
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteAccessLevelAsync(request);

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

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

DeleteAccessLevelAsync(String, CallSettings)

public virtual Task<Operation<Empty, AccessContextManagerOperationMetadata>> DeleteAccessLevelAsync(string name, CallSettings callSettings = null)

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]/accessLevels/[ACCESS_LEVEL]";
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteAccessLevelAsync(name);

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

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

DeleteAccessLevelAsync(String, CancellationToken)

public virtual Task<Operation<Empty, AccessContextManagerOperationMetadata>> DeleteAccessLevelAsync(string name, CancellationToken cancellationToken)

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]/accessLevels/[ACCESS_LEVEL]";
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteAccessLevelAsync(name);

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

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

DeleteAccessPolicy(AccessPolicyName, CallSettings)

public virtual Operation<Empty, AccessContextManagerOperationMetadata> DeleteAccessPolicy(AccessPolicyName name, CallSettings callSettings = null)

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

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

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

DeleteAccessPolicy(DeleteAccessPolicyRequest, CallSettings)

public virtual Operation<Empty, AccessContextManagerOperationMetadata> DeleteAccessPolicy(DeleteAccessPolicyRequest request, CallSettings callSettings = null)

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

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

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

DeleteAccessPolicy(String, CallSettings)

public virtual Operation<Empty, AccessContextManagerOperationMetadata> DeleteAccessPolicy(string name, CallSettings callSettings = null)

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

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

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

DeleteAccessPolicyAsync(AccessPolicyName, CallSettings)

public virtual Task<Operation<Empty, AccessContextManagerOperationMetadata>> DeleteAccessPolicyAsync(AccessPolicyName name, CallSettings callSettings = null)

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
AccessPolicyName name = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]");
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteAccessPolicyAsync(name);

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

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

DeleteAccessPolicyAsync(AccessPolicyName, CancellationToken)

public virtual Task<Operation<Empty, AccessContextManagerOperationMetadata>> DeleteAccessPolicyAsync(AccessPolicyName name, CancellationToken cancellationToken)

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
AccessPolicyName name = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]");
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteAccessPolicyAsync(name);

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

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

DeleteAccessPolicyAsync(DeleteAccessPolicyRequest, CallSettings)

public virtual Task<Operation<Empty, AccessContextManagerOperationMetadata>> DeleteAccessPolicyAsync(DeleteAccessPolicyRequest request, CallSettings callSettings = null)

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

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

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

DeleteAccessPolicyAsync(DeleteAccessPolicyRequest, CancellationToken)

public virtual Task<Operation<Empty, AccessContextManagerOperationMetadata>> DeleteAccessPolicyAsync(DeleteAccessPolicyRequest request, CancellationToken cancellationToken)

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

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

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

DeleteAccessPolicyAsync(String, CallSettings)

public virtual Task<Operation<Empty, AccessContextManagerOperationMetadata>> DeleteAccessPolicyAsync(string name, CallSettings callSettings = null)

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]";
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteAccessPolicyAsync(name);

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

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

DeleteAccessPolicyAsync(String, CancellationToken)

public virtual Task<Operation<Empty, AccessContextManagerOperationMetadata>> DeleteAccessPolicyAsync(string name, CancellationToken cancellationToken)

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]";
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteAccessPolicyAsync(name);

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

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

DeleteGcpUserAccessBinding(DeleteGcpUserAccessBindingRequest, CallSettings)

public virtual Operation<Empty, GcpUserAccessBindingOperationMetadata> DeleteGcpUserAccessBinding(DeleteGcpUserAccessBindingRequest request, CallSettings callSettings = null)

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
DeleteGcpUserAccessBindingRequest request = new DeleteGcpUserAccessBindingRequest
{
    GcpUserAccessBindingName = GcpUserAccessBindingName.FromOrganizationGcpUserAccessBinding("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]"),
};
// Make the request
Operation<Empty, GcpUserAccessBindingOperationMetadata> response = accessContextManagerClient.DeleteGcpUserAccessBinding(request);

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

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

DeleteGcpUserAccessBinding(GcpUserAccessBindingName, CallSettings)

public virtual Operation<Empty, GcpUserAccessBindingOperationMetadata> DeleteGcpUserAccessBinding(GcpUserAccessBindingName name, CallSettings callSettings = null)

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
GcpUserAccessBindingName name = GcpUserAccessBindingName.FromOrganizationGcpUserAccessBinding("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]");
// Make the request
Operation<Empty, GcpUserAccessBindingOperationMetadata> response = accessContextManagerClient.DeleteGcpUserAccessBinding(name);

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

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

DeleteGcpUserAccessBinding(String, CallSettings)

public virtual Operation<Empty, GcpUserAccessBindingOperationMetadata> DeleteGcpUserAccessBinding(string name, CallSettings callSettings = null)

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
string name = "organizations/[ORGANIZATION]/gcpUserAccessBindings/[GCP_USER_ACCESS_BINDING]";
// Make the request
Operation<Empty, GcpUserAccessBindingOperationMetadata> response = accessContextManagerClient.DeleteGcpUserAccessBinding(name);

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

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

DeleteGcpUserAccessBindingAsync(DeleteGcpUserAccessBindingRequest, CallSettings)

public virtual Task<Operation<Empty, GcpUserAccessBindingOperationMetadata>> DeleteGcpUserAccessBindingAsync(DeleteGcpUserAccessBindingRequest request, CallSettings callSettings = null)

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
DeleteGcpUserAccessBindingRequest request = new DeleteGcpUserAccessBindingRequest
{
    GcpUserAccessBindingName = GcpUserAccessBindingName.FromOrganizationGcpUserAccessBinding("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]"),
};
// Make the request
Operation<Empty, GcpUserAccessBindingOperationMetadata> response = await accessContextManagerClient.DeleteGcpUserAccessBindingAsync(request);

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

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

DeleteGcpUserAccessBindingAsync(DeleteGcpUserAccessBindingRequest, CancellationToken)

public virtual Task<Operation<Empty, GcpUserAccessBindingOperationMetadata>> DeleteGcpUserAccessBindingAsync(DeleteGcpUserAccessBindingRequest request, CancellationToken cancellationToken)

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
DeleteGcpUserAccessBindingRequest request = new DeleteGcpUserAccessBindingRequest
{
    GcpUserAccessBindingName = GcpUserAccessBindingName.FromOrganizationGcpUserAccessBinding("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]"),
};
// Make the request
Operation<Empty, GcpUserAccessBindingOperationMetadata> response = await accessContextManagerClient.DeleteGcpUserAccessBindingAsync(request);

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

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

DeleteGcpUserAccessBindingAsync(GcpUserAccessBindingName, CallSettings)

public virtual Task<Operation<Empty, GcpUserAccessBindingOperationMetadata>> DeleteGcpUserAccessBindingAsync(GcpUserAccessBindingName name, CallSettings callSettings = null)

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
GcpUserAccessBindingName name = GcpUserAccessBindingName.FromOrganizationGcpUserAccessBinding("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]");
// Make the request
Operation<Empty, GcpUserAccessBindingOperationMetadata> response = await accessContextManagerClient.DeleteGcpUserAccessBindingAsync(name);

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

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

DeleteGcpUserAccessBindingAsync(GcpUserAccessBindingName, CancellationToken)

public virtual Task<Operation<Empty, GcpUserAccessBindingOperationMetadata>> DeleteGcpUserAccessBindingAsync(GcpUserAccessBindingName name, CancellationToken cancellationToken)

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
GcpUserAccessBindingName name = GcpUserAccessBindingName.FromOrganizationGcpUserAccessBinding("[ORGANIZATION]", "[GCP_USER_ACCESS_BINDING]");
// Make the request
Operation<Empty, GcpUserAccessBindingOperationMetadata> response = await accessContextManagerClient.DeleteGcpUserAccessBindingAsync(name);

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

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

DeleteGcpUserAccessBindingAsync(String, CallSettings)

public virtual Task<Operation<Empty, GcpUserAccessBindingOperationMetadata>> DeleteGcpUserAccessBindingAsync(string name, CallSettings callSettings = null)

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "organizations/[ORGANIZATION]/gcpUserAccessBindings/[GCP_USER_ACCESS_BINDING]";
// Make the request
Operation<Empty, GcpUserAccessBindingOperationMetadata> response = await accessContextManagerClient.DeleteGcpUserAccessBindingAsync(name);

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

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

DeleteGcpUserAccessBindingAsync(String, CancellationToken)

public virtual Task<Operation<Empty, GcpUserAccessBindingOperationMetadata>> DeleteGcpUserAccessBindingAsync(string name, CancellationToken cancellationToken)

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "organizations/[ORGANIZATION]/gcpUserAccessBindings/[GCP_USER_ACCESS_BINDING]";
// Make the request
Operation<Empty, GcpUserAccessBindingOperationMetadata> response = await accessContextManagerClient.DeleteGcpUserAccessBindingAsync(name);

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

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

DeleteServicePerimeter(DeleteServicePerimeterRequest, CallSettings)

public virtual Operation<Empty, AccessContextManagerOperationMetadata> DeleteServicePerimeter(DeleteServicePerimeterRequest request, CallSettings callSettings = null)

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
DeleteServicePerimeterRequest request = new DeleteServicePerimeterRequest
{
    ServicePerimeterName = ServicePerimeterName.FromAccessPolicyServicePerimeter("[ACCESS_POLICY]", "[SERVICE_PERIMETER]"),
};
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = accessContextManagerClient.DeleteServicePerimeter(request);

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

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

DeleteServicePerimeter(ServicePerimeterName, CallSettings)

public virtual Operation<Empty, AccessContextManagerOperationMetadata> DeleteServicePerimeter(ServicePerimeterName name, CallSettings callSettings = null)

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
ServicePerimeterName name = ServicePerimeterName.FromAccessPolicyServicePerimeter("[ACCESS_POLICY]", "[SERVICE_PERIMETER]");
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = accessContextManagerClient.DeleteServicePerimeter(name);

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

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

DeleteServicePerimeter(String, CallSettings)

public virtual Operation<Empty, AccessContextManagerOperationMetadata> DeleteServicePerimeter(string name, CallSettings callSettings = null)

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]/servicePerimeters/[SERVICE_PERIMETER]";
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = accessContextManagerClient.DeleteServicePerimeter(name);

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

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

DeleteServicePerimeterAsync(DeleteServicePerimeterRequest, CallSettings)

public virtual Task<Operation<Empty, AccessContextManagerOperationMetadata>> DeleteServicePerimeterAsync(DeleteServicePerimeterRequest request, CallSettings callSettings = null)

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
DeleteServicePerimeterRequest request = new DeleteServicePerimeterRequest
{
    ServicePerimeterName = ServicePerimeterName.FromAccessPolicyServicePerimeter("[ACCESS_POLICY]", "[SERVICE_PERIMETER]"),
};
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteServicePerimeterAsync(request);

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

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

DeleteServicePerimeterAsync(DeleteServicePerimeterRequest, CancellationToken)

public virtual Task<Operation<Empty, AccessContextManagerOperationMetadata>> DeleteServicePerimeterAsync(DeleteServicePerimeterRequest request, CancellationToken cancellationToken)

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
DeleteServicePerimeterRequest request = new DeleteServicePerimeterRequest
{
    ServicePerimeterName = ServicePerimeterName.FromAccessPolicyServicePerimeter("[ACCESS_POLICY]", "[SERVICE_PERIMETER]"),
};
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteServicePerimeterAsync(request);

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

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

DeleteServicePerimeterAsync(ServicePerimeterName, CallSettings)

public virtual Task<Operation<Empty, AccessContextManagerOperationMetadata>> DeleteServicePerimeterAsync(ServicePerimeterName name, CallSettings callSettings = null)

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
ServicePerimeterName name = ServicePerimeterName.FromAccessPolicyServicePerimeter("[ACCESS_POLICY]", "[SERVICE_PERIMETER]");
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteServicePerimeterAsync(name);

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

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

DeleteServicePerimeterAsync(ServicePerimeterName, CancellationToken)

public virtual Task<Operation<Empty, AccessContextManagerOperationMetadata>> DeleteServicePerimeterAsync(ServicePerimeterName name, CancellationToken cancellationToken)

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
ServicePerimeterName name = ServicePerimeterName.FromAccessPolicyServicePerimeter("[ACCESS_POLICY]", "[SERVICE_PERIMETER]");
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteServicePerimeterAsync(name);

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

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

DeleteServicePerimeterAsync(String, CallSettings)

public virtual Task<Operation<Empty, AccessContextManagerOperationMetadata>> DeleteServicePerimeterAsync(string name, CallSettings callSettings = null)

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]/servicePerimeters/[SERVICE_PERIMETER]";
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteServicePerimeterAsync(name);

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

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

DeleteServicePerimeterAsync(String, CancellationToken)

public virtual Task<Operation<Empty, AccessContextManagerOperationMetadata>> DeleteServicePerimeterAsync(string name, CancellationToken cancellationToken)

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string name = "accessPolicies/[ACCESS_POLICY]/servicePerimeters/[SERVICE_PERIMETER]";
// Make the request
Operation<Empty, AccessContextManagerOperationMetadata> response = await accessContextManagerClient.DeleteServicePerimeterAsync(name);

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

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

GetAccessLevel(AccessLevelName, CallSettings)

public virtual AccessLevel GetAccessLevel(AccessLevelName name, CallSettings callSettings = null)

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

GetAccessLevel(GetAccessLevelRequest, CallSettings)

public virtual AccessLevel GetAccessLevel(GetAccessLevelRequest request, CallSettings callSettings = null)

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

GetAccessLevel(String, CallSettings)

public virtual AccessLevel GetAccessLevel(string name, CallSettings callSettings = null)

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

GetAccessLevelAsync(AccessLevelName, CallSettings)

public virtual Task<AccessLevel> GetAccessLevelAsync(AccessLevelName name, CallSettings callSettings = null)

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

GetAccessLevelAsync(AccessLevelName, CancellationToken)

public virtual Task<AccessLevel> GetAccessLevelAsync(AccessLevelName name, CancellationToken cancellationToken)

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

GetAccessLevelAsync(GetAccessLevelRequest, CallSettings)

public virtual Task<AccessLevel> GetAccessLevelAsync(GetAccessLevelRequest request, CallSettings callSettings = null)

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

GetAccessLevelAsync(GetAccessLevelRequest, CancellationToken)

public virtual Task<AccessLevel> GetAccessLevelAsync(GetAccessLevelRequest request, CancellationToken cancellationToken)

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

GetAccessLevelAsync(String, CallSettings)

public virtual Task<AccessLevel> GetAccessLevelAsync(string name, CallSettings callSettings = null)

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

GetAccessLevelAsync(String, CancellationToken)

public virtual Task<AccessLevel> GetAccessLevelAsync(string name, CancellationToken cancellationToken)

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

GetAccessPolicy(AccessPolicyName, CallSettings)

public virtual AccessPolicy GetAccessPolicy(AccessPolicyName name, CallSettings callSettings = null)

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

GetAccessPolicy(GetAccessPolicyRequest, CallSettings)

public virtual AccessPolicy GetAccessPolicy(GetAccessPolicyRequest request, CallSettings callSettings = null)

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

GetAccessPolicy(String, CallSettings)

public virtual AccessPolicy GetAccessPolicy(string name, CallSettings callSettings = null)

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

GetAccessPolicyAsync(AccessPolicyName, CallSettings)

public virtual Task<AccessPolicy> GetAccessPolicyAsync(AccessPolicyName name, CallSettings callSettings = null)

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

GetAccessPolicyAsync(AccessPolicyName, CancellationToken)

public virtual Task<AccessPolicy> GetAccessPolicyAsync(AccessPolicyName name, CancellationToken cancellationToken)

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

GetAccessPolicyAsync(GetAccessPolicyRequest, CallSettings)

public virtual Task<AccessPolicy> GetAccessPolicyAsync(GetAccessPolicyRequest request, CallSettings callSettings = null)

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

GetAccessPolicyAsync(GetAccessPolicyRequest, CancellationToken)

public virtual Task<AccessPolicy> GetAccessPolicyAsync(GetAccessPolicyRequest request, CancellationToken cancellationToken)

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

GetAccessPolicyAsync(String, CallSettings)

public virtual Task<AccessPolicy> GetAccessPolicyAsync(string name, CallSettings callSettings = null)

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

GetAccessPolicyAsync(String, CancellationToken)

public virtual Task<AccessPolicy> GetAccessPolicyAsync(string name, CancellationToken cancellationToken)

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

GetGcpUserAccessBinding(GcpUserAccessBindingName, CallSettings)

public virtual GcpUserAccessBinding GetGcpUserAccessBinding(GcpUserAccessBindingName name, CallSettings callSettings = null)

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

GetGcpUserAccessBinding(GetGcpUserAccessBindingRequest, CallSettings)

public virtual GcpUserAccessBinding GetGcpUserAccessBinding(GetGcpUserAccessBindingRequest request, CallSettings callSettings = null)

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

GetGcpUserAccessBinding(String, CallSettings)

public virtual GcpUserAccessBinding GetGcpUserAccessBinding(string name, CallSettings callSettings = null)

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

GetGcpUserAccessBindingAsync(GcpUserAccessBindingName, CallSettings)

public virtual Task<GcpUserAccessBinding> GetGcpUserAccessBindingAsync(GcpUserAccessBindingName name, CallSettings callSettings = null)

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

GetGcpUserAccessBindingAsync(GcpUserAccessBindingName, CancellationToken)

public virtual Task<GcpUserAccessBinding> GetGcpUserAccessBindingAsync(GcpUserAccessBindingName name, CancellationToken cancellationToken)

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

GetGcpUserAccessBindingAsync(GetGcpUserAccessBindingRequest, CallSettings)

public virtual Task<GcpUserAccessBinding> GetGcpUserAccessBindingAsync(GetGcpUserAccessBindingRequest request, CallSettings callSettings = null)

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

GetGcpUserAccessBindingAsync(GetGcpUserAccessBindingRequest, CancellationToken)

public virtual Task<GcpUserAccessBinding> GetGcpUserAccessBindingAsync(GetGcpUserAccessBindingRequest request, CancellationToken cancellationToken)

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

GetGcpUserAccessBindingAsync(String, CallSettings)

public virtual Task<GcpUserAccessBinding> GetGcpUserAccessBindingAsync(string name, CallSettings callSettings = null)

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

GetGcpUserAccessBindingAsync(String, CancellationToken)

public virtual Task<GcpUserAccessBinding> GetGcpUserAccessBindingAsync(string name, CancellationToken cancellationToken)

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

GetServicePerimeter(GetServicePerimeterRequest, CallSettings)

public virtual ServicePerimeter GetServicePerimeter(GetServicePerimeterRequest request, CallSettings callSettings = null)

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

GetServicePerimeter(ServicePerimeterName, CallSettings)

public virtual ServicePerimeter GetServicePerimeter(ServicePerimeterName name, CallSettings callSettings = null)

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

GetServicePerimeter(String, CallSettings)

public virtual ServicePerimeter GetServicePerimeter(string name, CallSettings callSettings = null)

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

GetServicePerimeterAsync(GetServicePerimeterRequest, CallSettings)

public virtual Task<ServicePerimeter> GetServicePerimeterAsync(GetServicePerimeterRequest request, CallSettings callSettings = null)

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

GetServicePerimeterAsync(GetServicePerimeterRequest, CancellationToken)

public virtual Task<ServicePerimeter> GetServicePerimeterAsync(GetServicePerimeterRequest request, CancellationToken cancellationToken)

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

GetServicePerimeterAsync(ServicePerimeterName, CallSettings)

public virtual Task<ServicePerimeter> GetServicePerimeterAsync(ServicePerimeterName name, CallSettings callSettings = null)

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

GetServicePerimeterAsync(ServicePerimeterName, CancellationToken)

public virtual Task<ServicePerimeter> GetServicePerimeterAsync(ServicePerimeterName name, CancellationToken cancellationToken)

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

GetServicePerimeterAsync(String, CallSettings)

public virtual Task<ServicePerimeter> GetServicePerimeterAsync(string name, CallSettings callSettings = null)

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

GetServicePerimeterAsync(String, CancellationToken)

public virtual Task<ServicePerimeter> GetServicePerimeterAsync(string name, CancellationToken cancellationToken)

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

ListAccessLevels(AccessPolicyName, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListAccessLevelsResponse, AccessLevel> ListAccessLevels(AccessPolicyName parent, string pageToken = null, int? pageSize = default(int? ), CallSettings callSettings = null)

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

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

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

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

ListAccessLevels(ListAccessLevelsRequest, CallSettings)

public virtual PagedEnumerable<ListAccessLevelsResponse, AccessLevel> ListAccessLevels(ListAccessLevelsRequest request, CallSettings callSettings = null)

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

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

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

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

ListAccessLevels(String, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListAccessLevelsResponse, AccessLevel> ListAccessLevels(string parent, string pageToken = null, int? pageSize = default(int? ), CallSettings callSettings = null)

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

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

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

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

ListAccessLevelsAsync(AccessPolicyName, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListAccessLevelsResponse, AccessLevel> ListAccessLevelsAsync(AccessPolicyName parent, string pageToken = null, int? pageSize = default(int? ), CallSettings callSettings = null)

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

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

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

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

ListAccessLevelsAsync(ListAccessLevelsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListAccessLevelsResponse, AccessLevel> ListAccessLevelsAsync(ListAccessLevelsRequest request, CallSettings callSettings = null)

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

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

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

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

ListAccessLevelsAsync(String, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListAccessLevelsResponse, AccessLevel> ListAccessLevelsAsync(string parent, string pageToken = null, int? pageSize = default(int? ), CallSettings callSettings = null)

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

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

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

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

ListAccessPolicies(ListAccessPoliciesRequest, CallSettings)

public virtual PagedEnumerable<ListAccessPoliciesResponse, AccessPolicy> ListAccessPolicies(ListAccessPoliciesRequest request, CallSettings callSettings = null)

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

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

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

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

ListAccessPoliciesAsync(ListAccessPoliciesRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListAccessPoliciesResponse, AccessPolicy> ListAccessPoliciesAsync(ListAccessPoliciesRequest request, CallSettings callSettings = null)

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

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

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

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

ListGcpUserAccessBindings(OrganizationName, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListGcpUserAccessBindingsResponse, GcpUserAccessBinding> ListGcpUserAccessBindings(OrganizationName parent, string pageToken = null, int? pageSize = default(int? ), CallSettings callSettings = null)

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

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

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

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

ListGcpUserAccessBindings(ListGcpUserAccessBindingsRequest, CallSettings)

public virtual PagedEnumerable<ListGcpUserAccessBindingsResponse, GcpUserAccessBinding> ListGcpUserAccessBindings(ListGcpUserAccessBindingsRequest request, CallSettings callSettings = null)

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

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

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

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

ListGcpUserAccessBindings(String, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListGcpUserAccessBindingsResponse, GcpUserAccessBinding> ListGcpUserAccessBindings(string parent, string pageToken = null, int? pageSize = default(int? ), CallSettings callSettings = null)

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

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

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

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

ListGcpUserAccessBindingsAsync(OrganizationName, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListGcpUserAccessBindingsResponse, GcpUserAccessBinding> ListGcpUserAccessBindingsAsync(OrganizationName parent, string pageToken = null, int? pageSize = default(int? ), CallSettings callSettings = null)

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

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((GcpUserAccessBinding 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((ListGcpUserAccessBindingsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (GcpUserAccessBinding item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<GcpUserAccessBinding> singlePage = 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 (GcpUserAccessBinding item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListGcpUserAccessBindingsAsync(ListGcpUserAccessBindingsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListGcpUserAccessBindingsResponse, GcpUserAccessBinding> ListGcpUserAccessBindingsAsync(ListGcpUserAccessBindingsRequest request, CallSettings callSettings = null)

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

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((GcpUserAccessBinding 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((ListGcpUserAccessBindingsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (GcpUserAccessBinding item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<GcpUserAccessBinding> singlePage = 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 (GcpUserAccessBinding item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListGcpUserAccessBindingsAsync(String, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListGcpUserAccessBindingsResponse, GcpUserAccessBinding> ListGcpUserAccessBindingsAsync(string parent, string pageToken = null, int? pageSize = default(int? ), CallSettings callSettings = null)

// Create client
AccessContextManagerClient accessContextManagerClient = await AccessContextManagerClient.CreateAsync();
// Initialize request argument(s)
string parent = "organizations/[ORGANIZATION]";
// Make the request
PagedAsyncEnumerable<ListGcpUserAccessBindingsResponse, GcpUserAccessBinding> response = accessContextManagerClient.ListGcpUserAccessBindingsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((GcpUserAccessBinding 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((ListGcpUserAccessBindingsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (GcpUserAccessBinding item in page)
    {
        // Do something with each item
        Console.WriteLine(item);
    }
});

// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page<GcpUserAccessBinding> singlePage = 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 (GcpUserAccessBinding item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

ListServicePerimeters(AccessPolicyName, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListServicePerimetersResponse, ServicePerimeter> ListServicePerimeters(AccessPolicyName parent, string pageToken = null, int? pageSize = default(int? ), CallSettings callSettings = null)

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

// Iterate over all response items, lazily performing RPCs as required
foreach (ServicePerimeter 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 (ListServicePerimetersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ServicePerimeter 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<ServicePerimeter> 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 (ServicePerimeter 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;

ListServicePerimeters(ListServicePerimetersRequest, CallSettings)

public virtual PagedEnumerable<ListServicePerimetersResponse, ServicePerimeter> ListServicePerimeters(ListServicePerimetersRequest request, CallSettings callSettings = null)

// Create client
AccessContextManagerClient accessContextManagerClient = AccessContextManagerClient.Create();
// Initialize request argument(s)
ListServicePerimetersRequest request = new ListServicePerimetersRequest
{
    ParentAsAccessPolicyName = AccessPolicyName.FromAccessPolicy("[ACCESS_POLICY]"),
};
// Make the request
PagedEnumerable<ListServicePerimetersResponse, ServicePerimeter> response = accessContextManagerClient.ListServicePerimeters(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (ServicePerimeter 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 (ListServicePerimetersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ServicePerimeter 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<ServicePerimeter> 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 (ServicePerimeter 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;

ListServicePerimeters(String, String, Nullable<Int32>, CallSettings)

public virtual PagedEnumerable<ListServicePerimetersResponse, ServicePerimeter> ListServicePerimeters(string parent, string pageToken = null, int? pageSize = default(int? ), CallSettings callSettings = null)

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

// Iterate over all response items, lazily performing RPCs as required
foreach (ServicePerimeter 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 (ListServicePerimetersResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ServicePerimeter 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<ServicePerimeter> 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 (ServicePerimeter 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;

ListServicePerimetersAsync(AccessPolicyName, String, Nullable<Int32>, CallSettings)

public virtual PagedAsyncEnumerable<ListServicePerimetersResponse, ServicePerimeter> ListServicePerimetersAsync(AccessPolicyName parent, string pageToken = null, int? pageSize = default(int? ), CallSettings callSettings = null)