Live Stream v1 API - Class LivestreamServiceClient (1.3.0)

public abstract class LivestreamServiceClient

Namespace

Assembly

Google.Cloud.Video.LiveStream.V1.dll

Remarks

Properties

CreateAssetOperationsClient

public virtual OperationsClient CreateAssetOperationsClient { get; }

CreateChannelOperationsClient

public virtual OperationsClient CreateChannelOperationsClient { get; }

CreateInputOperationsClient

public virtual OperationsClient CreateInputOperationsClient { get; }

DefaultEndpoint

public static string DefaultEndpoint { get; }

DefaultScopes

public static IReadOnlyList<string> DefaultScopes { get; }

DeleteAssetOperationsClient

public virtual OperationsClient DeleteAssetOperationsClient { get; }

DeleteChannelOperationsClient

public virtual OperationsClient DeleteChannelOperationsClient { get; }

DeleteInputOperationsClient

public virtual OperationsClient DeleteInputOperationsClient { get; }

GrpcClient

public virtual LivestreamService.LivestreamServiceClient GrpcClient { get; }

LocationsClient

public virtual LocationsClient LocationsClient { get; }

ServiceMetadata

public static ServiceMetadata ServiceMetadata { get; }

StartChannelOperationsClient

public virtual OperationsClient StartChannelOperationsClient { get; }

StopChannelOperationsClient

public virtual OperationsClient StopChannelOperationsClient { get; }

UpdateChannelOperationsClient

public virtual OperationsClient UpdateChannelOperationsClient { get; }

UpdateInputOperationsClient

public virtual OperationsClient UpdateInputOperationsClient { get; }

UpdatePoolOperationsClient

public virtual OperationsClient UpdatePoolOperationsClient { get; }

Methods

Create()

public static LivestreamServiceClient Create()

CreateAsset(LocationName, Asset, string, CallSettings)

public virtual Operation<Asset, OperationMetadata> CreateAsset(LocationName parent, Asset asset, string assetId, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Asset asset = new Asset();
string assetId = "";
// Make the request
Operation<Asset, OperationMetadata> response = livestreamServiceClient.CreateAsset(parent, asset, assetId);

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

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

CreateAsset(CreateAssetRequest, CallSettings)

public virtual Operation<Asset, OperationMetadata> CreateAsset(CreateAssetRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
CreateAssetRequest request = new CreateAssetRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Asset = new Asset(),
    AssetId = "",
    RequestId = "",
};
// Make the request
Operation<Asset, OperationMetadata> response = livestreamServiceClient.CreateAsset(request);

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

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

CreateAsset(string, Asset, string, CallSettings)

public virtual Operation<Asset, OperationMetadata> CreateAsset(string parent, Asset asset, string assetId, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Asset asset = new Asset();
string assetId = "";
// Make the request
Operation<Asset, OperationMetadata> response = livestreamServiceClient.CreateAsset(parent, asset, assetId);

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

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

CreateAssetAsync(LocationName, Asset, string, CallSettings)

public virtual Task<Operation<Asset, OperationMetadata>> CreateAssetAsync(LocationName parent, Asset asset, string assetId, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Asset asset = new Asset();
string assetId = "";
// Make the request
Operation<Asset, OperationMetadata> response = await livestreamServiceClient.CreateAssetAsync(parent, asset, assetId);

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

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

CreateAssetAsync(LocationName, Asset, string, CancellationToken)

public virtual Task<Operation<Asset, OperationMetadata>> CreateAssetAsync(LocationName parent, Asset asset, string assetId, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Asset asset = new Asset();
string assetId = "";
// Make the request
Operation<Asset, OperationMetadata> response = await livestreamServiceClient.CreateAssetAsync(parent, asset, assetId);

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

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

CreateAssetAsync(CreateAssetRequest, CallSettings)

public virtual Task<Operation<Asset, OperationMetadata>> CreateAssetAsync(CreateAssetRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
CreateAssetRequest request = new CreateAssetRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Asset = new Asset(),
    AssetId = "",
    RequestId = "",
};
// Make the request
Operation<Asset, OperationMetadata> response = await livestreamServiceClient.CreateAssetAsync(request);

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

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

CreateAssetAsync(CreateAssetRequest, CancellationToken)

public virtual Task<Operation<Asset, OperationMetadata>> CreateAssetAsync(CreateAssetRequest request, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
CreateAssetRequest request = new CreateAssetRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Asset = new Asset(),
    AssetId = "",
    RequestId = "",
};
// Make the request
Operation<Asset, OperationMetadata> response = await livestreamServiceClient.CreateAssetAsync(request);

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

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

CreateAssetAsync(string, Asset, string, CallSettings)

public virtual Task<Operation<Asset, OperationMetadata>> CreateAssetAsync(string parent, Asset asset, string assetId, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Asset asset = new Asset();
string assetId = "";
// Make the request
Operation<Asset, OperationMetadata> response = await livestreamServiceClient.CreateAssetAsync(parent, asset, assetId);

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

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

CreateAssetAsync(string, Asset, string, CancellationToken)

public virtual Task<Operation<Asset, OperationMetadata>> CreateAssetAsync(string parent, Asset asset, string assetId, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Asset asset = new Asset();
string assetId = "";
// Make the request
Operation<Asset, OperationMetadata> response = await livestreamServiceClient.CreateAssetAsync(parent, asset, assetId);

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

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

CreateAsync(CancellationToken)

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

CreateChannel(LocationName, Channel, string, CallSettings)

public virtual Operation<Channel, OperationMetadata> CreateChannel(LocationName parent, Channel channel, string channelId, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Channel channel = new Channel();
string channelId = "";
// Make the request
Operation<Channel, OperationMetadata> response = livestreamServiceClient.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 = livestreamServiceClient.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;
}

CreateChannel(CreateChannelRequest, CallSettings)

public virtual Operation<Channel, OperationMetadata> CreateChannel(CreateChannelRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
CreateChannelRequest request = new CreateChannelRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Channel = new Channel(),
    ChannelId = "",
    RequestId = "",
};
// Make the request
Operation<Channel, OperationMetadata> response = livestreamServiceClient.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 = livestreamServiceClient.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;
}

CreateChannel(string, Channel, string, CallSettings)

public virtual Operation<Channel, OperationMetadata> CreateChannel(string parent, Channel channel, string channelId, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Channel channel = new Channel();
string channelId = "";
// Make the request
Operation<Channel, OperationMetadata> response = livestreamServiceClient.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 = livestreamServiceClient.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;
}

CreateChannelAsync(LocationName, Channel, string, CallSettings)

public virtual Task<Operation<Channel, OperationMetadata>> CreateChannelAsync(LocationName parent, Channel channel, string channelId, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.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 livestreamServiceClient.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 livestreamServiceClient.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;
}

CreateChannelAsync(LocationName, Channel, string, CancellationToken)

public virtual Task<Operation<Channel, OperationMetadata>> CreateChannelAsync(LocationName parent, Channel channel, string channelId, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.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 livestreamServiceClient.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 livestreamServiceClient.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;
}

CreateChannelAsync(CreateChannelRequest, CallSettings)

public virtual Task<Operation<Channel, OperationMetadata>> CreateChannelAsync(CreateChannelRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
CreateChannelRequest request = new CreateChannelRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Channel = new Channel(),
    ChannelId = "",
    RequestId = "",
};
// Make the request
Operation<Channel, OperationMetadata> response = await livestreamServiceClient.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 livestreamServiceClient.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;
}

CreateChannelAsync(CreateChannelRequest, CancellationToken)

public virtual Task<Operation<Channel, OperationMetadata>> CreateChannelAsync(CreateChannelRequest request, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
CreateChannelRequest request = new CreateChannelRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Channel = new Channel(),
    ChannelId = "",
    RequestId = "",
};
// Make the request
Operation<Channel, OperationMetadata> response = await livestreamServiceClient.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 livestreamServiceClient.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;
}

CreateChannelAsync(string, Channel, string, CallSettings)

public virtual Task<Operation<Channel, OperationMetadata>> CreateChannelAsync(string parent, Channel channel, string channelId, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.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 livestreamServiceClient.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 livestreamServiceClient.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;
}

CreateChannelAsync(string, Channel, string, CancellationToken)

public virtual Task<Operation<Channel, OperationMetadata>> CreateChannelAsync(string parent, Channel channel, string channelId, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.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 livestreamServiceClient.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 livestreamServiceClient.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;
}

CreateEvent(ChannelName, Event, string, CallSettings)

public virtual Event CreateEvent(ChannelName parent, Event @event, string eventId, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
ChannelName parent = ChannelName.FromProjectLocationChannel("[PROJECT]", "[LOCATION]", "[CHANNEL]");
Event @event = new Event();
string eventId = "";
// Make the request
Event response = livestreamServiceClient.CreateEvent(parent, @event, eventId);

CreateEvent(CreateEventRequest, CallSettings)

public virtual Event CreateEvent(CreateEventRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
CreateEventRequest request = new CreateEventRequest
{
    ParentAsChannelName = ChannelName.FromProjectLocationChannel("[PROJECT]", "[LOCATION]", "[CHANNEL]"),
    Event = new Event(),
    EventId = "",
    RequestId = "",
};
// Make the request
Event response = livestreamServiceClient.CreateEvent(request);

CreateEvent(string, Event, string, CallSettings)

public virtual Event CreateEvent(string parent, Event @event, string eventId, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/channels/[CHANNEL]";
Event @event = new Event();
string eventId = "";
// Make the request
Event response = livestreamServiceClient.CreateEvent(parent, @event, eventId);

CreateEventAsync(ChannelName, Event, string, CallSettings)

public virtual Task<Event> CreateEventAsync(ChannelName parent, Event @event, string eventId, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
ChannelName parent = ChannelName.FromProjectLocationChannel("[PROJECT]", "[LOCATION]", "[CHANNEL]");
Event @event = new Event();
string eventId = "";
// Make the request
Event response = await livestreamServiceClient.CreateEventAsync(parent, @event, eventId);

CreateEventAsync(ChannelName, Event, string, CancellationToken)

public virtual Task<Event> CreateEventAsync(ChannelName parent, Event @event, string eventId, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
ChannelName parent = ChannelName.FromProjectLocationChannel("[PROJECT]", "[LOCATION]", "[CHANNEL]");
Event @event = new Event();
string eventId = "";
// Make the request
Event response = await livestreamServiceClient.CreateEventAsync(parent, @event, eventId);

CreateEventAsync(CreateEventRequest, CallSettings)

public virtual Task<Event> CreateEventAsync(CreateEventRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
CreateEventRequest request = new CreateEventRequest
{
    ParentAsChannelName = ChannelName.FromProjectLocationChannel("[PROJECT]", "[LOCATION]", "[CHANNEL]"),
    Event = new Event(),
    EventId = "",
    RequestId = "",
};
// Make the request
Event response = await livestreamServiceClient.CreateEventAsync(request);

CreateEventAsync(CreateEventRequest, CancellationToken)

public virtual Task<Event> CreateEventAsync(CreateEventRequest request, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
CreateEventRequest request = new CreateEventRequest
{
    ParentAsChannelName = ChannelName.FromProjectLocationChannel("[PROJECT]", "[LOCATION]", "[CHANNEL]"),
    Event = new Event(),
    EventId = "",
    RequestId = "",
};
// Make the request
Event response = await livestreamServiceClient.CreateEventAsync(request);

CreateEventAsync(string, Event, string, CallSettings)

public virtual Task<Event> CreateEventAsync(string parent, Event @event, string eventId, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/channels/[CHANNEL]";
Event @event = new Event();
string eventId = "";
// Make the request
Event response = await livestreamServiceClient.CreateEventAsync(parent, @event, eventId);

CreateEventAsync(string, Event, string, CancellationToken)

public virtual Task<Event> CreateEventAsync(string parent, Event @event, string eventId, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/channels/[CHANNEL]";
Event @event = new Event();
string eventId = "";
// Make the request
Event response = await livestreamServiceClient.CreateEventAsync(parent, @event, eventId);

CreateInput(LocationName, Input, string, CallSettings)

public virtual Operation<Input, OperationMetadata> CreateInput(LocationName parent, Input input, string inputId, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Input input = new Input();
string inputId = "";
// Make the request
Operation<Input, OperationMetadata> response = livestreamServiceClient.CreateInput(parent, input, inputId);

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

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

CreateInput(CreateInputRequest, CallSettings)

public virtual Operation<Input, OperationMetadata> CreateInput(CreateInputRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
CreateInputRequest request = new CreateInputRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Input = new Input(),
    InputId = "",
    RequestId = "",
};
// Make the request
Operation<Input, OperationMetadata> response = livestreamServiceClient.CreateInput(request);

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

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

CreateInput(string, Input, string, CallSettings)

public virtual Operation<Input, OperationMetadata> CreateInput(string parent, Input input, string inputId, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Input input = new Input();
string inputId = "";
// Make the request
Operation<Input, OperationMetadata> response = livestreamServiceClient.CreateInput(parent, input, inputId);

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

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

CreateInputAsync(LocationName, Input, string, CallSettings)

public virtual Task<Operation<Input, OperationMetadata>> CreateInputAsync(LocationName parent, Input input, string inputId, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Input input = new Input();
string inputId = "";
// Make the request
Operation<Input, OperationMetadata> response = await livestreamServiceClient.CreateInputAsync(parent, input, inputId);

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

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

CreateInputAsync(LocationName, Input, string, CancellationToken)

public virtual Task<Operation<Input, OperationMetadata>> CreateInputAsync(LocationName parent, Input input, string inputId, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Input input = new Input();
string inputId = "";
// Make the request
Operation<Input, OperationMetadata> response = await livestreamServiceClient.CreateInputAsync(parent, input, inputId);

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

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

CreateInputAsync(CreateInputRequest, CallSettings)

public virtual Task<Operation<Input, OperationMetadata>> CreateInputAsync(CreateInputRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
CreateInputRequest request = new CreateInputRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Input = new Input(),
    InputId = "",
    RequestId = "",
};
// Make the request
Operation<Input, OperationMetadata> response = await livestreamServiceClient.CreateInputAsync(request);

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

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

CreateInputAsync(CreateInputRequest, CancellationToken)

public virtual Task<Operation<Input, OperationMetadata>> CreateInputAsync(CreateInputRequest request, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
CreateInputRequest request = new CreateInputRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Input = new Input(),
    InputId = "",
    RequestId = "",
};
// Make the request
Operation<Input, OperationMetadata> response = await livestreamServiceClient.CreateInputAsync(request);

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

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

CreateInputAsync(string, Input, string, CallSettings)

public virtual Task<Operation<Input, OperationMetadata>> CreateInputAsync(string parent, Input input, string inputId, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Input input = new Input();
string inputId = "";
// Make the request
Operation<Input, OperationMetadata> response = await livestreamServiceClient.CreateInputAsync(parent, input, inputId);

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

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

CreateInputAsync(string, Input, string, CancellationToken)

public virtual Task<Operation<Input, OperationMetadata>> CreateInputAsync(string parent, Input input, string inputId, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Input input = new Input();
string inputId = "";
// Make the request
Operation<Input, OperationMetadata> response = await livestreamServiceClient.CreateInputAsync(parent, input, inputId);

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

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

DeleteAsset(AssetName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteAsset(AssetName name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
AssetName name = AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]");
// Make the request
Operation<Empty, OperationMetadata> response = livestreamServiceClient.DeleteAsset(name);

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

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

DeleteAsset(DeleteAssetRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteAsset(DeleteAssetRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
DeleteAssetRequest request = new DeleteAssetRequest
{
    AssetName = AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = livestreamServiceClient.DeleteAsset(request);

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

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

DeleteAsset(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteAsset(string name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/assets/[ASSET]";
// Make the request
Operation<Empty, OperationMetadata> response = livestreamServiceClient.DeleteAsset(name);

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

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

DeleteAssetAsync(AssetName, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAssetAsync(AssetName name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
AssetName name = AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]");
// Make the request
Operation<Empty, OperationMetadata> response = await livestreamServiceClient.DeleteAssetAsync(name);

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

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

DeleteAssetAsync(AssetName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAssetAsync(AssetName name, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
AssetName name = AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]");
// Make the request
Operation<Empty, OperationMetadata> response = await livestreamServiceClient.DeleteAssetAsync(name);

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

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

DeleteAssetAsync(DeleteAssetRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAssetAsync(DeleteAssetRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteAssetRequest request = new DeleteAssetRequest
{
    AssetName = AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await livestreamServiceClient.DeleteAssetAsync(request);

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

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

DeleteAssetAsync(DeleteAssetRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAssetAsync(DeleteAssetRequest request, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteAssetRequest request = new DeleteAssetRequest
{
    AssetName = AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await livestreamServiceClient.DeleteAssetAsync(request);

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

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

DeleteAssetAsync(string, CallSettings)

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

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/assets/[ASSET]";
// Make the request
Operation<Empty, OperationMetadata> response = await livestreamServiceClient.DeleteAssetAsync(name);

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

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

DeleteAssetAsync(string, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteAssetAsync(string name, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/assets/[ASSET]";
// Make the request
Operation<Empty, OperationMetadata> response = await livestreamServiceClient.DeleteAssetAsync(name);

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

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

DeleteChannel(ChannelName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteChannel(ChannelName name, CallSettings callSettings = null)

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

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

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

DeleteChannel(DeleteChannelRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteChannel(DeleteChannelRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
DeleteChannelRequest request = new DeleteChannelRequest
{
    ChannelName = ChannelName.FromProjectLocationChannel("[PROJECT]", "[LOCATION]", "[CHANNEL]"),
    RequestId = "",
    Force = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = livestreamServiceClient.DeleteChannel(request);

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

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

DeleteChannel(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteChannel(string name, CallSettings callSettings = null)

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

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

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

DeleteChannelAsync(ChannelName, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteChannelAsync(ChannelName name, CallSettings callSettings = null)

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

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

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

DeleteChannelAsync(ChannelName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteChannelAsync(ChannelName name, CancellationToken cancellationToken)

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

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

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

DeleteChannelAsync(DeleteChannelRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteChannelAsync(DeleteChannelRequest request, CallSettings callSettings = null)

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

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

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

DeleteChannelAsync(DeleteChannelRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteChannelAsync(DeleteChannelRequest request, CancellationToken cancellationToken)

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

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

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

DeleteChannelAsync(string, CallSettings)

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

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

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

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

DeleteChannelAsync(string, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteChannelAsync(string name, CancellationToken cancellationToken)

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

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

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

DeleteEvent(DeleteEventRequest, CallSettings)

public virtual void DeleteEvent(DeleteEventRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
DeleteEventRequest request = new DeleteEventRequest
{
    EventName = EventName.FromProjectLocationChannelEvent("[PROJECT]", "[LOCATION]", "[CHANNEL]", "[EVENT]"),
    RequestId = "",
};
// Make the request
livestreamServiceClient.DeleteEvent(request);

DeleteEvent(EventName, CallSettings)

public virtual void DeleteEvent(EventName name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
EventName name = EventName.FromProjectLocationChannelEvent("[PROJECT]", "[LOCATION]", "[CHANNEL]", "[EVENT]");
// Make the request
livestreamServiceClient.DeleteEvent(name);

DeleteEvent(string, CallSettings)

public virtual void DeleteEvent(string name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/channels/[CHANNEL]/events/[EVENT]";
// Make the request
livestreamServiceClient.DeleteEvent(name);

DeleteEventAsync(DeleteEventRequest, CallSettings)

public virtual Task DeleteEventAsync(DeleteEventRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteEventRequest request = new DeleteEventRequest
{
    EventName = EventName.FromProjectLocationChannelEvent("[PROJECT]", "[LOCATION]", "[CHANNEL]", "[EVENT]"),
    RequestId = "",
};
// Make the request
await livestreamServiceClient.DeleteEventAsync(request);

DeleteEventAsync(DeleteEventRequest, CancellationToken)

public virtual Task DeleteEventAsync(DeleteEventRequest request, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteEventRequest request = new DeleteEventRequest
{
    EventName = EventName.FromProjectLocationChannelEvent("[PROJECT]", "[LOCATION]", "[CHANNEL]", "[EVENT]"),
    RequestId = "",
};
// Make the request
await livestreamServiceClient.DeleteEventAsync(request);

DeleteEventAsync(EventName, CallSettings)

public virtual Task DeleteEventAsync(EventName name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
EventName name = EventName.FromProjectLocationChannelEvent("[PROJECT]", "[LOCATION]", "[CHANNEL]", "[EVENT]");
// Make the request
await livestreamServiceClient.DeleteEventAsync(name);

DeleteEventAsync(EventName, CancellationToken)

public virtual Task DeleteEventAsync(EventName name, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
EventName name = EventName.FromProjectLocationChannelEvent("[PROJECT]", "[LOCATION]", "[CHANNEL]", "[EVENT]");
// Make the request
await livestreamServiceClient.DeleteEventAsync(name);

DeleteEventAsync(string, CallSettings)

public virtual Task DeleteEventAsync(string name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/channels/[CHANNEL]/events/[EVENT]";
// Make the request
await livestreamServiceClient.DeleteEventAsync(name);

DeleteEventAsync(string, CancellationToken)

public virtual Task DeleteEventAsync(string name, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/channels/[CHANNEL]/events/[EVENT]";
// Make the request
await livestreamServiceClient.DeleteEventAsync(name);

DeleteInput(DeleteInputRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteInput(DeleteInputRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
DeleteInputRequest request = new DeleteInputRequest
{
    InputName = InputName.FromProjectLocationInput("[PROJECT]", "[LOCATION]", "[INPUT]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = livestreamServiceClient.DeleteInput(request);

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

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

DeleteInput(InputName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteInput(InputName name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
InputName name = InputName.FromProjectLocationInput("[PROJECT]", "[LOCATION]", "[INPUT]");
// Make the request
Operation<Empty, OperationMetadata> response = livestreamServiceClient.DeleteInput(name);

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

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

DeleteInput(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteInput(string name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/inputs/[INPUT]";
// Make the request
Operation<Empty, OperationMetadata> response = livestreamServiceClient.DeleteInput(name);

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

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

DeleteInputAsync(DeleteInputRequest, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteInputAsync(DeleteInputRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteInputRequest request = new DeleteInputRequest
{
    InputName = InputName.FromProjectLocationInput("[PROJECT]", "[LOCATION]", "[INPUT]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await livestreamServiceClient.DeleteInputAsync(request);

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

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

DeleteInputAsync(DeleteInputRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteInputAsync(DeleteInputRequest request, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteInputRequest request = new DeleteInputRequest
{
    InputName = InputName.FromProjectLocationInput("[PROJECT]", "[LOCATION]", "[INPUT]"),
    RequestId = "",
};
// Make the request
Operation<Empty, OperationMetadata> response = await livestreamServiceClient.DeleteInputAsync(request);

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

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

DeleteInputAsync(InputName, CallSettings)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteInputAsync(InputName name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
InputName name = InputName.FromProjectLocationInput("[PROJECT]", "[LOCATION]", "[INPUT]");
// Make the request
Operation<Empty, OperationMetadata> response = await livestreamServiceClient.DeleteInputAsync(name);

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

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

DeleteInputAsync(InputName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteInputAsync(InputName name, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
InputName name = InputName.FromProjectLocationInput("[PROJECT]", "[LOCATION]", "[INPUT]");
// Make the request
Operation<Empty, OperationMetadata> response = await livestreamServiceClient.DeleteInputAsync(name);

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

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

DeleteInputAsync(string, CallSettings)

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

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/inputs/[INPUT]";
// Make the request
Operation<Empty, OperationMetadata> response = await livestreamServiceClient.DeleteInputAsync(name);

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

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

DeleteInputAsync(string, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteInputAsync(string name, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/inputs/[INPUT]";
// Make the request
Operation<Empty, OperationMetadata> response = await livestreamServiceClient.DeleteInputAsync(name);

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

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

GetAsset(AssetName, CallSettings)

public virtual Asset GetAsset(AssetName name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
AssetName name = AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]");
// Make the request
Asset response = livestreamServiceClient.GetAsset(name);

GetAsset(GetAssetRequest, CallSettings)

public virtual Asset GetAsset(GetAssetRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
GetAssetRequest request = new GetAssetRequest
{
    AssetName = AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]"),
};
// Make the request
Asset response = livestreamServiceClient.GetAsset(request);

GetAsset(string, CallSettings)

public virtual Asset GetAsset(string name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/assets/[ASSET]";
// Make the request
Asset response = livestreamServiceClient.GetAsset(name);

GetAssetAsync(AssetName, CallSettings)

public virtual Task<Asset> GetAssetAsync(AssetName name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
AssetName name = AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]");
// Make the request
Asset response = await livestreamServiceClient.GetAssetAsync(name);

GetAssetAsync(AssetName, CancellationToken)

public virtual Task<Asset> GetAssetAsync(AssetName name, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
AssetName name = AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]");
// Make the request
Asset response = await livestreamServiceClient.GetAssetAsync(name);

GetAssetAsync(GetAssetRequest, CallSettings)

public virtual Task<Asset> GetAssetAsync(GetAssetRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
GetAssetRequest request = new GetAssetRequest
{
    AssetName = AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]"),
};
// Make the request
Asset response = await livestreamServiceClient.GetAssetAsync(request);

GetAssetAsync(GetAssetRequest, CancellationToken)

public virtual Task<Asset> GetAssetAsync(GetAssetRequest request, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
GetAssetRequest request = new GetAssetRequest
{
    AssetName = AssetName.FromProjectLocationAsset("[PROJECT]", "[LOCATION]", "[ASSET]"),
};
// Make the request
Asset response = await livestreamServiceClient.GetAssetAsync(request);

GetAssetAsync(string, CallSettings)

public virtual Task<Asset> GetAssetAsync(string name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/assets/[ASSET]";
// Make the request
Asset response = await livestreamServiceClient.GetAssetAsync(name);

GetAssetAsync(string, CancellationToken)

public virtual Task<Asset> GetAssetAsync(string name, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/assets/[ASSET]";
// Make the request
Asset response = await livestreamServiceClient.GetAssetAsync(name);

GetChannel(ChannelName, CallSettings)

public virtual Channel GetChannel(ChannelName name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
ChannelName name = ChannelName.FromProjectLocationChannel("[PROJECT]", "[LOCATION]", "[CHANNEL]");
// Make the request
Channel response = livestreamServiceClient.GetChannel(name);

GetChannel(GetChannelRequest, CallSettings)

public virtual Channel GetChannel(GetChannelRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
GetChannelRequest request = new GetChannelRequest
{
    ChannelName = ChannelName.FromProjectLocationChannel("[PROJECT]", "[LOCATION]", "[CHANNEL]"),
};
// Make the request
Channel response = livestreamServiceClient.GetChannel(request);

GetChannel(string, CallSettings)

public virtual Channel GetChannel(string name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/channels/[CHANNEL]";
// Make the request
Channel response = livestreamServiceClient.GetChannel(name);

GetChannelAsync(ChannelName, CallSettings)

public virtual Task<Channel> GetChannelAsync(ChannelName name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
ChannelName name = ChannelName.FromProjectLocationChannel("[PROJECT]", "[LOCATION]", "[CHANNEL]");
// Make the request
Channel response = await livestreamServiceClient.GetChannelAsync(name);

GetChannelAsync(ChannelName, CancellationToken)

public virtual Task<Channel> GetChannelAsync(ChannelName name, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
ChannelName name = ChannelName.FromProjectLocationChannel("[PROJECT]", "[LOCATION]", "[CHANNEL]");
// Make the request
Channel response = await livestreamServiceClient.GetChannelAsync(name);

GetChannelAsync(GetChannelRequest, CallSettings)

public virtual Task<Channel> GetChannelAsync(GetChannelRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
GetChannelRequest request = new GetChannelRequest
{
    ChannelName = ChannelName.FromProjectLocationChannel("[PROJECT]", "[LOCATION]", "[CHANNEL]"),
};
// Make the request
Channel response = await livestreamServiceClient.GetChannelAsync(request);

GetChannelAsync(GetChannelRequest, CancellationToken)

public virtual Task<Channel> GetChannelAsync(GetChannelRequest request, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
GetChannelRequest request = new GetChannelRequest
{
    ChannelName = ChannelName.FromProjectLocationChannel("[PROJECT]", "[LOCATION]", "[CHANNEL]"),
};
// Make the request
Channel response = await livestreamServiceClient.GetChannelAsync(request);

GetChannelAsync(string, CallSettings)

public virtual Task<Channel> GetChannelAsync(string name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/channels/[CHANNEL]";
// Make the request
Channel response = await livestreamServiceClient.GetChannelAsync(name);

GetChannelAsync(string, CancellationToken)

public virtual Task<Channel> GetChannelAsync(string name, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/channels/[CHANNEL]";
// Make the request
Channel response = await livestreamServiceClient.GetChannelAsync(name);

GetEvent(EventName, CallSettings)

public virtual Event GetEvent(EventName name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
EventName name = EventName.FromProjectLocationChannelEvent("[PROJECT]", "[LOCATION]", "[CHANNEL]", "[EVENT]");
// Make the request
Event response = livestreamServiceClient.GetEvent(name);

GetEvent(GetEventRequest, CallSettings)

public virtual Event GetEvent(GetEventRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
GetEventRequest request = new GetEventRequest
{
    EventName = EventName.FromProjectLocationChannelEvent("[PROJECT]", "[LOCATION]", "[CHANNEL]", "[EVENT]"),
};
// Make the request
Event response = livestreamServiceClient.GetEvent(request);

GetEvent(string, CallSettings)

public virtual Event GetEvent(string name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/channels/[CHANNEL]/events/[EVENT]";
// Make the request
Event response = livestreamServiceClient.GetEvent(name);

GetEventAsync(EventName, CallSettings)

public virtual Task<Event> GetEventAsync(EventName name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
EventName name = EventName.FromProjectLocationChannelEvent("[PROJECT]", "[LOCATION]", "[CHANNEL]", "[EVENT]");
// Make the request
Event response = await livestreamServiceClient.GetEventAsync(name);

GetEventAsync(EventName, CancellationToken)

public virtual Task<Event> GetEventAsync(EventName name, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
EventName name = EventName.FromProjectLocationChannelEvent("[PROJECT]", "[LOCATION]", "[CHANNEL]", "[EVENT]");
// Make the request
Event response = await livestreamServiceClient.GetEventAsync(name);

GetEventAsync(GetEventRequest, CallSettings)

public virtual Task<Event> GetEventAsync(GetEventRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
GetEventRequest request = new GetEventRequest
{
    EventName = EventName.FromProjectLocationChannelEvent("[PROJECT]", "[LOCATION]", "[CHANNEL]", "[EVENT]"),
};
// Make the request
Event response = await livestreamServiceClient.GetEventAsync(request);

GetEventAsync(GetEventRequest, CancellationToken)

public virtual Task<Event> GetEventAsync(GetEventRequest request, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
GetEventRequest request = new GetEventRequest
{
    EventName = EventName.FromProjectLocationChannelEvent("[PROJECT]", "[LOCATION]", "[CHANNEL]", "[EVENT]"),
};
// Make the request
Event response = await livestreamServiceClient.GetEventAsync(request);

GetEventAsync(string, CallSettings)

public virtual Task<Event> GetEventAsync(string name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/channels/[CHANNEL]/events/[EVENT]";
// Make the request
Event response = await livestreamServiceClient.GetEventAsync(name);

GetEventAsync(string, CancellationToken)

public virtual Task<Event> GetEventAsync(string name, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/channels/[CHANNEL]/events/[EVENT]";
// Make the request
Event response = await livestreamServiceClient.GetEventAsync(name);

GetInput(GetInputRequest, CallSettings)

public virtual Input GetInput(GetInputRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
GetInputRequest request = new GetInputRequest
{
    InputName = InputName.FromProjectLocationInput("[PROJECT]", "[LOCATION]", "[INPUT]"),
};
// Make the request
Input response = livestreamServiceClient.GetInput(request);

GetInput(InputName, CallSettings)

public virtual Input GetInput(InputName name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
InputName name = InputName.FromProjectLocationInput("[PROJECT]", "[LOCATION]", "[INPUT]");
// Make the request
Input response = livestreamServiceClient.GetInput(name);

GetInput(string, CallSettings)

public virtual Input GetInput(string name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/inputs/[INPUT]";
// Make the request
Input response = livestreamServiceClient.GetInput(name);

GetInputAsync(GetInputRequest, CallSettings)

public virtual Task<Input> GetInputAsync(GetInputRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
GetInputRequest request = new GetInputRequest
{
    InputName = InputName.FromProjectLocationInput("[PROJECT]", "[LOCATION]", "[INPUT]"),
};
// Make the request
Input response = await livestreamServiceClient.GetInputAsync(request);

GetInputAsync(GetInputRequest, CancellationToken)

public virtual Task<Input> GetInputAsync(GetInputRequest request, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
GetInputRequest request = new GetInputRequest
{
    InputName = InputName.FromProjectLocationInput("[PROJECT]", "[LOCATION]", "[INPUT]"),
};
// Make the request
Input response = await livestreamServiceClient.GetInputAsync(request);

GetInputAsync(InputName, CallSettings)

public virtual Task<Input> GetInputAsync(InputName name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
InputName name = InputName.FromProjectLocationInput("[PROJECT]", "[LOCATION]", "[INPUT]");
// Make the request
Input response = await livestreamServiceClient.GetInputAsync(name);

GetInputAsync(InputName, CancellationToken)

public virtual Task<Input> GetInputAsync(InputName name, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
InputName name = InputName.FromProjectLocationInput("[PROJECT]", "[LOCATION]", "[INPUT]");
// Make the request
Input response = await livestreamServiceClient.GetInputAsync(name);

GetInputAsync(string, CallSettings)

public virtual Task<Input> GetInputAsync(string name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/inputs/[INPUT]";
// Make the request
Input response = await livestreamServiceClient.GetInputAsync(name);

GetInputAsync(string, CancellationToken)

public virtual Task<Input> GetInputAsync(string name, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/inputs/[INPUT]";
// Make the request
Input response = await livestreamServiceClient.GetInputAsync(name);

GetPool(GetPoolRequest, CallSettings)

public virtual Pool GetPool(GetPoolRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
GetPoolRequest request = new GetPoolRequest
{
    PoolName = PoolName.FromProjectLocationPool("[PROJECT]", "[LOCATION]", "[POOL]"),
};
// Make the request
Pool response = livestreamServiceClient.GetPool(request);

GetPool(PoolName, CallSettings)

public virtual Pool GetPool(PoolName name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
PoolName name = PoolName.FromProjectLocationPool("[PROJECT]", "[LOCATION]", "[POOL]");
// Make the request
Pool response = livestreamServiceClient.GetPool(name);

GetPool(string, CallSettings)

public virtual Pool GetPool(string name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/pools/[POOL]";
// Make the request
Pool response = livestreamServiceClient.GetPool(name);

GetPoolAsync(GetPoolRequest, CallSettings)

public virtual Task<Pool> GetPoolAsync(GetPoolRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
GetPoolRequest request = new GetPoolRequest
{
    PoolName = PoolName.FromProjectLocationPool("[PROJECT]", "[LOCATION]", "[POOL]"),
};
// Make the request
Pool response = await livestreamServiceClient.GetPoolAsync(request);

GetPoolAsync(GetPoolRequest, CancellationToken)

public virtual Task<Pool> GetPoolAsync(GetPoolRequest request, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
GetPoolRequest request = new GetPoolRequest
{
    PoolName = PoolName.FromProjectLocationPool("[PROJECT]", "[LOCATION]", "[POOL]"),
};
// Make the request
Pool response = await livestreamServiceClient.GetPoolAsync(request);

GetPoolAsync(PoolName, CallSettings)

public virtual Task<Pool> GetPoolAsync(PoolName name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
PoolName name = PoolName.FromProjectLocationPool("[PROJECT]", "[LOCATION]", "[POOL]");
// Make the request
Pool response = await livestreamServiceClient.GetPoolAsync(name);

GetPoolAsync(PoolName, CancellationToken)

public virtual Task<Pool> GetPoolAsync(PoolName name, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
PoolName name = PoolName.FromProjectLocationPool("[PROJECT]", "[LOCATION]", "[POOL]");
// Make the request
Pool response = await livestreamServiceClient.GetPoolAsync(name);

GetPoolAsync(string, CallSettings)

public virtual Task<Pool> GetPoolAsync(string name, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/pools/[POOL]";
// Make the request
Pool response = await livestreamServiceClient.GetPoolAsync(name);

GetPoolAsync(string, CancellationToken)

public virtual Task<Pool> GetPoolAsync(string name, CancellationToken cancellationToken)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/pools/[POOL]";
// Make the request
Pool response = await livestreamServiceClient.GetPoolAsync(name);

ListAssets(LocationName, string, int?, CallSettings)

public virtual PagedEnumerable<ListAssetsResponse, Asset> ListAssets(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListAssetsResponse, Asset> response = livestreamServiceClient.ListAssets(parent);

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

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

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

ListAssets(ListAssetsRequest, CallSettings)

public virtual PagedEnumerable<ListAssetsResponse, Asset> ListAssets(ListAssetsRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
ListAssetsRequest request = new ListAssetsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedEnumerable<ListAssetsResponse, Asset> response = livestreamServiceClient.ListAssets(request);

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

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

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

ListAssets(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListAssetsResponse, Asset> ListAssets(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = LivestreamServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListAssetsResponse, Asset> response = livestreamServiceClient.ListAssets(parent);

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

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

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

ListAssetsAsync(LocationName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListAssetsResponse, Asset> ListAssetsAsync(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListAssetsResponse, Asset> response = livestreamServiceClient.ListAssetsAsync(parent);

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

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

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

ListAssetsAsync(ListAssetsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListAssetsResponse, Asset> ListAssetsAsync(ListAssetsRequest request, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
ListAssetsRequest request = new ListAssetsRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    OrderBy = "",
};
// Make the request
PagedAsyncEnumerable<ListAssetsResponse, Asset> response = livestreamServiceClient.ListAssetsAsync(request);

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

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

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

ListAssetsAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListAssetsResponse, Asset> ListAssetsAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
LivestreamServiceClient livestreamServiceClient = await LivestreamServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListAssetsResponse, Asset> response = livestreamServiceClient.ListAssetsAsync(parent);

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

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

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

ListChannels(LocationName, string, int?, CallSettings)

public virtual PagedEnumerable<ListChannelsResponse, Channel> ListChannels(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)