Data Lineage v1 API - Class LineageClient (1.1.0)

public abstract class LineageClient

Namespace

Assembly

Google.Cloud.DataCatalog.Lineage.V1.dll

Remarks

Properties

DefaultEndpoint

public static string DefaultEndpoint { get; }

DefaultScopes

public static IReadOnlyList<string> DefaultScopes { get; }

DeleteProcessOperationsClient

public virtual OperationsClient DeleteProcessOperationsClient { get; }

DeleteRunOperationsClient

public virtual OperationsClient DeleteRunOperationsClient { get; }

GrpcClient

public virtual Lineage.LineageClient GrpcClient { get; }

ServiceMetadata

public static ServiceMetadata ServiceMetadata { get; }

Methods

BatchSearchLinkProcesses(BatchSearchLinkProcessesRequest, CallSettings)

public virtual PagedEnumerable<BatchSearchLinkProcessesResponse, ProcessLinks> BatchSearchLinkProcesses(BatchSearchLinkProcessesRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
BatchSearchLinkProcessesRequest request = new BatchSearchLinkProcessesRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Links = { "", },
};
// Make the request
PagedEnumerable<BatchSearchLinkProcessesResponse, ProcessLinks> response = lineageClient.BatchSearchLinkProcesses(request);

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

BatchSearchLinkProcessesAsync(BatchSearchLinkProcessesRequest, CallSettings)

public virtual PagedAsyncEnumerable<BatchSearchLinkProcessesResponse, ProcessLinks> BatchSearchLinkProcessesAsync(BatchSearchLinkProcessesRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
BatchSearchLinkProcessesRequest request = new BatchSearchLinkProcessesRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Links = { "", },
};
// Make the request
PagedAsyncEnumerable<BatchSearchLinkProcessesResponse, ProcessLinks> response = lineageClient.BatchSearchLinkProcessesAsync(request);

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

Create()

public static LineageClient Create()

CreateAsync(CancellationToken)

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

CreateLineageEvent(CreateLineageEventRequest, CallSettings)

public virtual LineageEvent CreateLineageEvent(CreateLineageEventRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
CreateLineageEventRequest request = new CreateLineageEventRequest
{
    ParentAsRunName = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]"),
    LineageEvent = new LineageEvent(),
    RequestId = "",
};
// Make the request
LineageEvent response = lineageClient.CreateLineageEvent(request);

CreateLineageEvent(RunName, LineageEvent, CallSettings)

public virtual LineageEvent CreateLineageEvent(RunName parent, LineageEvent lineageEvent, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
RunName parent = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]");
LineageEvent lineageEvent = new LineageEvent();
// Make the request
LineageEvent response = lineageClient.CreateLineageEvent(parent, lineageEvent);

CreateLineageEvent(string, LineageEvent, CallSettings)

public virtual LineageEvent CreateLineageEvent(string parent, LineageEvent lineageEvent, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]/runs/[RUN]";
LineageEvent lineageEvent = new LineageEvent();
// Make the request
LineageEvent response = lineageClient.CreateLineageEvent(parent, lineageEvent);

CreateLineageEventAsync(CreateLineageEventRequest, CallSettings)

public virtual Task<LineageEvent> CreateLineageEventAsync(CreateLineageEventRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
CreateLineageEventRequest request = new CreateLineageEventRequest
{
    ParentAsRunName = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]"),
    LineageEvent = new LineageEvent(),
    RequestId = "",
};
// Make the request
LineageEvent response = await lineageClient.CreateLineageEventAsync(request);

CreateLineageEventAsync(CreateLineageEventRequest, CancellationToken)

public virtual Task<LineageEvent> CreateLineageEventAsync(CreateLineageEventRequest request, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
CreateLineageEventRequest request = new CreateLineageEventRequest
{
    ParentAsRunName = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]"),
    LineageEvent = new LineageEvent(),
    RequestId = "",
};
// Make the request
LineageEvent response = await lineageClient.CreateLineageEventAsync(request);

CreateLineageEventAsync(RunName, LineageEvent, CallSettings)

public virtual Task<LineageEvent> CreateLineageEventAsync(RunName parent, LineageEvent lineageEvent, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
RunName parent = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]");
LineageEvent lineageEvent = new LineageEvent();
// Make the request
LineageEvent response = await lineageClient.CreateLineageEventAsync(parent, lineageEvent);

CreateLineageEventAsync(RunName, LineageEvent, CancellationToken)

public virtual Task<LineageEvent> CreateLineageEventAsync(RunName parent, LineageEvent lineageEvent, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
RunName parent = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]");
LineageEvent lineageEvent = new LineageEvent();
// Make the request
LineageEvent response = await lineageClient.CreateLineageEventAsync(parent, lineageEvent);

CreateLineageEventAsync(string, LineageEvent, CallSettings)

public virtual Task<LineageEvent> CreateLineageEventAsync(string parent, LineageEvent lineageEvent, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]/runs/[RUN]";
LineageEvent lineageEvent = new LineageEvent();
// Make the request
LineageEvent response = await lineageClient.CreateLineageEventAsync(parent, lineageEvent);

CreateLineageEventAsync(string, LineageEvent, CancellationToken)

public virtual Task<LineageEvent> CreateLineageEventAsync(string parent, LineageEvent lineageEvent, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]/runs/[RUN]";
LineageEvent lineageEvent = new LineageEvent();
// Make the request
LineageEvent response = await lineageClient.CreateLineageEventAsync(parent, lineageEvent);

CreateProcess(LocationName, Process, CallSettings)

public virtual Process CreateProcess(LocationName parent, Process process, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Process process = new Process();
// Make the request
Process response = lineageClient.CreateProcess(parent, process);

CreateProcess(CreateProcessRequest, CallSettings)

public virtual Process CreateProcess(CreateProcessRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
CreateProcessRequest request = new CreateProcessRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Process = new Process(),
    RequestId = "",
};
// Make the request
Process response = lineageClient.CreateProcess(request);

CreateProcess(string, Process, CallSettings)

public virtual Process CreateProcess(string parent, Process process, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Process process = new Process();
// Make the request
Process response = lineageClient.CreateProcess(parent, process);

CreateProcessAsync(LocationName, Process, CallSettings)

public virtual Task<Process> CreateProcessAsync(LocationName parent, Process process, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Process process = new Process();
// Make the request
Process response = await lineageClient.CreateProcessAsync(parent, process);

CreateProcessAsync(LocationName, Process, CancellationToken)

public virtual Task<Process> CreateProcessAsync(LocationName parent, Process process, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Process process = new Process();
// Make the request
Process response = await lineageClient.CreateProcessAsync(parent, process);

CreateProcessAsync(CreateProcessRequest, CallSettings)

public virtual Task<Process> CreateProcessAsync(CreateProcessRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
CreateProcessRequest request = new CreateProcessRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Process = new Process(),
    RequestId = "",
};
// Make the request
Process response = await lineageClient.CreateProcessAsync(request);

CreateProcessAsync(CreateProcessRequest, CancellationToken)

public virtual Task<Process> CreateProcessAsync(CreateProcessRequest request, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
CreateProcessRequest request = new CreateProcessRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Process = new Process(),
    RequestId = "",
};
// Make the request
Process response = await lineageClient.CreateProcessAsync(request);

CreateProcessAsync(string, Process, CallSettings)

public virtual Task<Process> CreateProcessAsync(string parent, Process process, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Process process = new Process();
// Make the request
Process response = await lineageClient.CreateProcessAsync(parent, process);

CreateProcessAsync(string, Process, CancellationToken)

public virtual Task<Process> CreateProcessAsync(string parent, Process process, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Process process = new Process();
// Make the request
Process response = await lineageClient.CreateProcessAsync(parent, process);

CreateRun(CreateRunRequest, CallSettings)

public virtual Run CreateRun(CreateRunRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
CreateRunRequest request = new CreateRunRequest
{
    ParentAsProcessName = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]"),
    Run = new Run(),
    RequestId = "",
};
// Make the request
Run response = lineageClient.CreateRun(request);

CreateRun(ProcessName, Run, CallSettings)

public virtual Run CreateRun(ProcessName parent, Run run, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
ProcessName parent = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]");
Run run = new Run();
// Make the request
Run response = lineageClient.CreateRun(parent, run);

CreateRun(string, Run, CallSettings)

public virtual Run CreateRun(string parent, Run run, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]";
Run run = new Run();
// Make the request
Run response = lineageClient.CreateRun(parent, run);

CreateRunAsync(CreateRunRequest, CallSettings)

public virtual Task<Run> CreateRunAsync(CreateRunRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
CreateRunRequest request = new CreateRunRequest
{
    ParentAsProcessName = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]"),
    Run = new Run(),
    RequestId = "",
};
// Make the request
Run response = await lineageClient.CreateRunAsync(request);

CreateRunAsync(CreateRunRequest, CancellationToken)

public virtual Task<Run> CreateRunAsync(CreateRunRequest request, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
CreateRunRequest request = new CreateRunRequest
{
    ParentAsProcessName = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]"),
    Run = new Run(),
    RequestId = "",
};
// Make the request
Run response = await lineageClient.CreateRunAsync(request);

CreateRunAsync(ProcessName, Run, CallSettings)

public virtual Task<Run> CreateRunAsync(ProcessName parent, Run run, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
ProcessName parent = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]");
Run run = new Run();
// Make the request
Run response = await lineageClient.CreateRunAsync(parent, run);

CreateRunAsync(ProcessName, Run, CancellationToken)

public virtual Task<Run> CreateRunAsync(ProcessName parent, Run run, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
ProcessName parent = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]");
Run run = new Run();
// Make the request
Run response = await lineageClient.CreateRunAsync(parent, run);

CreateRunAsync(string, Run, CallSettings)

public virtual Task<Run> CreateRunAsync(string parent, Run run, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]";
Run run = new Run();
// Make the request
Run response = await lineageClient.CreateRunAsync(parent, run);

CreateRunAsync(string, Run, CancellationToken)

public virtual Task<Run> CreateRunAsync(string parent, Run run, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]";
Run run = new Run();
// Make the request
Run response = await lineageClient.CreateRunAsync(parent, run);

DeleteLineageEvent(DeleteLineageEventRequest, CallSettings)

public virtual void DeleteLineageEvent(DeleteLineageEventRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
DeleteLineageEventRequest request = new DeleteLineageEventRequest
{
    LineageEventName = LineageEventName.FromProjectLocationProcessRunLineageEvent("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]", "[LINEAGE_EVENT]"),
    AllowMissing = false,
};
// Make the request
lineageClient.DeleteLineageEvent(request);

DeleteLineageEvent(LineageEventName, CallSettings)

public virtual void DeleteLineageEvent(LineageEventName name, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
LineageEventName name = LineageEventName.FromProjectLocationProcessRunLineageEvent("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]", "[LINEAGE_EVENT]");
// Make the request
lineageClient.DeleteLineageEvent(name);

DeleteLineageEvent(string, CallSettings)

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

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]/runs/[RUN]/lineageEvents/[LINEAGE_EVENT]";
// Make the request
lineageClient.DeleteLineageEvent(name);

DeleteLineageEventAsync(DeleteLineageEventRequest, CallSettings)

public virtual Task DeleteLineageEventAsync(DeleteLineageEventRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
DeleteLineageEventRequest request = new DeleteLineageEventRequest
{
    LineageEventName = LineageEventName.FromProjectLocationProcessRunLineageEvent("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]", "[LINEAGE_EVENT]"),
    AllowMissing = false,
};
// Make the request
await lineageClient.DeleteLineageEventAsync(request);

DeleteLineageEventAsync(DeleteLineageEventRequest, CancellationToken)

public virtual Task DeleteLineageEventAsync(DeleteLineageEventRequest request, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
DeleteLineageEventRequest request = new DeleteLineageEventRequest
{
    LineageEventName = LineageEventName.FromProjectLocationProcessRunLineageEvent("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]", "[LINEAGE_EVENT]"),
    AllowMissing = false,
};
// Make the request
await lineageClient.DeleteLineageEventAsync(request);

DeleteLineageEventAsync(LineageEventName, CallSettings)

public virtual Task DeleteLineageEventAsync(LineageEventName name, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
LineageEventName name = LineageEventName.FromProjectLocationProcessRunLineageEvent("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]", "[LINEAGE_EVENT]");
// Make the request
await lineageClient.DeleteLineageEventAsync(name);

DeleteLineageEventAsync(LineageEventName, CancellationToken)

public virtual Task DeleteLineageEventAsync(LineageEventName name, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
LineageEventName name = LineageEventName.FromProjectLocationProcessRunLineageEvent("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]", "[LINEAGE_EVENT]");
// Make the request
await lineageClient.DeleteLineageEventAsync(name);

DeleteLineageEventAsync(string, CallSettings)

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

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]/runs/[RUN]/lineageEvents/[LINEAGE_EVENT]";
// Make the request
await lineageClient.DeleteLineageEventAsync(name);

DeleteLineageEventAsync(string, CancellationToken)

public virtual Task DeleteLineageEventAsync(string name, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]/runs/[RUN]/lineageEvents/[LINEAGE_EVENT]";
// Make the request
await lineageClient.DeleteLineageEventAsync(name);

DeleteProcess(DeleteProcessRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteProcess(DeleteProcessRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
DeleteProcessRequest request = new DeleteProcessRequest
{
    ProcessName = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]"),
    AllowMissing = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = lineageClient.DeleteProcess(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 = lineageClient.PollOnceDeleteProcess(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;
}

DeleteProcess(ProcessName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteProcess(ProcessName name, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
ProcessName name = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]");
// Make the request
Operation<Empty, OperationMetadata> response = lineageClient.DeleteProcess(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 = lineageClient.PollOnceDeleteProcess(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;
}

DeleteProcess(string, CallSettings)

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

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]";
// Make the request
Operation<Empty, OperationMetadata> response = lineageClient.DeleteProcess(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 = lineageClient.PollOnceDeleteProcess(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;
}

DeleteProcessAsync(DeleteProcessRequest, CallSettings)

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

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
DeleteProcessRequest request = new DeleteProcessRequest
{
    ProcessName = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]"),
    AllowMissing = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await lineageClient.DeleteProcessAsync(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 lineageClient.PollOnceDeleteProcessAsync(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;
}

DeleteProcessAsync(DeleteProcessRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteProcessAsync(DeleteProcessRequest request, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
DeleteProcessRequest request = new DeleteProcessRequest
{
    ProcessName = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]"),
    AllowMissing = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await lineageClient.DeleteProcessAsync(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 lineageClient.PollOnceDeleteProcessAsync(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;
}

DeleteProcessAsync(ProcessName, CallSettings)

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

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
ProcessName name = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]");
// Make the request
Operation<Empty, OperationMetadata> response = await lineageClient.DeleteProcessAsync(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 lineageClient.PollOnceDeleteProcessAsync(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;
}

DeleteProcessAsync(ProcessName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteProcessAsync(ProcessName name, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
ProcessName name = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]");
// Make the request
Operation<Empty, OperationMetadata> response = await lineageClient.DeleteProcessAsync(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 lineageClient.PollOnceDeleteProcessAsync(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;
}

DeleteProcessAsync(string, CallSettings)

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

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]";
// Make the request
Operation<Empty, OperationMetadata> response = await lineageClient.DeleteProcessAsync(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 lineageClient.PollOnceDeleteProcessAsync(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;
}

DeleteProcessAsync(string, CancellationToken)

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

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]";
// Make the request
Operation<Empty, OperationMetadata> response = await lineageClient.DeleteProcessAsync(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 lineageClient.PollOnceDeleteProcessAsync(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;
}

DeleteRun(DeleteRunRequest, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteRun(DeleteRunRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
DeleteRunRequest request = new DeleteRunRequest
{
    RunName = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]"),
    AllowMissing = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = lineageClient.DeleteRun(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 = lineageClient.PollOnceDeleteRun(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;
}

DeleteRun(RunName, CallSettings)

public virtual Operation<Empty, OperationMetadata> DeleteRun(RunName name, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
RunName name = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]");
// Make the request
Operation<Empty, OperationMetadata> response = lineageClient.DeleteRun(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 = lineageClient.PollOnceDeleteRun(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;
}

DeleteRun(string, CallSettings)

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

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]/runs/[RUN]";
// Make the request
Operation<Empty, OperationMetadata> response = lineageClient.DeleteRun(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 = lineageClient.PollOnceDeleteRun(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;
}

DeleteRunAsync(DeleteRunRequest, CallSettings)

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

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
DeleteRunRequest request = new DeleteRunRequest
{
    RunName = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]"),
    AllowMissing = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await lineageClient.DeleteRunAsync(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 lineageClient.PollOnceDeleteRunAsync(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;
}

DeleteRunAsync(DeleteRunRequest, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteRunAsync(DeleteRunRequest request, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
DeleteRunRequest request = new DeleteRunRequest
{
    RunName = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]"),
    AllowMissing = false,
};
// Make the request
Operation<Empty, OperationMetadata> response = await lineageClient.DeleteRunAsync(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 lineageClient.PollOnceDeleteRunAsync(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;
}

DeleteRunAsync(RunName, CallSettings)

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

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
RunName name = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]");
// Make the request
Operation<Empty, OperationMetadata> response = await lineageClient.DeleteRunAsync(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 lineageClient.PollOnceDeleteRunAsync(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;
}

DeleteRunAsync(RunName, CancellationToken)

public virtual Task<Operation<Empty, OperationMetadata>> DeleteRunAsync(RunName name, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
RunName name = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]");
// Make the request
Operation<Empty, OperationMetadata> response = await lineageClient.DeleteRunAsync(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 lineageClient.PollOnceDeleteRunAsync(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;
}

DeleteRunAsync(string, CallSettings)

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

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]/runs/[RUN]";
// Make the request
Operation<Empty, OperationMetadata> response = await lineageClient.DeleteRunAsync(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 lineageClient.PollOnceDeleteRunAsync(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;
}

DeleteRunAsync(string, CancellationToken)

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

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]/runs/[RUN]";
// Make the request
Operation<Empty, OperationMetadata> response = await lineageClient.DeleteRunAsync(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 lineageClient.PollOnceDeleteRunAsync(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;
}

GetLineageEvent(GetLineageEventRequest, CallSettings)

public virtual LineageEvent GetLineageEvent(GetLineageEventRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
GetLineageEventRequest request = new GetLineageEventRequest
{
    LineageEventName = LineageEventName.FromProjectLocationProcessRunLineageEvent("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]", "[LINEAGE_EVENT]"),
};
// Make the request
LineageEvent response = lineageClient.GetLineageEvent(request);

GetLineageEvent(LineageEventName, CallSettings)

public virtual LineageEvent GetLineageEvent(LineageEventName name, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
LineageEventName name = LineageEventName.FromProjectLocationProcessRunLineageEvent("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]", "[LINEAGE_EVENT]");
// Make the request
LineageEvent response = lineageClient.GetLineageEvent(name);

GetLineageEvent(string, CallSettings)

public virtual LineageEvent GetLineageEvent(string name, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]/runs/[RUN]/lineageEvents/[LINEAGE_EVENT]";
// Make the request
LineageEvent response = lineageClient.GetLineageEvent(name);

GetLineageEventAsync(GetLineageEventRequest, CallSettings)

public virtual Task<LineageEvent> GetLineageEventAsync(GetLineageEventRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
GetLineageEventRequest request = new GetLineageEventRequest
{
    LineageEventName = LineageEventName.FromProjectLocationProcessRunLineageEvent("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]", "[LINEAGE_EVENT]"),
};
// Make the request
LineageEvent response = await lineageClient.GetLineageEventAsync(request);

GetLineageEventAsync(GetLineageEventRequest, CancellationToken)

public virtual Task<LineageEvent> GetLineageEventAsync(GetLineageEventRequest request, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
GetLineageEventRequest request = new GetLineageEventRequest
{
    LineageEventName = LineageEventName.FromProjectLocationProcessRunLineageEvent("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]", "[LINEAGE_EVENT]"),
};
// Make the request
LineageEvent response = await lineageClient.GetLineageEventAsync(request);

GetLineageEventAsync(LineageEventName, CallSettings)

public virtual Task<LineageEvent> GetLineageEventAsync(LineageEventName name, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
LineageEventName name = LineageEventName.FromProjectLocationProcessRunLineageEvent("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]", "[LINEAGE_EVENT]");
// Make the request
LineageEvent response = await lineageClient.GetLineageEventAsync(name);

GetLineageEventAsync(LineageEventName, CancellationToken)

public virtual Task<LineageEvent> GetLineageEventAsync(LineageEventName name, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
LineageEventName name = LineageEventName.FromProjectLocationProcessRunLineageEvent("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]", "[LINEAGE_EVENT]");
// Make the request
LineageEvent response = await lineageClient.GetLineageEventAsync(name);

GetLineageEventAsync(string, CallSettings)

public virtual Task<LineageEvent> GetLineageEventAsync(string name, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]/runs/[RUN]/lineageEvents/[LINEAGE_EVENT]";
// Make the request
LineageEvent response = await lineageClient.GetLineageEventAsync(name);

GetLineageEventAsync(string, CancellationToken)

public virtual Task<LineageEvent> GetLineageEventAsync(string name, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]/runs/[RUN]/lineageEvents/[LINEAGE_EVENT]";
// Make the request
LineageEvent response = await lineageClient.GetLineageEventAsync(name);

GetProcess(GetProcessRequest, CallSettings)

public virtual Process GetProcess(GetProcessRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
GetProcessRequest request = new GetProcessRequest
{
    ProcessName = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]"),
};
// Make the request
Process response = lineageClient.GetProcess(request);

GetProcess(ProcessName, CallSettings)

public virtual Process GetProcess(ProcessName name, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
ProcessName name = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]");
// Make the request
Process response = lineageClient.GetProcess(name);

GetProcess(string, CallSettings)

public virtual Process GetProcess(string name, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]";
// Make the request
Process response = lineageClient.GetProcess(name);

GetProcessAsync(GetProcessRequest, CallSettings)

public virtual Task<Process> GetProcessAsync(GetProcessRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
GetProcessRequest request = new GetProcessRequest
{
    ProcessName = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]"),
};
// Make the request
Process response = await lineageClient.GetProcessAsync(request);

GetProcessAsync(GetProcessRequest, CancellationToken)

public virtual Task<Process> GetProcessAsync(GetProcessRequest request, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
GetProcessRequest request = new GetProcessRequest
{
    ProcessName = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]"),
};
// Make the request
Process response = await lineageClient.GetProcessAsync(request);

GetProcessAsync(ProcessName, CallSettings)

public virtual Task<Process> GetProcessAsync(ProcessName name, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
ProcessName name = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]");
// Make the request
Process response = await lineageClient.GetProcessAsync(name);

GetProcessAsync(ProcessName, CancellationToken)

public virtual Task<Process> GetProcessAsync(ProcessName name, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
ProcessName name = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]");
// Make the request
Process response = await lineageClient.GetProcessAsync(name);

GetProcessAsync(string, CallSettings)

public virtual Task<Process> GetProcessAsync(string name, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]";
// Make the request
Process response = await lineageClient.GetProcessAsync(name);

GetProcessAsync(string, CancellationToken)

public virtual Task<Process> GetProcessAsync(string name, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]";
// Make the request
Process response = await lineageClient.GetProcessAsync(name);

GetRun(GetRunRequest, CallSettings)

public virtual Run GetRun(GetRunRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
GetRunRequest request = new GetRunRequest
{
    RunName = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]"),
};
// Make the request
Run response = lineageClient.GetRun(request);

GetRun(RunName, CallSettings)

public virtual Run GetRun(RunName name, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
RunName name = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]");
// Make the request
Run response = lineageClient.GetRun(name);

GetRun(string, CallSettings)

public virtual Run GetRun(string name, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]/runs/[RUN]";
// Make the request
Run response = lineageClient.GetRun(name);

GetRunAsync(GetRunRequest, CallSettings)

public virtual Task<Run> GetRunAsync(GetRunRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
GetRunRequest request = new GetRunRequest
{
    RunName = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]"),
};
// Make the request
Run response = await lineageClient.GetRunAsync(request);

GetRunAsync(GetRunRequest, CancellationToken)

public virtual Task<Run> GetRunAsync(GetRunRequest request, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
GetRunRequest request = new GetRunRequest
{
    RunName = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]"),
};
// Make the request
Run response = await lineageClient.GetRunAsync(request);

GetRunAsync(RunName, CallSettings)

public virtual Task<Run> GetRunAsync(RunName name, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
RunName name = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]");
// Make the request
Run response = await lineageClient.GetRunAsync(name);

GetRunAsync(RunName, CancellationToken)

public virtual Task<Run> GetRunAsync(RunName name, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
RunName name = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]");
// Make the request
Run response = await lineageClient.GetRunAsync(name);

GetRunAsync(string, CallSettings)

public virtual Task<Run> GetRunAsync(string name, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]/runs/[RUN]";
// Make the request
Run response = await lineageClient.GetRunAsync(name);

GetRunAsync(string, CancellationToken)

public virtual Task<Run> GetRunAsync(string name, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]/runs/[RUN]";
// Make the request
Run response = await lineageClient.GetRunAsync(name);

ListLineageEvents(ListLineageEventsRequest, CallSettings)

public virtual PagedEnumerable<ListLineageEventsResponse, LineageEvent> ListLineageEvents(ListLineageEventsRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
ListLineageEventsRequest request = new ListLineageEventsRequest
{
    ParentAsRunName = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]"),
};
// Make the request
PagedEnumerable<ListLineageEventsResponse, LineageEvent> response = lineageClient.ListLineageEvents(request);

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

ListLineageEvents(RunName, string, int?, CallSettings)

public virtual PagedEnumerable<ListLineageEventsResponse, LineageEvent> ListLineageEvents(RunName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
RunName parent = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]");
// Make the request
PagedEnumerable<ListLineageEventsResponse, LineageEvent> response = lineageClient.ListLineageEvents(parent);

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

ListLineageEvents(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListLineageEventsResponse, LineageEvent> ListLineageEvents(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]/runs/[RUN]";
// Make the request
PagedEnumerable<ListLineageEventsResponse, LineageEvent> response = lineageClient.ListLineageEvents(parent);

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

ListLineageEventsAsync(ListLineageEventsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListLineageEventsResponse, LineageEvent> ListLineageEventsAsync(ListLineageEventsRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
ListLineageEventsRequest request = new ListLineageEventsRequest
{
    ParentAsRunName = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]"),
};
// Make the request
PagedAsyncEnumerable<ListLineageEventsResponse, LineageEvent> response = lineageClient.ListLineageEventsAsync(request);

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

ListLineageEventsAsync(RunName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListLineageEventsResponse, LineageEvent> ListLineageEventsAsync(RunName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
RunName parent = RunName.FromProjectLocationProcessRun("[PROJECT]", "[LOCATION]", "[PROCESS]", "[RUN]");
// Make the request
PagedAsyncEnumerable<ListLineageEventsResponse, LineageEvent> response = lineageClient.ListLineageEventsAsync(parent);

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

ListLineageEventsAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListLineageEventsResponse, LineageEvent> ListLineageEventsAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]/runs/[RUN]";
// Make the request
PagedAsyncEnumerable<ListLineageEventsResponse, LineageEvent> response = lineageClient.ListLineageEventsAsync(parent);

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

ListProcesses(LocationName, string, int?, CallSettings)

public virtual PagedEnumerable<ListProcessesResponse, Process> ListProcesses(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListProcessesResponse, Process> response = lineageClient.ListProcesses(parent);

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

ListProcesses(ListProcessesRequest, CallSettings)

public virtual PagedEnumerable<ListProcessesResponse, Process> ListProcesses(ListProcessesRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
ListProcessesRequest request = new ListProcessesRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedEnumerable<ListProcessesResponse, Process> response = lineageClient.ListProcesses(request);

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

ListProcesses(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListProcessesResponse, Process> ListProcesses(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedEnumerable<ListProcessesResponse, Process> response = lineageClient.ListProcesses(parent);

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

ListProcessesAsync(LocationName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListProcessesResponse, Process> ListProcessesAsync(LocationName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListProcessesResponse, Process> response = lineageClient.ListProcessesAsync(parent);

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

ListProcessesAsync(ListProcessesRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListProcessesResponse, Process> ListProcessesAsync(ListProcessesRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
ListProcessesRequest request = new ListProcessesRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
};
// Make the request
PagedAsyncEnumerable<ListProcessesResponse, Process> response = lineageClient.ListProcessesAsync(request);

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

ListProcessesAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListProcessesResponse, Process> ListProcessesAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
// Make the request
PagedAsyncEnumerable<ListProcessesResponse, Process> response = lineageClient.ListProcessesAsync(parent);

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

ListRuns(ListRunsRequest, CallSettings)

public virtual PagedEnumerable<ListRunsResponse, Run> ListRuns(ListRunsRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
ListRunsRequest request = new ListRunsRequest
{
    ParentAsProcessName = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]"),
};
// Make the request
PagedEnumerable<ListRunsResponse, Run> response = lineageClient.ListRuns(request);

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

ListRuns(ProcessName, string, int?, CallSettings)

public virtual PagedEnumerable<ListRunsResponse, Run> ListRuns(ProcessName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
ProcessName parent = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]");
// Make the request
PagedEnumerable<ListRunsResponse, Run> response = lineageClient.ListRuns(parent);

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

ListRuns(string, string, int?, CallSettings)

public virtual PagedEnumerable<ListRunsResponse, Run> ListRuns(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]";
// Make the request
PagedEnumerable<ListRunsResponse, Run> response = lineageClient.ListRuns(parent);

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

ListRunsAsync(ListRunsRequest, CallSettings)

public virtual PagedAsyncEnumerable<ListRunsResponse, Run> ListRunsAsync(ListRunsRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
ListRunsRequest request = new ListRunsRequest
{
    ParentAsProcessName = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]"),
};
// Make the request
PagedAsyncEnumerable<ListRunsResponse, Run> response = lineageClient.ListRunsAsync(request);

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

ListRunsAsync(ProcessName, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListRunsResponse, Run> ListRunsAsync(ProcessName parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
ProcessName parent = ProcessName.FromProjectLocationProcess("[PROJECT]", "[LOCATION]", "[PROCESS]");
// Make the request
PagedAsyncEnumerable<ListRunsResponse, Run> response = lineageClient.ListRunsAsync(parent);

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

ListRunsAsync(string, string, int?, CallSettings)

public virtual PagedAsyncEnumerable<ListRunsResponse, Run> ListRunsAsync(string parent, string pageToken = null, int? pageSize = null, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/processes/[PROCESS]";
// Make the request
PagedAsyncEnumerable<ListRunsResponse, Run> response = lineageClient.ListRunsAsync(parent);

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

PollOnceDeleteProcess(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> PollOnceDeleteProcess(string operationName, CallSettings callSettings = null)

PollOnceDeleteProcessAsync(string, CallSettings)

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

PollOnceDeleteRun(string, CallSettings)

public virtual Operation<Empty, OperationMetadata> PollOnceDeleteRun(string operationName, CallSettings callSettings = null)

PollOnceDeleteRunAsync(string, CallSettings)

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

ProcessOpenLineageRunEvent(ProcessOpenLineageRunEventRequest, CallSettings)

public virtual ProcessOpenLineageRunEventResponse ProcessOpenLineageRunEvent(ProcessOpenLineageRunEventRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
ProcessOpenLineageRunEventRequest request = new ProcessOpenLineageRunEventRequest
{
    Parent = "",
    OpenLineage = new Struct(),
    RequestId = "",
};
// Make the request
ProcessOpenLineageRunEventResponse response = lineageClient.ProcessOpenLineageRunEvent(request);

ProcessOpenLineageRunEvent(string, Struct, CallSettings)

public virtual ProcessOpenLineageRunEventResponse ProcessOpenLineageRunEvent(string parent, Struct openLineage, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
string parent = "";
Struct openLineage = new Struct();
// Make the request
ProcessOpenLineageRunEventResponse response = lineageClient.ProcessOpenLineageRunEvent(parent, openLineage);

ProcessOpenLineageRunEventAsync(ProcessOpenLineageRunEventRequest, CallSettings)

public virtual Task<ProcessOpenLineageRunEventResponse> ProcessOpenLineageRunEventAsync(ProcessOpenLineageRunEventRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
ProcessOpenLineageRunEventRequest request = new ProcessOpenLineageRunEventRequest
{
    Parent = "",
    OpenLineage = new Struct(),
    RequestId = "",
};
// Make the request
ProcessOpenLineageRunEventResponse response = await lineageClient.ProcessOpenLineageRunEventAsync(request);

ProcessOpenLineageRunEventAsync(ProcessOpenLineageRunEventRequest, CancellationToken)

public virtual Task<ProcessOpenLineageRunEventResponse> ProcessOpenLineageRunEventAsync(ProcessOpenLineageRunEventRequest request, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
ProcessOpenLineageRunEventRequest request = new ProcessOpenLineageRunEventRequest
{
    Parent = "",
    OpenLineage = new Struct(),
    RequestId = "",
};
// Make the request
ProcessOpenLineageRunEventResponse response = await lineageClient.ProcessOpenLineageRunEventAsync(request);

ProcessOpenLineageRunEventAsync(string, Struct, CallSettings)

public virtual Task<ProcessOpenLineageRunEventResponse> ProcessOpenLineageRunEventAsync(string parent, Struct openLineage, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string parent = "";
Struct openLineage = new Struct();
// Make the request
ProcessOpenLineageRunEventResponse response = await lineageClient.ProcessOpenLineageRunEventAsync(parent, openLineage);

ProcessOpenLineageRunEventAsync(string, Struct, CancellationToken)

public virtual Task<ProcessOpenLineageRunEventResponse> ProcessOpenLineageRunEventAsync(string parent, Struct openLineage, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
string parent = "";
Struct openLineage = new Struct();
// Make the request
ProcessOpenLineageRunEventResponse response = await lineageClient.ProcessOpenLineageRunEventAsync(parent, openLineage);

SearchLinks(SearchLinksRequest, CallSettings)

public virtual PagedEnumerable<SearchLinksResponse, Link> SearchLinks(SearchLinksRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
SearchLinksRequest request = new SearchLinksRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Source = new EntityReference(),
};
// Make the request
PagedEnumerable<SearchLinksResponse, Link> response = lineageClient.SearchLinks(request);

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

SearchLinksAsync(SearchLinksRequest, CallSettings)

public virtual PagedAsyncEnumerable<SearchLinksResponse, Link> SearchLinksAsync(SearchLinksRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
SearchLinksRequest request = new SearchLinksRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Source = new EntityReference(),
};
// Make the request
PagedAsyncEnumerable<SearchLinksResponse, Link> response = lineageClient.SearchLinksAsync(request);

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

ShutdownDefaultChannelsAsync()

public static Task ShutdownDefaultChannelsAsync()

UpdateProcess(Process, FieldMask, CallSettings)

public virtual Process UpdateProcess(Process process, FieldMask updateMask, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
Process process = new Process();
FieldMask updateMask = new FieldMask();
// Make the request
Process response = lineageClient.UpdateProcess(process, updateMask);

UpdateProcess(UpdateProcessRequest, CallSettings)

public virtual Process UpdateProcess(UpdateProcessRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
UpdateProcessRequest request = new UpdateProcessRequest
{
    Process = new Process(),
    UpdateMask = new FieldMask(),
    AllowMissing = false,
};
// Make the request
Process response = lineageClient.UpdateProcess(request);

UpdateProcessAsync(Process, FieldMask, CallSettings)

public virtual Task<Process> UpdateProcessAsync(Process process, FieldMask updateMask, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
Process process = new Process();
FieldMask updateMask = new FieldMask();
// Make the request
Process response = await lineageClient.UpdateProcessAsync(process, updateMask);

UpdateProcessAsync(Process, FieldMask, CancellationToken)

public virtual Task<Process> UpdateProcessAsync(Process process, FieldMask updateMask, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
Process process = new Process();
FieldMask updateMask = new FieldMask();
// Make the request
Process response = await lineageClient.UpdateProcessAsync(process, updateMask);

UpdateProcessAsync(UpdateProcessRequest, CallSettings)

public virtual Task<Process> UpdateProcessAsync(UpdateProcessRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
UpdateProcessRequest request = new UpdateProcessRequest
{
    Process = new Process(),
    UpdateMask = new FieldMask(),
    AllowMissing = false,
};
// Make the request
Process response = await lineageClient.UpdateProcessAsync(request);

UpdateProcessAsync(UpdateProcessRequest, CancellationToken)

public virtual Task<Process> UpdateProcessAsync(UpdateProcessRequest request, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
UpdateProcessRequest request = new UpdateProcessRequest
{
    Process = new Process(),
    UpdateMask = new FieldMask(),
    AllowMissing = false,
};
// Make the request
Process response = await lineageClient.UpdateProcessAsync(request);

UpdateRun(Run, FieldMask, CallSettings)

public virtual Run UpdateRun(Run run, FieldMask updateMask, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
Run run = new Run();
FieldMask updateMask = new FieldMask();
// Make the request
Run response = lineageClient.UpdateRun(run, updateMask);

UpdateRun(UpdateRunRequest, CallSettings)

public virtual Run UpdateRun(UpdateRunRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = LineageClient.Create();
// Initialize request argument(s)
UpdateRunRequest request = new UpdateRunRequest
{
    Run = new Run(),
    UpdateMask = new FieldMask(),
    AllowMissing = false,
};
// Make the request
Run response = lineageClient.UpdateRun(request);

UpdateRunAsync(Run, FieldMask, CallSettings)

public virtual Task<Run> UpdateRunAsync(Run run, FieldMask updateMask, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
Run run = new Run();
FieldMask updateMask = new FieldMask();
// Make the request
Run response = await lineageClient.UpdateRunAsync(run, updateMask);

UpdateRunAsync(Run, FieldMask, CancellationToken)

public virtual Task<Run> UpdateRunAsync(Run run, FieldMask updateMask, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
Run run = new Run();
FieldMask updateMask = new FieldMask();
// Make the request
Run response = await lineageClient.UpdateRunAsync(run, updateMask);

UpdateRunAsync(UpdateRunRequest, CallSettings)

public virtual Task<Run> UpdateRunAsync(UpdateRunRequest request, CallSettings callSettings = null)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
UpdateRunRequest request = new UpdateRunRequest
{
    Run = new Run(),
    UpdateMask = new FieldMask(),
    AllowMissing = false,
};
// Make the request
Run response = await lineageClient.UpdateRunAsync(request);

UpdateRunAsync(UpdateRunRequest, CancellationToken)

public virtual Task<Run> UpdateRunAsync(UpdateRunRequest request, CancellationToken cancellationToken)

// Create client
LineageClient lineageClient = await LineageClient.CreateAsync();
// Initialize request argument(s)
UpdateRunRequest request = new UpdateRunRequest
{
    Run = new Run(),
    UpdateMask = new FieldMask(),
    AllowMissing = false,
};
// Make the request
Run response = await lineageClient.UpdateRunAsync(request);