Eventarc v1 API - Class EventarcClient (2.8.0)

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Channel channel = new Channel();
string channelId = "";
// Make the request
Operation<Channel, OperationMetadata> response = eventarcClient.CreateChannel(parent, channel, channelId);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
CreateChannelRequest request = new CreateChannelRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Channel = new Channel(),
    ChannelId = "",
    ValidateOnly = false,
};
// Make the request
Operation<Channel, OperationMetadata> response = eventarcClient.CreateChannel(request);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Channel channel = new Channel();
string channelId = "";
// Make the request
Operation<Channel, OperationMetadata> response = eventarcClient.CreateChannel(parent, channel, channelId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Channel channel = new Channel();
string channelId = "";
// Make the request
Operation<Channel, OperationMetadata> response = await eventarcClient.CreateChannelAsync(parent, channel, channelId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Channel channel = new Channel();
string channelId = "";
// Make the request
Operation<Channel, OperationMetadata> response = await eventarcClient.CreateChannelAsync(parent, channel, channelId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
CreateChannelRequest request = new CreateChannelRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Channel = new Channel(),
    ChannelId = "",
    ValidateOnly = false,
};
// Make the request
Operation<Channel, OperationMetadata> response = await eventarcClient.CreateChannelAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
CreateChannelRequest request = new CreateChannelRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Channel = new Channel(),
    ChannelId = "",
    ValidateOnly = false,
};
// Make the request
Operation<Channel, OperationMetadata> response = await eventarcClient.CreateChannelAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Channel channel = new Channel();
string channelId = "";
// Make the request
Operation<Channel, OperationMetadata> response = await eventarcClient.CreateChannelAsync(parent, channel, channelId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Channel channel = new Channel();
string channelId = "";
// Make the request
Operation<Channel, OperationMetadata> response = await eventarcClient.CreateChannelAsync(parent, channel, channelId);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ChannelConnection channelConnection = new ChannelConnection();
string channelConnectionId = "";
// Make the request
Operation<ChannelConnection, OperationMetadata> response = eventarcClient.CreateChannelConnection(parent, channelConnection, channelConnectionId);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
CreateChannelConnectionRequest request = new CreateChannelConnectionRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ChannelConnection = new ChannelConnection(),
    ChannelConnectionId = "",
};
// Make the request
Operation<ChannelConnection, OperationMetadata> response = eventarcClient.CreateChannelConnection(request);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ChannelConnection channelConnection = new ChannelConnection();
string channelConnectionId = "";
// Make the request
Operation<ChannelConnection, OperationMetadata> response = eventarcClient.CreateChannelConnection(parent, channelConnection, channelConnectionId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ChannelConnection channelConnection = new ChannelConnection();
string channelConnectionId = "";
// Make the request
Operation<ChannelConnection, OperationMetadata> response = await eventarcClient.CreateChannelConnectionAsync(parent, channelConnection, channelConnectionId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ChannelConnection channelConnection = new ChannelConnection();
string channelConnectionId = "";
// Make the request
Operation<ChannelConnection, OperationMetadata> response = await eventarcClient.CreateChannelConnectionAsync(parent, channelConnection, channelConnectionId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
CreateChannelConnectionRequest request = new CreateChannelConnectionRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ChannelConnection = new ChannelConnection(),
    ChannelConnectionId = "",
};
// Make the request
Operation<ChannelConnection, OperationMetadata> response = await eventarcClient.CreateChannelConnectionAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
CreateChannelConnectionRequest request = new CreateChannelConnectionRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    ChannelConnection = new ChannelConnection(),
    ChannelConnectionId = "",
};
// Make the request
Operation<ChannelConnection, OperationMetadata> response = await eventarcClient.CreateChannelConnectionAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ChannelConnection channelConnection = new ChannelConnection();
string channelConnectionId = "";
// Make the request
Operation<ChannelConnection, OperationMetadata> response = await eventarcClient.CreateChannelConnectionAsync(parent, channelConnection, channelConnectionId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
ChannelConnection channelConnection = new ChannelConnection();
string channelConnectionId = "";
// Make the request
Operation<ChannelConnection, OperationMetadata> response = await eventarcClient.CreateChannelConnectionAsync(parent, channelConnection, channelConnectionId);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Enrollment enrollment = new Enrollment();
string enrollmentId = "";
// Make the request
Operation<Enrollment, OperationMetadata> response = eventarcClient.CreateEnrollment(parent, enrollment, enrollmentId);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
CreateEnrollmentRequest request = new CreateEnrollmentRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Enrollment = new Enrollment(),
    EnrollmentId = "",
    ValidateOnly = false,
};
// Make the request
Operation<Enrollment, OperationMetadata> response = eventarcClient.CreateEnrollment(request);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Enrollment enrollment = new Enrollment();
string enrollmentId = "";
// Make the request
Operation<Enrollment, OperationMetadata> response = eventarcClient.CreateEnrollment(parent, enrollment, enrollmentId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Enrollment enrollment = new Enrollment();
string enrollmentId = "";
// Make the request
Operation<Enrollment, OperationMetadata> response = await eventarcClient.CreateEnrollmentAsync(parent, enrollment, enrollmentId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Enrollment enrollment = new Enrollment();
string enrollmentId = "";
// Make the request
Operation<Enrollment, OperationMetadata> response = await eventarcClient.CreateEnrollmentAsync(parent, enrollment, enrollmentId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
CreateEnrollmentRequest request = new CreateEnrollmentRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Enrollment = new Enrollment(),
    EnrollmentId = "",
    ValidateOnly = false,
};
// Make the request
Operation<Enrollment, OperationMetadata> response = await eventarcClient.CreateEnrollmentAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
CreateEnrollmentRequest request = new CreateEnrollmentRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Enrollment = new Enrollment(),
    EnrollmentId = "",
    ValidateOnly = false,
};
// Make the request
Operation<Enrollment, OperationMetadata> response = await eventarcClient.CreateEnrollmentAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Enrollment enrollment = new Enrollment();
string enrollmentId = "";
// Make the request
Operation<Enrollment, OperationMetadata> response = await eventarcClient.CreateEnrollmentAsync(parent, enrollment, enrollmentId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Enrollment enrollment = new Enrollment();
string enrollmentId = "";
// Make the request
Operation<Enrollment, OperationMetadata> response = await eventarcClient.CreateEnrollmentAsync(parent, enrollment, enrollmentId);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
GoogleApiSource googleApiSource = new GoogleApiSource();
string googleApiSourceId = "";
// Make the request
Operation<GoogleApiSource, OperationMetadata> response = eventarcClient.CreateGoogleApiSource(parent, googleApiSource, googleApiSourceId);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
CreateGoogleApiSourceRequest request = new CreateGoogleApiSourceRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    GoogleApiSource = new GoogleApiSource(),
    GoogleApiSourceId = "",
    ValidateOnly = false,
};
// Make the request
Operation<GoogleApiSource, OperationMetadata> response = eventarcClient.CreateGoogleApiSource(request);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
GoogleApiSource googleApiSource = new GoogleApiSource();
string googleApiSourceId = "";
// Make the request
Operation<GoogleApiSource, OperationMetadata> response = eventarcClient.CreateGoogleApiSource(parent, googleApiSource, googleApiSourceId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
GoogleApiSource googleApiSource = new GoogleApiSource();
string googleApiSourceId = "";
// Make the request
Operation<GoogleApiSource, OperationMetadata> response = await eventarcClient.CreateGoogleApiSourceAsync(parent, googleApiSource, googleApiSourceId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
GoogleApiSource googleApiSource = new GoogleApiSource();
string googleApiSourceId = "";
// Make the request
Operation<GoogleApiSource, OperationMetadata> response = await eventarcClient.CreateGoogleApiSourceAsync(parent, googleApiSource, googleApiSourceId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
CreateGoogleApiSourceRequest request = new CreateGoogleApiSourceRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    GoogleApiSource = new GoogleApiSource(),
    GoogleApiSourceId = "",
    ValidateOnly = false,
};
// Make the request
Operation<GoogleApiSource, OperationMetadata> response = await eventarcClient.CreateGoogleApiSourceAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
CreateGoogleApiSourceRequest request = new CreateGoogleApiSourceRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    GoogleApiSource = new GoogleApiSource(),
    GoogleApiSourceId = "",
    ValidateOnly = false,
};
// Make the request
Operation<GoogleApiSource, OperationMetadata> response = await eventarcClient.CreateGoogleApiSourceAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
GoogleApiSource googleApiSource = new GoogleApiSource();
string googleApiSourceId = "";
// Make the request
Operation<GoogleApiSource, OperationMetadata> response = await eventarcClient.CreateGoogleApiSourceAsync(parent, googleApiSource, googleApiSourceId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
GoogleApiSource googleApiSource = new GoogleApiSource();
string googleApiSourceId = "";
// Make the request
Operation<GoogleApiSource, OperationMetadata> response = await eventarcClient.CreateGoogleApiSourceAsync(parent, googleApiSource, googleApiSourceId);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
MessageBus messageBus = new MessageBus();
string messageBusId = "";
// Make the request
Operation<MessageBus, OperationMetadata> response = eventarcClient.CreateMessageBus(parent, messageBus, messageBusId);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
CreateMessageBusRequest request = new CreateMessageBusRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    MessageBus = new MessageBus(),
    MessageBusId = "",
    ValidateOnly = false,
};
// Make the request
Operation<MessageBus, OperationMetadata> response = eventarcClient.CreateMessageBus(request);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
MessageBus messageBus = new MessageBus();
string messageBusId = "";
// Make the request
Operation<MessageBus, OperationMetadata> response = eventarcClient.CreateMessageBus(parent, messageBus, messageBusId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
MessageBus messageBus = new MessageBus();
string messageBusId = "";
// Make the request
Operation<MessageBus, OperationMetadata> response = await eventarcClient.CreateMessageBusAsync(parent, messageBus, messageBusId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
MessageBus messageBus = new MessageBus();
string messageBusId = "";
// Make the request
Operation<MessageBus, OperationMetadata> response = await eventarcClient.CreateMessageBusAsync(parent, messageBus, messageBusId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
CreateMessageBusRequest request = new CreateMessageBusRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    MessageBus = new MessageBus(),
    MessageBusId = "",
    ValidateOnly = false,
};
// Make the request
Operation<MessageBus, OperationMetadata> response = await eventarcClient.CreateMessageBusAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
CreateMessageBusRequest request = new CreateMessageBusRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    MessageBus = new MessageBus(),
    MessageBusId = "",
    ValidateOnly = false,
};
// Make the request
Operation<MessageBus, OperationMetadata> response = await eventarcClient.CreateMessageBusAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
MessageBus messageBus = new MessageBus();
string messageBusId = "";
// Make the request
Operation<MessageBus, OperationMetadata> response = await eventarcClient.CreateMessageBusAsync(parent, messageBus, messageBusId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
MessageBus messageBus = new MessageBus();
string messageBusId = "";
// Make the request
Operation<MessageBus, OperationMetadata> response = await eventarcClient.CreateMessageBusAsync(parent, messageBus, messageBusId);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Pipeline pipeline = new Pipeline();
string pipelineId = "";
// Make the request
Operation<Pipeline, OperationMetadata> response = eventarcClient.CreatePipeline(parent, pipeline, pipelineId);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
CreatePipelineRequest request = new CreatePipelineRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Pipeline = new Pipeline(),
    PipelineId = "",
    ValidateOnly = false,
};
// Make the request
Operation<Pipeline, OperationMetadata> response = eventarcClient.CreatePipeline(request);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Pipeline pipeline = new Pipeline();
string pipelineId = "";
// Make the request
Operation<Pipeline, OperationMetadata> response = eventarcClient.CreatePipeline(parent, pipeline, pipelineId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Pipeline pipeline = new Pipeline();
string pipelineId = "";
// Make the request
Operation<Pipeline, OperationMetadata> response = await eventarcClient.CreatePipelineAsync(parent, pipeline, pipelineId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Pipeline pipeline = new Pipeline();
string pipelineId = "";
// Make the request
Operation<Pipeline, OperationMetadata> response = await eventarcClient.CreatePipelineAsync(parent, pipeline, pipelineId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
CreatePipelineRequest request = new CreatePipelineRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Pipeline = new Pipeline(),
    PipelineId = "",
    ValidateOnly = false,
};
// Make the request
Operation<Pipeline, OperationMetadata> response = await eventarcClient.CreatePipelineAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
CreatePipelineRequest request = new CreatePipelineRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Pipeline = new Pipeline(),
    PipelineId = "",
    ValidateOnly = false,
};
// Make the request
Operation<Pipeline, OperationMetadata> response = await eventarcClient.CreatePipelineAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Pipeline pipeline = new Pipeline();
string pipelineId = "";
// Make the request
Operation<Pipeline, OperationMetadata> response = await eventarcClient.CreatePipelineAsync(parent, pipeline, pipelineId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Pipeline pipeline = new Pipeline();
string pipelineId = "";
// Make the request
Operation<Pipeline, OperationMetadata> response = await eventarcClient.CreatePipelineAsync(parent, pipeline, pipelineId);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Trigger trigger = new Trigger();
string triggerId = "";
// Make the request
Operation<Trigger, OperationMetadata> response = eventarcClient.CreateTrigger(parent, trigger, triggerId);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
CreateTriggerRequest request = new CreateTriggerRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Trigger = new Trigger(),
    TriggerId = "",
    ValidateOnly = false,
};
// Make the request
Operation<Trigger, OperationMetadata> response = eventarcClient.CreateTrigger(request);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Trigger trigger = new Trigger();
string triggerId = "";
// Make the request
Operation<Trigger, OperationMetadata> response = eventarcClient.CreateTrigger(parent, trigger, triggerId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Trigger trigger = new Trigger();
string triggerId = "";
// Make the request
Operation<Trigger, OperationMetadata> response = await eventarcClient.CreateTriggerAsync(parent, trigger, triggerId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Trigger trigger = new Trigger();
string triggerId = "";
// Make the request
Operation<Trigger, OperationMetadata> response = await eventarcClient.CreateTriggerAsync(parent, trigger, triggerId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
CreateTriggerRequest request = new CreateTriggerRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Trigger = new Trigger(),
    TriggerId = "",
    ValidateOnly = false,
};
// Make the request
Operation<Trigger, OperationMetadata> response = await eventarcClient.CreateTriggerAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
CreateTriggerRequest request = new CreateTriggerRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Trigger = new Trigger(),
    TriggerId = "",
    ValidateOnly = false,
};
// Make the request
Operation<Trigger, OperationMetadata> response = await eventarcClient.CreateTriggerAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Trigger trigger = new Trigger();
string triggerId = "";
// Make the request
Operation<Trigger, OperationMetadata> response = await eventarcClient.CreateTriggerAsync(parent, trigger, triggerId);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Trigger trigger = new Trigger();
string triggerId = "";
// Make the request
Operation<Trigger, OperationMetadata> response = await eventarcClient.CreateTriggerAsync(parent, trigger, triggerId);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
ChannelName name = ChannelName.FromProjectLocationChannel("[PROJECT]", "[LOCATION]", "[CHANNEL]");
// Make the request
Operation<Channel, OperationMetadata> response = eventarcClient.DeleteChannel(name);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
DeleteChannelRequest request = new DeleteChannelRequest
{
    ChannelName = ChannelName.FromProjectLocationChannel("[PROJECT]", "[LOCATION]", "[CHANNEL]"),
    ValidateOnly = false,
};
// Make the request
Operation<Channel, OperationMetadata> response = eventarcClient.DeleteChannel(request);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/channels/[CHANNEL]";
// Make the request
Operation<Channel, OperationMetadata> response = eventarcClient.DeleteChannel(name);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
ChannelName name = ChannelName.FromProjectLocationChannel("[PROJECT]", "[LOCATION]", "[CHANNEL]");
// Make the request
Operation<Channel, OperationMetadata> response = await eventarcClient.DeleteChannelAsync(name);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
ChannelName name = ChannelName.FromProjectLocationChannel("[PROJECT]", "[LOCATION]", "[CHANNEL]");
// Make the request
Operation<Channel, OperationMetadata> response = await eventarcClient.DeleteChannelAsync(name);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
DeleteChannelRequest request = new DeleteChannelRequest
{
    ChannelName = ChannelName.FromProjectLocationChannel("[PROJECT]", "[LOCATION]", "[CHANNEL]"),
    ValidateOnly = false,
};
// Make the request
Operation<Channel, OperationMetadata> response = await eventarcClient.DeleteChannelAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
DeleteChannelRequest request = new DeleteChannelRequest
{
    ChannelName = ChannelName.FromProjectLocationChannel("[PROJECT]", "[LOCATION]", "[CHANNEL]"),
    ValidateOnly = false,
};
// Make the request
Operation<Channel, OperationMetadata> response = await eventarcClient.DeleteChannelAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/channels/[CHANNEL]";
// Make the request
Operation<Channel, OperationMetadata> response = await eventarcClient.DeleteChannelAsync(name);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/channels/[CHANNEL]";
// Make the request
Operation<Channel, OperationMetadata> response = await eventarcClient.DeleteChannelAsync(name);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
ChannelConnectionName name = ChannelConnectionName.FromProjectLocationChannelConnection("[PROJECT]", "[LOCATION]", "[CHANNEL_CONNECTION]");
// Make the request
Operation<ChannelConnection, OperationMetadata> response = eventarcClient.DeleteChannelConnection(name);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
DeleteChannelConnectionRequest request = new DeleteChannelConnectionRequest
{
    ChannelConnectionName = ChannelConnectionName.FromProjectLocationChannelConnection("[PROJECT]", "[LOCATION]", "[CHANNEL_CONNECTION]"),
};
// Make the request
Operation<ChannelConnection, OperationMetadata> response = eventarcClient.DeleteChannelConnection(request);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/channelConnections/[CHANNEL_CONNECTION]";
// Make the request
Operation<ChannelConnection, OperationMetadata> response = eventarcClient.DeleteChannelConnection(name);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
ChannelConnectionName name = ChannelConnectionName.FromProjectLocationChannelConnection("[PROJECT]", "[LOCATION]", "[CHANNEL_CONNECTION]");
// Make the request
Operation<ChannelConnection, OperationMetadata> response = await eventarcClient.DeleteChannelConnectionAsync(name);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
ChannelConnectionName name = ChannelConnectionName.FromProjectLocationChannelConnection("[PROJECT]", "[LOCATION]", "[CHANNEL_CONNECTION]");
// Make the request
Operation<ChannelConnection, OperationMetadata> response = await eventarcClient.DeleteChannelConnectionAsync(name);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
DeleteChannelConnectionRequest request = new DeleteChannelConnectionRequest
{
    ChannelConnectionName = ChannelConnectionName.FromProjectLocationChannelConnection("[PROJECT]", "[LOCATION]", "[CHANNEL_CONNECTION]"),
};
// Make the request
Operation<ChannelConnection, OperationMetadata> response = await eventarcClient.DeleteChannelConnectionAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
DeleteChannelConnectionRequest request = new DeleteChannelConnectionRequest
{
    ChannelConnectionName = ChannelConnectionName.FromProjectLocationChannelConnection("[PROJECT]", "[LOCATION]", "[CHANNEL_CONNECTION]"),
};
// Make the request
Operation<ChannelConnection, OperationMetadata> response = await eventarcClient.DeleteChannelConnectionAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/channelConnections/[CHANNEL_CONNECTION]";
// Make the request
Operation<ChannelConnection, OperationMetadata> response = await eventarcClient.DeleteChannelConnectionAsync(name);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/channelConnections/[CHANNEL_CONNECTION]";
// Make the request
Operation<ChannelConnection, OperationMetadata> response = await eventarcClient.DeleteChannelConnectionAsync(name);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
DeleteEnrollmentRequest request = new DeleteEnrollmentRequest
{
    EnrollmentName = EnrollmentName.FromProjectLocationEnrollment("[PROJECT]", "[LOCATION]", "[ENROLLMENT]"),
    Etag = "",
    AllowMissing = false,
    ValidateOnly = false,
};
// Make the request
Operation<Enrollment, OperationMetadata> response = eventarcClient.DeleteEnrollment(request);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
EnrollmentName name = EnrollmentName.FromProjectLocationEnrollment("[PROJECT]", "[LOCATION]", "[ENROLLMENT]");
string etag = "";
// Make the request
Operation<Enrollment, OperationMetadata> response = eventarcClient.DeleteEnrollment(name, etag);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/enrollments/[ENROLLMENT]";
string etag = "";
// Make the request
Operation<Enrollment, OperationMetadata> response = eventarcClient.DeleteEnrollment(name, etag);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
DeleteEnrollmentRequest request = new DeleteEnrollmentRequest
{
    EnrollmentName = EnrollmentName.FromProjectLocationEnrollment("[PROJECT]", "[LOCATION]", "[ENROLLMENT]"),
    Etag = "",
    AllowMissing = false,
    ValidateOnly = false,
};
// Make the request
Operation<Enrollment, OperationMetadata> response = await eventarcClient.DeleteEnrollmentAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
DeleteEnrollmentRequest request = new DeleteEnrollmentRequest
{
    EnrollmentName = EnrollmentName.FromProjectLocationEnrollment("[PROJECT]", "[LOCATION]", "[ENROLLMENT]"),
    Etag = "",
    AllowMissing = false,
    ValidateOnly = false,
};
// Make the request
Operation<Enrollment, OperationMetadata> response = await eventarcClient.DeleteEnrollmentAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
EnrollmentName name = EnrollmentName.FromProjectLocationEnrollment("[PROJECT]", "[LOCATION]", "[ENROLLMENT]");
string etag = "";
// Make the request
Operation<Enrollment, OperationMetadata> response = await eventarcClient.DeleteEnrollmentAsync(name, etag);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
EnrollmentName name = EnrollmentName.FromProjectLocationEnrollment("[PROJECT]", "[LOCATION]", "[ENROLLMENT]");
string etag = "";
// Make the request
Operation<Enrollment, OperationMetadata> response = await eventarcClient.DeleteEnrollmentAsync(name, etag);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/enrollments/[ENROLLMENT]";
string etag = "";
// Make the request
Operation<Enrollment, OperationMetadata> response = await eventarcClient.DeleteEnrollmentAsync(name, etag);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/enrollments/[ENROLLMENT]";
string etag = "";
// Make the request
Operation<Enrollment, OperationMetadata> response = await eventarcClient.DeleteEnrollmentAsync(name, etag);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
DeleteGoogleApiSourceRequest request = new DeleteGoogleApiSourceRequest
{
    GoogleApiSourceName = GoogleApiSourceName.FromProjectLocationGoogleApiSource("[PROJECT]", "[LOCATION]", "[GOOGLE_API_SOURCE]"),
    Etag = "",
    AllowMissing = false,
    ValidateOnly = false,
};
// Make the request
Operation<GoogleApiSource, OperationMetadata> response = eventarcClient.DeleteGoogleApiSource(request);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
GoogleApiSourceName name = GoogleApiSourceName.FromProjectLocationGoogleApiSource("[PROJECT]", "[LOCATION]", "[GOOGLE_API_SOURCE]");
string etag = "";
// Make the request
Operation<GoogleApiSource, OperationMetadata> response = eventarcClient.DeleteGoogleApiSource(name, etag);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/googleApiSources/[GOOGLE_API_SOURCE]";
string etag = "";
// Make the request
Operation<GoogleApiSource, OperationMetadata> response = eventarcClient.DeleteGoogleApiSource(name, etag);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
DeleteGoogleApiSourceRequest request = new DeleteGoogleApiSourceRequest
{
    GoogleApiSourceName = GoogleApiSourceName.FromProjectLocationGoogleApiSource("[PROJECT]", "[LOCATION]", "[GOOGLE_API_SOURCE]"),
    Etag = "",
    AllowMissing = false,
    ValidateOnly = false,
};
// Make the request
Operation<GoogleApiSource, OperationMetadata> response = await eventarcClient.DeleteGoogleApiSourceAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
DeleteGoogleApiSourceRequest request = new DeleteGoogleApiSourceRequest
{
    GoogleApiSourceName = GoogleApiSourceName.FromProjectLocationGoogleApiSource("[PROJECT]", "[LOCATION]", "[GOOGLE_API_SOURCE]"),
    Etag = "",
    AllowMissing = false,
    ValidateOnly = false,
};
// Make the request
Operation<GoogleApiSource, OperationMetadata> response = await eventarcClient.DeleteGoogleApiSourceAsync(request);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
GoogleApiSourceName name = GoogleApiSourceName.FromProjectLocationGoogleApiSource("[PROJECT]", "[LOCATION]", "[GOOGLE_API_SOURCE]");
string etag = "";
// Make the request
Operation<GoogleApiSource, OperationMetadata> response = await eventarcClient.DeleteGoogleApiSourceAsync(name, etag);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
GoogleApiSourceName name = GoogleApiSourceName.FromProjectLocationGoogleApiSource("[PROJECT]", "[LOCATION]", "[GOOGLE_API_SOURCE]");
string etag = "";
// Make the request
Operation<GoogleApiSource, OperationMetadata> response = await eventarcClient.DeleteGoogleApiSourceAsync(name, etag);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/googleApiSources/[GOOGLE_API_SOURCE]";
string etag = "";
// Make the request
Operation<GoogleApiSource, OperationMetadata> response = await eventarcClient.DeleteGoogleApiSourceAsync(name, etag);

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

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

// Create client
EventarcClient eventarcClient = await EventarcClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/googleApiSources/[GOOGLE_API_SOURCE]";
string etag = "";
// Make the request
Operation<GoogleApiSource, OperationMetadata> response = await eventarcClient.DeleteGoogleApiSourceAsync(name, etag);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
DeleteMessageBusRequest request = new DeleteMessageBusRequest
{
    MessageBusName = MessageBusName.FromProjectLocationMessageBus("[PROJECT]", "[LOCATION]", "[MESSAGE_BUS]"),
    Etag = "",
    AllowMissing = false,
    ValidateOnly = false,
};
// Make the request
Operation<MessageBus, OperationMetadata> response = eventarcClient.DeleteMessageBus(request);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
MessageBusName name = MessageBusName.FromProjectLocationMessageBus("[PROJECT]", "[LOCATION]", "[MESSAGE_BUS]");
string etag = "";
// Make the request
Operation<MessageBus, OperationMetadata> response = eventarcClient.DeleteMessageBus(name, etag);

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

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

// Create client
EventarcClient eventarcClient = EventarcClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/messageBuses/[MESSAGE_BUS]";
string etag = "";
// Make the request
Operation<MessageBus, OperationMetadata> response = eventarcClient.DeleteMessageBus(name, etag);

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

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