Network Connectivity v1 API - Class CrossNetworkAutomationServiceClient (2.10.0)

Stay organized with collections Save and categorize content based on your preferences.

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ServiceConnectionMap serviceConnectionMap = new ServiceConnectionMap();
string serviceConnectionMapId = "";
// Make the request
Operation<ServiceConnectionMap, OperationMetadata> response = crossNetworkAutomationServiceClient.CreateServiceConnectionMap(parent, serviceConnectionMap, serviceConnectionMapId);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
CreateServiceConnectionMapRequest request = new CreateServiceConnectionMapRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ServiceConnectionMapId = "",
    ServiceConnectionMap = new ServiceConnectionMap(),
    RequestId = "",
};
// Make the request
Operation<ServiceConnectionMap, OperationMetadata> response = crossNetworkAutomationServiceClient.CreateServiceConnectionMap(request);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ServiceConnectionMap serviceConnectionMap = new ServiceConnectionMap();
string serviceConnectionMapId = "";
// Make the request
Operation<ServiceConnectionMap, OperationMetadata> response = crossNetworkAutomationServiceClient.CreateServiceConnectionMap(parent, serviceConnectionMap, serviceConnectionMapId);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ServiceConnectionMap serviceConnectionMap = new ServiceConnectionMap();
string serviceConnectionMapId = "";
// Make the request
Operation<ServiceConnectionMap, OperationMetadata> response = await crossNetworkAutomationServiceClient.CreateServiceConnectionMapAsync(parent, serviceConnectionMap, serviceConnectionMapId);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ServiceConnectionMap serviceConnectionMap = new ServiceConnectionMap();
string serviceConnectionMapId = "";
// Make the request
Operation<ServiceConnectionMap, OperationMetadata> response = await crossNetworkAutomationServiceClient.CreateServiceConnectionMapAsync(parent, serviceConnectionMap, serviceConnectionMapId);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
CreateServiceConnectionMapRequest request = new CreateServiceConnectionMapRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ServiceConnectionMapId = "",
    ServiceConnectionMap = new ServiceConnectionMap(),
    RequestId = "",
};
// Make the request
Operation<ServiceConnectionMap, OperationMetadata> response = await crossNetworkAutomationServiceClient.CreateServiceConnectionMapAsync(request);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
CreateServiceConnectionMapRequest request = new CreateServiceConnectionMapRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ServiceConnectionMapId = "",
    ServiceConnectionMap = new ServiceConnectionMap(),
    RequestId = "",
};
// Make the request
Operation<ServiceConnectionMap, OperationMetadata> response = await crossNetworkAutomationServiceClient.CreateServiceConnectionMapAsync(request);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ServiceConnectionMap serviceConnectionMap = new ServiceConnectionMap();
string serviceConnectionMapId = "";
// Make the request
Operation<ServiceConnectionMap, OperationMetadata> response = await crossNetworkAutomationServiceClient.CreateServiceConnectionMapAsync(parent, serviceConnectionMap, serviceConnectionMapId);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ServiceConnectionMap serviceConnectionMap = new ServiceConnectionMap();
string serviceConnectionMapId = "";
// Make the request
Operation<ServiceConnectionMap, OperationMetadata> response = await crossNetworkAutomationServiceClient.CreateServiceConnectionMapAsync(parent, serviceConnectionMap, serviceConnectionMapId);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ServiceConnectionPolicy serviceConnectionPolicy = new ServiceConnectionPolicy();
string serviceConnectionPolicyId = "";
// Make the request
Operation<ServiceConnectionPolicy, OperationMetadata> response = crossNetworkAutomationServiceClient.CreateServiceConnectionPolicy(parent, serviceConnectionPolicy, serviceConnectionPolicyId);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
CreateServiceConnectionPolicyRequest request = new CreateServiceConnectionPolicyRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ServiceConnectionPolicyId = "",
    ServiceConnectionPolicy = new ServiceConnectionPolicy(),
    RequestId = "",
};
// Make the request
Operation<ServiceConnectionPolicy, OperationMetadata> response = crossNetworkAutomationServiceClient.CreateServiceConnectionPolicy(request);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ServiceConnectionPolicy serviceConnectionPolicy = new ServiceConnectionPolicy();
string serviceConnectionPolicyId = "";
// Make the request
Operation<ServiceConnectionPolicy, OperationMetadata> response = crossNetworkAutomationServiceClient.CreateServiceConnectionPolicy(parent, serviceConnectionPolicy, serviceConnectionPolicyId);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ServiceConnectionPolicy serviceConnectionPolicy = new ServiceConnectionPolicy();
string serviceConnectionPolicyId = "";
// Make the request
Operation<ServiceConnectionPolicy, OperationMetadata> response = await crossNetworkAutomationServiceClient.CreateServiceConnectionPolicyAsync(parent, serviceConnectionPolicy, serviceConnectionPolicyId);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ServiceConnectionPolicy serviceConnectionPolicy = new ServiceConnectionPolicy();
string serviceConnectionPolicyId = "";
// Make the request
Operation<ServiceConnectionPolicy, OperationMetadata> response = await crossNetworkAutomationServiceClient.CreateServiceConnectionPolicyAsync(parent, serviceConnectionPolicy, serviceConnectionPolicyId);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
CreateServiceConnectionPolicyRequest request = new CreateServiceConnectionPolicyRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ServiceConnectionPolicyId = "",
    ServiceConnectionPolicy = new ServiceConnectionPolicy(),
    RequestId = "",
};
// Make the request
Operation<ServiceConnectionPolicy, OperationMetadata> response = await crossNetworkAutomationServiceClient.CreateServiceConnectionPolicyAsync(request);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
CreateServiceConnectionPolicyRequest request = new CreateServiceConnectionPolicyRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ServiceConnectionPolicyId = "",
    ServiceConnectionPolicy = new ServiceConnectionPolicy(),
    RequestId = "",
};
// Make the request
Operation<ServiceConnectionPolicy, OperationMetadata> response = await crossNetworkAutomationServiceClient.CreateServiceConnectionPolicyAsync(request);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ServiceConnectionPolicy serviceConnectionPolicy = new ServiceConnectionPolicy();
string serviceConnectionPolicyId = "";
// Make the request
Operation<ServiceConnectionPolicy, OperationMetadata> response = await crossNetworkAutomationServiceClient.CreateServiceConnectionPolicyAsync(parent, serviceConnectionPolicy, serviceConnectionPolicyId);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ServiceConnectionPolicy serviceConnectionPolicy = new ServiceConnectionPolicy();
string serviceConnectionPolicyId = "";
// Make the request
Operation<ServiceConnectionPolicy, OperationMetadata> response = await crossNetworkAutomationServiceClient.CreateServiceConnectionPolicyAsync(parent, serviceConnectionPolicy, serviceConnectionPolicyId);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ServiceConnectionToken serviceConnectionToken = new ServiceConnectionToken();
string serviceConnectionTokenId = "";
// Make the request
Operation<ServiceConnectionToken, OperationMetadata> response = crossNetworkAutomationServiceClient.CreateServiceConnectionToken(parent, serviceConnectionToken, serviceConnectionTokenId);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
CreateServiceConnectionTokenRequest request = new CreateServiceConnectionTokenRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ServiceConnectionTokenId = "",
    ServiceConnectionToken = new ServiceConnectionToken(),
    RequestId = "",
};
// Make the request
Operation<ServiceConnectionToken, OperationMetadata> response = crossNetworkAutomationServiceClient.CreateServiceConnectionToken(request);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ServiceConnectionToken serviceConnectionToken = new ServiceConnectionToken();
string serviceConnectionTokenId = "";
// Make the request
Operation<ServiceConnectionToken, OperationMetadata> response = crossNetworkAutomationServiceClient.CreateServiceConnectionToken(parent, serviceConnectionToken, serviceConnectionTokenId);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ServiceConnectionToken serviceConnectionToken = new ServiceConnectionToken();
string serviceConnectionTokenId = "";
// Make the request
Operation<ServiceConnectionToken, OperationMetadata> response = await crossNetworkAutomationServiceClient.CreateServiceConnectionTokenAsync(parent, serviceConnectionToken, serviceConnectionTokenId);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ServiceConnectionToken serviceConnectionToken = new ServiceConnectionToken();
string serviceConnectionTokenId = "";
// Make the request
Operation<ServiceConnectionToken, OperationMetadata> response = await crossNetworkAutomationServiceClient.CreateServiceConnectionTokenAsync(parent, serviceConnectionToken, serviceConnectionTokenId);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
CreateServiceConnectionTokenRequest request = new CreateServiceConnectionTokenRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ServiceConnectionTokenId = "",
    ServiceConnectionToken = new ServiceConnectionToken(),
    RequestId = "",
};
// Make the request
Operation<ServiceConnectionToken, OperationMetadata> response = await crossNetworkAutomationServiceClient.CreateServiceConnectionTokenAsync(request);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
CreateServiceConnectionTokenRequest request = new CreateServiceConnectionTokenRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ServiceConnectionTokenId = "",
    ServiceConnectionToken = new ServiceConnectionToken(),
    RequestId = "",
};
// Make the request
Operation<ServiceConnectionToken, OperationMetadata> response = await crossNetworkAutomationServiceClient.CreateServiceConnectionTokenAsync(request);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ServiceConnectionToken serviceConnectionToken = new ServiceConnectionToken();
string serviceConnectionTokenId = "";
// Make the request
Operation<ServiceConnectionToken, OperationMetadata> response = await crossNetworkAutomationServiceClient.CreateServiceConnectionTokenAsync(parent, serviceConnectionToken, serviceConnectionTokenId);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ServiceConnectionToken serviceConnectionToken = new ServiceConnectionToken();
string serviceConnectionTokenId = "";
// Make the request
Operation<ServiceConnectionToken, OperationMetadata> response = await crossNetworkAutomationServiceClient.CreateServiceConnectionTokenAsync(parent, serviceConnectionToken, serviceConnectionTokenId);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
DeleteServiceClassRequest request = new DeleteServiceClassRequest
{
    ServiceClassName = ServiceClassName.FromProjectLocationServiceClass("[PROJECT]", "[LOCATION]", "[SERVICE_CLASS]"),
    RequestId = "",
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = crossNetworkAutomationServiceClient.DeleteServiceClass(request);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
ServiceClassName name = ServiceClassName.FromProjectLocationServiceClass("[PROJECT]", "[LOCATION]", "[SERVICE_CLASS]");
// Make the request
Operation<Empty, OperationMetadata> response = crossNetworkAutomationServiceClient.DeleteServiceClass(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceClasses/[SERVICE_CLASS]";
// Make the request
Operation<Empty, OperationMetadata> response = crossNetworkAutomationServiceClient.DeleteServiceClass(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteServiceClassRequest request = new DeleteServiceClassRequest
{
    ServiceClassName = ServiceClassName.FromProjectLocationServiceClass("[PROJECT]", "[LOCATION]", "[SERVICE_CLASS]"),
    RequestId = "",
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceClassAsync(request);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteServiceClassRequest request = new DeleteServiceClassRequest
{
    ServiceClassName = ServiceClassName.FromProjectLocationServiceClass("[PROJECT]", "[LOCATION]", "[SERVICE_CLASS]"),
    RequestId = "",
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceClassAsync(request);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
ServiceClassName name = ServiceClassName.FromProjectLocationServiceClass("[PROJECT]", "[LOCATION]", "[SERVICE_CLASS]");
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceClassAsync(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
ServiceClassName name = ServiceClassName.FromProjectLocationServiceClass("[PROJECT]", "[LOCATION]", "[SERVICE_CLASS]");
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceClassAsync(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceClasses/[SERVICE_CLASS]";
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceClassAsync(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceClasses/[SERVICE_CLASS]";
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceClassAsync(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
DeleteServiceConnectionMapRequest request = new DeleteServiceConnectionMapRequest
{
    ServiceConnectionMapName = ServiceConnectionMapName.FromProjectLocationServiceConnectionMap("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_MAP]"),
    RequestId = "",
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = crossNetworkAutomationServiceClient.DeleteServiceConnectionMap(request);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
ServiceConnectionMapName name = ServiceConnectionMapName.FromProjectLocationServiceConnectionMap("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_MAP]");
// Make the request
Operation<Empty, OperationMetadata> response = crossNetworkAutomationServiceClient.DeleteServiceConnectionMap(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceConnectionMaps/[SERVICE_CONNECTION_MAP]";
// Make the request
Operation<Empty, OperationMetadata> response = crossNetworkAutomationServiceClient.DeleteServiceConnectionMap(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteServiceConnectionMapRequest request = new DeleteServiceConnectionMapRequest
{
    ServiceConnectionMapName = ServiceConnectionMapName.FromProjectLocationServiceConnectionMap("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_MAP]"),
    RequestId = "",
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceConnectionMapAsync(request);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteServiceConnectionMapRequest request = new DeleteServiceConnectionMapRequest
{
    ServiceConnectionMapName = ServiceConnectionMapName.FromProjectLocationServiceConnectionMap("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_MAP]"),
    RequestId = "",
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceConnectionMapAsync(request);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
ServiceConnectionMapName name = ServiceConnectionMapName.FromProjectLocationServiceConnectionMap("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_MAP]");
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceConnectionMapAsync(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
ServiceConnectionMapName name = ServiceConnectionMapName.FromProjectLocationServiceConnectionMap("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_MAP]");
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceConnectionMapAsync(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceConnectionMaps/[SERVICE_CONNECTION_MAP]";
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceConnectionMapAsync(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceConnectionMaps/[SERVICE_CONNECTION_MAP]";
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceConnectionMapAsync(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
DeleteServiceConnectionPolicyRequest request = new DeleteServiceConnectionPolicyRequest
{
    ServiceConnectionPolicyName = ServiceConnectionPolicyName.FromProjectLocationServiceConnectionPolicy("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_POLICY]"),
    RequestId = "",
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = crossNetworkAutomationServiceClient.DeleteServiceConnectionPolicy(request);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
ServiceConnectionPolicyName name = ServiceConnectionPolicyName.FromProjectLocationServiceConnectionPolicy("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_POLICY]");
// Make the request
Operation<Empty, OperationMetadata> response = crossNetworkAutomationServiceClient.DeleteServiceConnectionPolicy(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceConnectionPolicies/[SERVICE_CONNECTION_POLICY]";
// Make the request
Operation<Empty, OperationMetadata> response = crossNetworkAutomationServiceClient.DeleteServiceConnectionPolicy(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteServiceConnectionPolicyRequest request = new DeleteServiceConnectionPolicyRequest
{
    ServiceConnectionPolicyName = ServiceConnectionPolicyName.FromProjectLocationServiceConnectionPolicy("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_POLICY]"),
    RequestId = "",
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceConnectionPolicyAsync(request);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteServiceConnectionPolicyRequest request = new DeleteServiceConnectionPolicyRequest
{
    ServiceConnectionPolicyName = ServiceConnectionPolicyName.FromProjectLocationServiceConnectionPolicy("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_POLICY]"),
    RequestId = "",
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceConnectionPolicyAsync(request);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
ServiceConnectionPolicyName name = ServiceConnectionPolicyName.FromProjectLocationServiceConnectionPolicy("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_POLICY]");
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceConnectionPolicyAsync(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
ServiceConnectionPolicyName name = ServiceConnectionPolicyName.FromProjectLocationServiceConnectionPolicy("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_POLICY]");
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceConnectionPolicyAsync(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceConnectionPolicies/[SERVICE_CONNECTION_POLICY]";
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceConnectionPolicyAsync(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceConnectionPolicies/[SERVICE_CONNECTION_POLICY]";
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceConnectionPolicyAsync(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
DeleteServiceConnectionTokenRequest request = new DeleteServiceConnectionTokenRequest
{
    ServiceConnectionTokenName = ServiceConnectionTokenName.FromProjectLocationServiceConnectionToken("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_TOKEN]"),
    RequestId = "",
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = crossNetworkAutomationServiceClient.DeleteServiceConnectionToken(request);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
ServiceConnectionTokenName name = ServiceConnectionTokenName.FromProjectLocationServiceConnectionToken("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_TOKEN]");
// Make the request
Operation<Empty, OperationMetadata> response = crossNetworkAutomationServiceClient.DeleteServiceConnectionToken(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceConnectionTokens/[SERVICE_CONNECTION_TOKEN]";
// Make the request
Operation<Empty, OperationMetadata> response = crossNetworkAutomationServiceClient.DeleteServiceConnectionToken(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteServiceConnectionTokenRequest request = new DeleteServiceConnectionTokenRequest
{
    ServiceConnectionTokenName = ServiceConnectionTokenName.FromProjectLocationServiceConnectionToken("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_TOKEN]"),
    RequestId = "",
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceConnectionTokenAsync(request);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteServiceConnectionTokenRequest request = new DeleteServiceConnectionTokenRequest
{
    ServiceConnectionTokenName = ServiceConnectionTokenName.FromProjectLocationServiceConnectionToken("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_TOKEN]"),
    RequestId = "",
    Etag = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceConnectionTokenAsync(request);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
ServiceConnectionTokenName name = ServiceConnectionTokenName.FromProjectLocationServiceConnectionToken("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_TOKEN]");
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceConnectionTokenAsync(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
ServiceConnectionTokenName name = ServiceConnectionTokenName.FromProjectLocationServiceConnectionToken("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_TOKEN]");
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceConnectionTokenAsync(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceConnectionTokens/[SERVICE_CONNECTION_TOKEN]";
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceConnectionTokenAsync(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceConnectionTokens/[SERVICE_CONNECTION_TOKEN]";
// Make the request
Operation<Empty, OperationMetadata> response = await crossNetworkAutomationServiceClient.DeleteServiceConnectionTokenAsync(name);

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

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

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
GetServiceClassRequest request = new GetServiceClassRequest
{
    ServiceClassName = ServiceClassName.FromProjectLocationServiceClass("[PROJECT]", "[LOCATION]", "[SERVICE_CLASS]"),
};
// Make the request
ServiceClass response = crossNetworkAutomationServiceClient.GetServiceClass(request);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
ServiceClassName name = ServiceClassName.FromProjectLocationServiceClass("[PROJECT]", "[LOCATION]", "[SERVICE_CLASS]");
// Make the request
ServiceClass response = crossNetworkAutomationServiceClient.GetServiceClass(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceClasses/[SERVICE_CLASS]";
// Make the request
ServiceClass response = crossNetworkAutomationServiceClient.GetServiceClass(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
GetServiceClassRequest request = new GetServiceClassRequest
{
    ServiceClassName = ServiceClassName.FromProjectLocationServiceClass("[PROJECT]", "[LOCATION]", "[SERVICE_CLASS]"),
};
// Make the request
ServiceClass response = await crossNetworkAutomationServiceClient.GetServiceClassAsync(request);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
GetServiceClassRequest request = new GetServiceClassRequest
{
    ServiceClassName = ServiceClassName.FromProjectLocationServiceClass("[PROJECT]", "[LOCATION]", "[SERVICE_CLASS]"),
};
// Make the request
ServiceClass response = await crossNetworkAutomationServiceClient.GetServiceClassAsync(request);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
ServiceClassName name = ServiceClassName.FromProjectLocationServiceClass("[PROJECT]", "[LOCATION]", "[SERVICE_CLASS]");
// Make the request
ServiceClass response = await crossNetworkAutomationServiceClient.GetServiceClassAsync(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
ServiceClassName name = ServiceClassName.FromProjectLocationServiceClass("[PROJECT]", "[LOCATION]", "[SERVICE_CLASS]");
// Make the request
ServiceClass response = await crossNetworkAutomationServiceClient.GetServiceClassAsync(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceClasses/[SERVICE_CLASS]";
// Make the request
ServiceClass response = await crossNetworkAutomationServiceClient.GetServiceClassAsync(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceClasses/[SERVICE_CLASS]";
// Make the request
ServiceClass response = await crossNetworkAutomationServiceClient.GetServiceClassAsync(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
GetServiceConnectionMapRequest request = new GetServiceConnectionMapRequest
{
    ServiceConnectionMapName = ServiceConnectionMapName.FromProjectLocationServiceConnectionMap("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_MAP]"),
};
// Make the request
ServiceConnectionMap response = crossNetworkAutomationServiceClient.GetServiceConnectionMap(request);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
ServiceConnectionMapName name = ServiceConnectionMapName.FromProjectLocationServiceConnectionMap("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_MAP]");
// Make the request
ServiceConnectionMap response = crossNetworkAutomationServiceClient.GetServiceConnectionMap(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceConnectionMaps/[SERVICE_CONNECTION_MAP]";
// Make the request
ServiceConnectionMap response = crossNetworkAutomationServiceClient.GetServiceConnectionMap(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
GetServiceConnectionMapRequest request = new GetServiceConnectionMapRequest
{
    ServiceConnectionMapName = ServiceConnectionMapName.FromProjectLocationServiceConnectionMap("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_MAP]"),
};
// Make the request
ServiceConnectionMap response = await crossNetworkAutomationServiceClient.GetServiceConnectionMapAsync(request);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
GetServiceConnectionMapRequest request = new GetServiceConnectionMapRequest
{
    ServiceConnectionMapName = ServiceConnectionMapName.FromProjectLocationServiceConnectionMap("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_MAP]"),
};
// Make the request
ServiceConnectionMap response = await crossNetworkAutomationServiceClient.GetServiceConnectionMapAsync(request);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
ServiceConnectionMapName name = ServiceConnectionMapName.FromProjectLocationServiceConnectionMap("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_MAP]");
// Make the request
ServiceConnectionMap response = await crossNetworkAutomationServiceClient.GetServiceConnectionMapAsync(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
ServiceConnectionMapName name = ServiceConnectionMapName.FromProjectLocationServiceConnectionMap("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_MAP]");
// Make the request
ServiceConnectionMap response = await crossNetworkAutomationServiceClient.GetServiceConnectionMapAsync(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceConnectionMaps/[SERVICE_CONNECTION_MAP]";
// Make the request
ServiceConnectionMap response = await crossNetworkAutomationServiceClient.GetServiceConnectionMapAsync(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceConnectionMaps/[SERVICE_CONNECTION_MAP]";
// Make the request
ServiceConnectionMap response = await crossNetworkAutomationServiceClient.GetServiceConnectionMapAsync(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
GetServiceConnectionPolicyRequest request = new GetServiceConnectionPolicyRequest
{
    ServiceConnectionPolicyName = ServiceConnectionPolicyName.FromProjectLocationServiceConnectionPolicy("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_POLICY]"),
};
// Make the request
ServiceConnectionPolicy response = crossNetworkAutomationServiceClient.GetServiceConnectionPolicy(request);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
ServiceConnectionPolicyName name = ServiceConnectionPolicyName.FromProjectLocationServiceConnectionPolicy("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_POLICY]");
// Make the request
ServiceConnectionPolicy response = crossNetworkAutomationServiceClient.GetServiceConnectionPolicy(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceConnectionPolicies/[SERVICE_CONNECTION_POLICY]";
// Make the request
ServiceConnectionPolicy response = crossNetworkAutomationServiceClient.GetServiceConnectionPolicy(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
GetServiceConnectionPolicyRequest request = new GetServiceConnectionPolicyRequest
{
    ServiceConnectionPolicyName = ServiceConnectionPolicyName.FromProjectLocationServiceConnectionPolicy("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_POLICY]"),
};
// Make the request
ServiceConnectionPolicy response = await crossNetworkAutomationServiceClient.GetServiceConnectionPolicyAsync(request);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
GetServiceConnectionPolicyRequest request = new GetServiceConnectionPolicyRequest
{
    ServiceConnectionPolicyName = ServiceConnectionPolicyName.FromProjectLocationServiceConnectionPolicy("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_POLICY]"),
};
// Make the request
ServiceConnectionPolicy response = await crossNetworkAutomationServiceClient.GetServiceConnectionPolicyAsync(request);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
ServiceConnectionPolicyName name = ServiceConnectionPolicyName.FromProjectLocationServiceConnectionPolicy("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_POLICY]");
// Make the request
ServiceConnectionPolicy response = await crossNetworkAutomationServiceClient.GetServiceConnectionPolicyAsync(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
ServiceConnectionPolicyName name = ServiceConnectionPolicyName.FromProjectLocationServiceConnectionPolicy("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_POLICY]");
// Make the request
ServiceConnectionPolicy response = await crossNetworkAutomationServiceClient.GetServiceConnectionPolicyAsync(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceConnectionPolicies/[SERVICE_CONNECTION_POLICY]";
// Make the request
ServiceConnectionPolicy response = await crossNetworkAutomationServiceClient.GetServiceConnectionPolicyAsync(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceConnectionPolicies/[SERVICE_CONNECTION_POLICY]";
// Make the request
ServiceConnectionPolicy response = await crossNetworkAutomationServiceClient.GetServiceConnectionPolicyAsync(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
GetServiceConnectionTokenRequest request = new GetServiceConnectionTokenRequest
{
    ServiceConnectionTokenName = ServiceConnectionTokenName.FromProjectLocationServiceConnectionToken("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_TOKEN]"),
};
// Make the request
ServiceConnectionToken response = crossNetworkAutomationServiceClient.GetServiceConnectionToken(request);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
ServiceConnectionTokenName name = ServiceConnectionTokenName.FromProjectLocationServiceConnectionToken("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_TOKEN]");
// Make the request
ServiceConnectionToken response = crossNetworkAutomationServiceClient.GetServiceConnectionToken(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceConnectionTokens/[SERVICE_CONNECTION_TOKEN]";
// Make the request
ServiceConnectionToken response = crossNetworkAutomationServiceClient.GetServiceConnectionToken(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
GetServiceConnectionTokenRequest request = new GetServiceConnectionTokenRequest
{
    ServiceConnectionTokenName = ServiceConnectionTokenName.FromProjectLocationServiceConnectionToken("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_TOKEN]"),
};
// Make the request
ServiceConnectionToken response = await crossNetworkAutomationServiceClient.GetServiceConnectionTokenAsync(request);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
GetServiceConnectionTokenRequest request = new GetServiceConnectionTokenRequest
{
    ServiceConnectionTokenName = ServiceConnectionTokenName.FromProjectLocationServiceConnectionToken("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_TOKEN]"),
};
// Make the request
ServiceConnectionToken response = await crossNetworkAutomationServiceClient.GetServiceConnectionTokenAsync(request);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
ServiceConnectionTokenName name = ServiceConnectionTokenName.FromProjectLocationServiceConnectionToken("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_TOKEN]");
// Make the request
ServiceConnectionToken response = await crossNetworkAutomationServiceClient.GetServiceConnectionTokenAsync(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
ServiceConnectionTokenName name = ServiceConnectionTokenName.FromProjectLocationServiceConnectionToken("[PROJECT]", "[LOCATION]", "[SERVICE_CONNECTION_TOKEN]");
// Make the request
ServiceConnectionToken response = await crossNetworkAutomationServiceClient.GetServiceConnectionTokenAsync(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceConnectionTokens/[SERVICE_CONNECTION_TOKEN]";
// Make the request
ServiceConnectionToken response = await crossNetworkAutomationServiceClient.GetServiceConnectionTokenAsync(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/serviceConnectionTokens/[SERVICE_CONNECTION_TOKEN]";
// Make the request
ServiceConnectionToken response = await crossNetworkAutomationServiceClient.GetServiceConnectionTokenAsync(name);

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListServiceClassesResponse, ServiceClass> response = crossNetworkAutomationServiceClient.ListServiceClasses(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (ServiceClass 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 (ListServiceClassesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ServiceClass 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<ServiceClass> 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 (ServiceClass item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
ListServiceClassesRequest request = new ListServiceClassesRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<ListServiceClassesResponse, ServiceClass> response = crossNetworkAutomationServiceClient.ListServiceClasses(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (ServiceClass 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 (ListServiceClassesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ServiceClass 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<ServiceClass> 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 (ServiceClass item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListServiceClassesResponse, ServiceClass> response = crossNetworkAutomationServiceClient.ListServiceClasses(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (ServiceClass 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 (ListServiceClassesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ServiceClass 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<ServiceClass> 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 (ServiceClass item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListServiceClassesResponse, ServiceClass> response = crossNetworkAutomationServiceClient.ListServiceClassesAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ServiceClass 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((ListServiceClassesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ServiceClass 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<ServiceClass> 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 (ServiceClass item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
ListServiceClassesRequest request = new ListServiceClassesRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<ListServiceClassesResponse, ServiceClass> response = crossNetworkAutomationServiceClient.ListServiceClassesAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ServiceClass 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((ListServiceClassesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ServiceClass 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<ServiceClass> 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 (ServiceClass item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListServiceClassesResponse, ServiceClass> response = crossNetworkAutomationServiceClient.ListServiceClassesAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ServiceClass 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((ListServiceClassesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ServiceClass 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<ServiceClass> 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 (ServiceClass item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListServiceConnectionMapsResponse, ServiceConnectionMap> response = crossNetworkAutomationServiceClient.ListServiceConnectionMaps(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (ServiceConnectionMap 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 (ListServiceConnectionMapsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ServiceConnectionMap 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<ServiceConnectionMap> 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 (ServiceConnectionMap item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
ListServiceConnectionMapsRequest request = new ListServiceConnectionMapsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<ListServiceConnectionMapsResponse, ServiceConnectionMap> response = crossNetworkAutomationServiceClient.ListServiceConnectionMaps(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (ServiceConnectionMap 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 (ListServiceConnectionMapsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ServiceConnectionMap 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<ServiceConnectionMap> 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 (ServiceConnectionMap item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListServiceConnectionMapsResponse, ServiceConnectionMap> response = crossNetworkAutomationServiceClient.ListServiceConnectionMaps(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (ServiceConnectionMap 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 (ListServiceConnectionMapsResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ServiceConnectionMap 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<ServiceConnectionMap> 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 (ServiceConnectionMap item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListServiceConnectionMapsResponse, ServiceConnectionMap> response = crossNetworkAutomationServiceClient.ListServiceConnectionMapsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ServiceConnectionMap 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((ListServiceConnectionMapsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ServiceConnectionMap 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<ServiceConnectionMap> 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 (ServiceConnectionMap item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
ListServiceConnectionMapsRequest request = new ListServiceConnectionMapsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<ListServiceConnectionMapsResponse, ServiceConnectionMap> response = crossNetworkAutomationServiceClient.ListServiceConnectionMapsAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ServiceConnectionMap 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((ListServiceConnectionMapsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ServiceConnectionMap 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<ServiceConnectionMap> 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 (ServiceConnectionMap item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = await CrossNetworkAutomationServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListServiceConnectionMapsResponse, ServiceConnectionMap> response = crossNetworkAutomationServiceClient.ListServiceConnectionMapsAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ServiceConnectionMap 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((ListServiceConnectionMapsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ServiceConnectionMap 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<ServiceConnectionMap> 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 (ServiceConnectionMap item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListServiceConnectionPoliciesResponse, ServiceConnectionPolicy> response = crossNetworkAutomationServiceClient.ListServiceConnectionPolicies(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (ServiceConnectionPolicy 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 (ListServiceConnectionPoliciesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ServiceConnectionPolicy 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<ServiceConnectionPolicy> 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 (ServiceConnectionPolicy item in singlePage)
{
    // Do something with each item
    Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;

// Create client
CrossNetworkAutomationServiceClient crossNetworkAutomationServiceClient = CrossNetworkAutomationServiceClient.Create();
// Initialize request argument(s)
ListServiceConnectionPoliciesRequest request = new ListServiceConnectionPoliciesRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<ListServiceConnectionPoliciesResponse, ServiceConnectionPolicy> response = crossNetworkAutomationServiceClient.ListServiceConnectionPolicies(request);

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