Google Cloud Dialogflow v2 API - Class ConversationModelsClient (4.12.0)

// Create client
ConversationModelsClient conversationModelsClient = ConversationModelsClient.Create();
// Initialize request argument(s)
CreateConversationModelRequest request = new CreateConversationModelRequest
{
    Parent = "",
    ConversationModel = new ConversationModel(),
};
// Make the request
Operation<ConversationModel, CreateConversationModelOperationMetadata> response = conversationModelsClient.CreateConversationModel(request);

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

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

// Create client
ConversationModelsClient conversationModelsClient = ConversationModelsClient.Create();
// Initialize request argument(s)
string parent = "";
ConversationModel conversationModel = new ConversationModel();
// Make the request
Operation<ConversationModel, CreateConversationModelOperationMetadata> response = conversationModelsClient.CreateConversationModel(parent, conversationModel);

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

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

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
CreateConversationModelRequest request = new CreateConversationModelRequest
{
    Parent = "",
    ConversationModel = new ConversationModel(),
};
// Make the request
Operation<ConversationModel, CreateConversationModelOperationMetadata> response = await conversationModelsClient.CreateConversationModelAsync(request);

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

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

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
CreateConversationModelRequest request = new CreateConversationModelRequest
{
    Parent = "",
    ConversationModel = new ConversationModel(),
};
// Make the request
Operation<ConversationModel, CreateConversationModelOperationMetadata> response = await conversationModelsClient.CreateConversationModelAsync(request);

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

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

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
string parent = "";
ConversationModel conversationModel = new ConversationModel();
// Make the request
Operation<ConversationModel, CreateConversationModelOperationMetadata> response = await conversationModelsClient.CreateConversationModelAsync(parent, conversationModel);

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

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

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
string parent = "";
ConversationModel conversationModel = new ConversationModel();
// Make the request
Operation<ConversationModel, CreateConversationModelOperationMetadata> response = await conversationModelsClient.CreateConversationModelAsync(parent, conversationModel);

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

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

// Create client
ConversationModelsClient conversationModelsClient = ConversationModelsClient.Create();
// Initialize request argument(s)
ConversationModelName parent = ConversationModelName.FromProjectLocationConversationModel("[PROJECT]", "[LOCATION]", "[CONVERSATION_MODEL]");
ConversationModelEvaluation conversationModelEvaluation = new ConversationModelEvaluation();
// Make the request
Operation<ConversationModelEvaluation, CreateConversationModelEvaluationOperationMetadata> response = conversationModelsClient.CreateConversationModelEvaluation(parent, conversationModelEvaluation);

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

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

// Create client
ConversationModelsClient conversationModelsClient = ConversationModelsClient.Create();
// Initialize request argument(s)
CreateConversationModelEvaluationRequest request = new CreateConversationModelEvaluationRequest
{
    ParentAsConversationModelName = ConversationModelName.FromProjectLocationConversationModel("[PROJECT]", "[LOCATION]", "[CONVERSATION_MODEL]"),
    ConversationModelEvaluation = new ConversationModelEvaluation(),
};
// Make the request
Operation<ConversationModelEvaluation, CreateConversationModelEvaluationOperationMetadata> response = conversationModelsClient.CreateConversationModelEvaluation(request);

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

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

// Create client
ConversationModelsClient conversationModelsClient = ConversationModelsClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/conversationModels/[CONVERSATION_MODEL]";
ConversationModelEvaluation conversationModelEvaluation = new ConversationModelEvaluation();
// Make the request
Operation<ConversationModelEvaluation, CreateConversationModelEvaluationOperationMetadata> response = conversationModelsClient.CreateConversationModelEvaluation(parent, conversationModelEvaluation);

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

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

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
ConversationModelName parent = ConversationModelName.FromProjectLocationConversationModel("[PROJECT]", "[LOCATION]", "[CONVERSATION_MODEL]");
ConversationModelEvaluation conversationModelEvaluation = new ConversationModelEvaluation();
// Make the request
Operation<ConversationModelEvaluation, CreateConversationModelEvaluationOperationMetadata> response = await conversationModelsClient.CreateConversationModelEvaluationAsync(parent, conversationModelEvaluation);

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

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

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
ConversationModelName parent = ConversationModelName.FromProjectLocationConversationModel("[PROJECT]", "[LOCATION]", "[CONVERSATION_MODEL]");
ConversationModelEvaluation conversationModelEvaluation = new ConversationModelEvaluation();
// Make the request
Operation<ConversationModelEvaluation, CreateConversationModelEvaluationOperationMetadata> response = await conversationModelsClient.CreateConversationModelEvaluationAsync(parent, conversationModelEvaluation);

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

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

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
CreateConversationModelEvaluationRequest request = new CreateConversationModelEvaluationRequest
{
    ParentAsConversationModelName = ConversationModelName.FromProjectLocationConversationModel("[PROJECT]", "[LOCATION]", "[CONVERSATION_MODEL]"),
    ConversationModelEvaluation = new ConversationModelEvaluation(),
};
// Make the request
Operation<ConversationModelEvaluation, CreateConversationModelEvaluationOperationMetadata> response = await conversationModelsClient.CreateConversationModelEvaluationAsync(request);

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

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

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
CreateConversationModelEvaluationRequest request = new CreateConversationModelEvaluationRequest
{
    ParentAsConversationModelName = ConversationModelName.FromProjectLocationConversationModel("[PROJECT]", "[LOCATION]", "[CONVERSATION_MODEL]"),
    ConversationModelEvaluation = new ConversationModelEvaluation(),
};
// Make the request
Operation<ConversationModelEvaluation, CreateConversationModelEvaluationOperationMetadata> response = await conversationModelsClient.CreateConversationModelEvaluationAsync(request);

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

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

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/conversationModels/[CONVERSATION_MODEL]";
ConversationModelEvaluation conversationModelEvaluation = new ConversationModelEvaluation();
// Make the request
Operation<ConversationModelEvaluation, CreateConversationModelEvaluationOperationMetadata> response = await conversationModelsClient.CreateConversationModelEvaluationAsync(parent, conversationModelEvaluation);

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

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

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/conversationModels/[CONVERSATION_MODEL]";
ConversationModelEvaluation conversationModelEvaluation = new ConversationModelEvaluation();
// Make the request
Operation<ConversationModelEvaluation, CreateConversationModelEvaluationOperationMetadata> response = await conversationModelsClient.CreateConversationModelEvaluationAsync(parent, conversationModelEvaluation);

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

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

// Create client
ConversationModelsClient conversationModelsClient = ConversationModelsClient.Create();
// Initialize request argument(s)
DeleteConversationModelRequest request = new DeleteConversationModelRequest { Name = "", };
// Make the request
Operation<Empty, DeleteConversationModelOperationMetadata> response = conversationModelsClient.DeleteConversationModel(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteConversationModelOperationMetadata> 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, DeleteConversationModelOperationMetadata> retrievedResponse = conversationModelsClient.PollOnceDeleteConversationModel(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
ConversationModelsClient conversationModelsClient = ConversationModelsClient.Create();
// Initialize request argument(s)
string name = "";
// Make the request
Operation<Empty, DeleteConversationModelOperationMetadata> response = conversationModelsClient.DeleteConversationModel(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteConversationModelOperationMetadata> 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, DeleteConversationModelOperationMetadata> retrievedResponse = conversationModelsClient.PollOnceDeleteConversationModel(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
DeleteConversationModelRequest request = new DeleteConversationModelRequest { Name = "", };
// Make the request
Operation<Empty, DeleteConversationModelOperationMetadata> response = await conversationModelsClient.DeleteConversationModelAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteConversationModelOperationMetadata> 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, DeleteConversationModelOperationMetadata> retrievedResponse = await conversationModelsClient.PollOnceDeleteConversationModelAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
DeleteConversationModelRequest request = new DeleteConversationModelRequest { Name = "", };
// Make the request
Operation<Empty, DeleteConversationModelOperationMetadata> response = await conversationModelsClient.DeleteConversationModelAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteConversationModelOperationMetadata> 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, DeleteConversationModelOperationMetadata> retrievedResponse = await conversationModelsClient.PollOnceDeleteConversationModelAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
string name = "";
// Make the request
Operation<Empty, DeleteConversationModelOperationMetadata> response = await conversationModelsClient.DeleteConversationModelAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteConversationModelOperationMetadata> 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, DeleteConversationModelOperationMetadata> retrievedResponse = await conversationModelsClient.PollOnceDeleteConversationModelAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
string name = "";
// Make the request
Operation<Empty, DeleteConversationModelOperationMetadata> response = await conversationModelsClient.DeleteConversationModelAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, DeleteConversationModelOperationMetadata> 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, DeleteConversationModelOperationMetadata> retrievedResponse = await conversationModelsClient.PollOnceDeleteConversationModelAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
ConversationModelsClient conversationModelsClient = ConversationModelsClient.Create();
// Initialize request argument(s)
DeployConversationModelRequest request = new DeployConversationModelRequest { Name = "", };
// Make the request
Operation<Empty, DeployConversationModelOperationMetadata> response = conversationModelsClient.DeployConversationModel(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeployConversationModelOperationMetadata> 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, DeployConversationModelOperationMetadata> retrievedResponse = conversationModelsClient.PollOnceDeployConversationModel(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
DeployConversationModelRequest request = new DeployConversationModelRequest { Name = "", };
// Make the request
Operation<Empty, DeployConversationModelOperationMetadata> response = await conversationModelsClient.DeployConversationModelAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeployConversationModelOperationMetadata> 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, DeployConversationModelOperationMetadata> retrievedResponse = await conversationModelsClient.PollOnceDeployConversationModelAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
DeployConversationModelRequest request = new DeployConversationModelRequest { Name = "", };
// Make the request
Operation<Empty, DeployConversationModelOperationMetadata> response = await conversationModelsClient.DeployConversationModelAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, DeployConversationModelOperationMetadata> 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, DeployConversationModelOperationMetadata> retrievedResponse = await conversationModelsClient.PollOnceDeployConversationModelAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
ConversationModelsClient conversationModelsClient = ConversationModelsClient.Create();
// Initialize request argument(s)
GetConversationModelRequest request = new GetConversationModelRequest { Name = "", };
// Make the request
ConversationModel response = conversationModelsClient.GetConversationModel(request);

// Create client
ConversationModelsClient conversationModelsClient = ConversationModelsClient.Create();
// Initialize request argument(s)
string name = "";
// Make the request
ConversationModel response = conversationModelsClient.GetConversationModel(name);

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
GetConversationModelRequest request = new GetConversationModelRequest { Name = "", };
// Make the request
ConversationModel response = await conversationModelsClient.GetConversationModelAsync(request);

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
GetConversationModelRequest request = new GetConversationModelRequest { Name = "", };
// Make the request
ConversationModel response = await conversationModelsClient.GetConversationModelAsync(request);

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
string name = "";
// Make the request
ConversationModel response = await conversationModelsClient.GetConversationModelAsync(name);

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
string name = "";
// Make the request
ConversationModel response = await conversationModelsClient.GetConversationModelAsync(name);

// Create client
ConversationModelsClient conversationModelsClient = ConversationModelsClient.Create();
// Initialize request argument(s)
GetConversationModelEvaluationRequest request = new GetConversationModelEvaluationRequest { Name = "", };
// Make the request
ConversationModelEvaluation response = conversationModelsClient.GetConversationModelEvaluation(request);

// Create client
ConversationModelsClient conversationModelsClient = ConversationModelsClient.Create();
// Initialize request argument(s)
string name = "";
// Make the request
ConversationModelEvaluation response = conversationModelsClient.GetConversationModelEvaluation(name);

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
GetConversationModelEvaluationRequest request = new GetConversationModelEvaluationRequest { Name = "", };
// Make the request
ConversationModelEvaluation response = await conversationModelsClient.GetConversationModelEvaluationAsync(request);

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
GetConversationModelEvaluationRequest request = new GetConversationModelEvaluationRequest { Name = "", };
// Make the request
ConversationModelEvaluation response = await conversationModelsClient.GetConversationModelEvaluationAsync(request);

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
string name = "";
// Make the request
ConversationModelEvaluation response = await conversationModelsClient.GetConversationModelEvaluationAsync(name);

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
string name = "";
// Make the request
ConversationModelEvaluation response = await conversationModelsClient.GetConversationModelEvaluationAsync(name);

// Create client
ConversationModelsClient conversationModelsClient = ConversationModelsClient.Create();
// Initialize request argument(s)
ListConversationModelEvaluationsRequest request = new ListConversationModelEvaluationsRequest { Parent = "", };
// Make the request
PagedEnumerable<ListConversationModelEvaluationsResponse, ConversationModelEvaluation> response = conversationModelsClient.ListConversationModelEvaluations(request);

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

// Create client
ConversationModelsClient conversationModelsClient = ConversationModelsClient.Create();
// Initialize request argument(s)
string parent = "";
// Make the request
PagedEnumerable<ListConversationModelEvaluationsResponse, ConversationModelEvaluation> response = conversationModelsClient.ListConversationModelEvaluations(parent);

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

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
ListConversationModelEvaluationsRequest request = new ListConversationModelEvaluationsRequest { Parent = "", };
// Make the request
PagedAsyncEnumerable<ListConversationModelEvaluationsResponse, ConversationModelEvaluation> response = conversationModelsClient.ListConversationModelEvaluationsAsync(request);

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

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
string parent = "";
// Make the request
PagedAsyncEnumerable<ListConversationModelEvaluationsResponse, ConversationModelEvaluation> response = conversationModelsClient.ListConversationModelEvaluationsAsync(parent);

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

// Create client
ConversationModelsClient conversationModelsClient = ConversationModelsClient.Create();
// Initialize request argument(s)
ListConversationModelsRequest request = new ListConversationModelsRequest { Parent = "", };
// Make the request
PagedEnumerable<ListConversationModelsResponse, ConversationModel> response = conversationModelsClient.ListConversationModels(request);

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

// Create client
ConversationModelsClient conversationModelsClient = ConversationModelsClient.Create();
// Initialize request argument(s)
string parent = "";
// Make the request
PagedEnumerable<ListConversationModelsResponse, ConversationModel> response = conversationModelsClient.ListConversationModels(parent);

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

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
ListConversationModelsRequest request = new ListConversationModelsRequest { Parent = "", };
// Make the request
PagedAsyncEnumerable<ListConversationModelsResponse, ConversationModel> response = conversationModelsClient.ListConversationModelsAsync(request);

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

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
string parent = "";
// Make the request
PagedAsyncEnumerable<ListConversationModelsResponse, ConversationModel> response = conversationModelsClient.ListConversationModelsAsync(parent);

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

// Create client
ConversationModelsClient conversationModelsClient = ConversationModelsClient.Create();
// Initialize request argument(s)
UndeployConversationModelRequest request = new UndeployConversationModelRequest { Name = "", };
// Make the request
Operation<Empty, UndeployConversationModelOperationMetadata> response = conversationModelsClient.UndeployConversationModel(request);

// Poll until the returned long-running operation is complete
Operation<Empty, UndeployConversationModelOperationMetadata> 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, UndeployConversationModelOperationMetadata> retrievedResponse = conversationModelsClient.PollOnceUndeployConversationModel(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
UndeployConversationModelRequest request = new UndeployConversationModelRequest { Name = "", };
// Make the request
Operation<Empty, UndeployConversationModelOperationMetadata> response = await conversationModelsClient.UndeployConversationModelAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, UndeployConversationModelOperationMetadata> 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, UndeployConversationModelOperationMetadata> retrievedResponse = await conversationModelsClient.PollOnceUndeployConversationModelAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    Empty retrievedResult = retrievedResponse.Result;
}

// Create client
ConversationModelsClient conversationModelsClient = await ConversationModelsClient.CreateAsync();
// Initialize request argument(s)
UndeployConversationModelRequest request = new UndeployConversationModelRequest { Name = "", };
// Make the request
Operation<Empty, UndeployConversationModelOperationMetadata> response = await conversationModelsClient.UndeployConversationModelAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, UndeployConversationModelOperationMetadata> 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, UndeployConversationModelOperationMetadata> retrievedResponse = await conversationModelsClient.PollOnceUndeployConversationModelAsync(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;
}