Google Cloud Dialogflow v2 API - Class ConversationProfilesClient (4.10.0)

// Create client
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
ClearSuggestionFeatureConfigRequest request = new ClearSuggestionFeatureConfigRequest
{
    ConversationProfile = "",
    ParticipantRole = Participant.Types.Role.Unspecified,
    SuggestionFeatureType = SuggestionFeature.Types.Type.Unspecified,
};
// Make the request
Operation<ConversationProfile, ClearSuggestionFeatureConfigOperationMetadata> response = conversationProfilesClient.ClearSuggestionFeatureConfig(request);

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

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

// Create client
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
string conversationProfile = "";
// Make the request
Operation<ConversationProfile, ClearSuggestionFeatureConfigOperationMetadata> response = conversationProfilesClient.ClearSuggestionFeatureConfig(conversationProfile);

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

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

// Create client
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
string conversationProfile = "";
Participant.Types.Role participantRole = Participant.Types.Role.Unspecified;
SuggestionFeature.Types.Type suggestionFeatureType = SuggestionFeature.Types.Type.Unspecified;
// Make the request
Operation<ConversationProfile, ClearSuggestionFeatureConfigOperationMetadata> response = conversationProfilesClient.ClearSuggestionFeatureConfig(conversationProfile, participantRole, suggestionFeatureType);

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

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

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
ClearSuggestionFeatureConfigRequest request = new ClearSuggestionFeatureConfigRequest
{
    ConversationProfile = "",
    ParticipantRole = Participant.Types.Role.Unspecified,
    SuggestionFeatureType = SuggestionFeature.Types.Type.Unspecified,
};
// Make the request
Operation<ConversationProfile, ClearSuggestionFeatureConfigOperationMetadata> response = await conversationProfilesClient.ClearSuggestionFeatureConfigAsync(request);

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

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

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
ClearSuggestionFeatureConfigRequest request = new ClearSuggestionFeatureConfigRequest
{
    ConversationProfile = "",
    ParticipantRole = Participant.Types.Role.Unspecified,
    SuggestionFeatureType = SuggestionFeature.Types.Type.Unspecified,
};
// Make the request
Operation<ConversationProfile, ClearSuggestionFeatureConfigOperationMetadata> response = await conversationProfilesClient.ClearSuggestionFeatureConfigAsync(request);

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

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

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
string conversationProfile = "";
// Make the request
Operation<ConversationProfile, ClearSuggestionFeatureConfigOperationMetadata> response = await conversationProfilesClient.ClearSuggestionFeatureConfigAsync(conversationProfile);

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

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

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
string conversationProfile = "";
Participant.Types.Role participantRole = Participant.Types.Role.Unspecified;
SuggestionFeature.Types.Type suggestionFeatureType = SuggestionFeature.Types.Type.Unspecified;
// Make the request
Operation<ConversationProfile, ClearSuggestionFeatureConfigOperationMetadata> response = await conversationProfilesClient.ClearSuggestionFeatureConfigAsync(conversationProfile, participantRole, suggestionFeatureType);

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

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

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
string conversationProfile = "";
Participant.Types.Role participantRole = Participant.Types.Role.Unspecified;
SuggestionFeature.Types.Type suggestionFeatureType = SuggestionFeature.Types.Type.Unspecified;
// Make the request
Operation<ConversationProfile, ClearSuggestionFeatureConfigOperationMetadata> response = await conversationProfilesClient.ClearSuggestionFeatureConfigAsync(conversationProfile, participantRole, suggestionFeatureType);

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

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

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
string conversationProfile = "";
// Make the request
Operation<ConversationProfile, ClearSuggestionFeatureConfigOperationMetadata> response = await conversationProfilesClient.ClearSuggestionFeatureConfigAsync(conversationProfile);

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

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

// Create client
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ConversationProfile conversationProfile = new ConversationProfile();
// Make the request
ConversationProfile response = conversationProfilesClient.CreateConversationProfile(parent, conversationProfile);

// Create client
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
ConversationProfile conversationProfile = new ConversationProfile();
// Make the request
ConversationProfile response = conversationProfilesClient.CreateConversationProfile(parent, conversationProfile);

// Create client
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
CreateConversationProfileRequest request = new CreateConversationProfileRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
    ConversationProfile = new ConversationProfile(),
};
// Make the request
ConversationProfile response = conversationProfilesClient.CreateConversationProfile(request);

// Create client
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]";
ConversationProfile conversationProfile = new ConversationProfile();
// Make the request
ConversationProfile response = conversationProfilesClient.CreateConversationProfile(parent, conversationProfile);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ConversationProfile conversationProfile = new ConversationProfile();
// Make the request
ConversationProfile response = await conversationProfilesClient.CreateConversationProfileAsync(parent, conversationProfile);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
ConversationProfile conversationProfile = new ConversationProfile();
// Make the request
ConversationProfile response = await conversationProfilesClient.CreateConversationProfileAsync(parent, conversationProfile);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
ConversationProfile conversationProfile = new ConversationProfile();
// Make the request
ConversationProfile response = await conversationProfilesClient.CreateConversationProfileAsync(parent, conversationProfile);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
ConversationProfile conversationProfile = new ConversationProfile();
// Make the request
ConversationProfile response = await conversationProfilesClient.CreateConversationProfileAsync(parent, conversationProfile);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
CreateConversationProfileRequest request = new CreateConversationProfileRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
    ConversationProfile = new ConversationProfile(),
};
// Make the request
ConversationProfile response = await conversationProfilesClient.CreateConversationProfileAsync(request);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
CreateConversationProfileRequest request = new CreateConversationProfileRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
    ConversationProfile = new ConversationProfile(),
};
// Make the request
ConversationProfile response = await conversationProfilesClient.CreateConversationProfileAsync(request);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]";
ConversationProfile conversationProfile = new ConversationProfile();
// Make the request
ConversationProfile response = await conversationProfilesClient.CreateConversationProfileAsync(parent, conversationProfile);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]";
ConversationProfile conversationProfile = new ConversationProfile();
// Make the request
ConversationProfile response = await conversationProfilesClient.CreateConversationProfileAsync(parent, conversationProfile);

// Create client
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
ConversationProfileName name = ConversationProfileName.FromProjectConversationProfile("[PROJECT]", "[CONVERSATION_PROFILE]");
// Make the request
conversationProfilesClient.DeleteConversationProfile(name);

// Create client
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
DeleteConversationProfileRequest request = new DeleteConversationProfileRequest
{
    ConversationProfileName = ConversationProfileName.FromProjectConversationProfile("[PROJECT]", "[CONVERSATION_PROFILE]"),
};
// Make the request
conversationProfilesClient.DeleteConversationProfile(request);

// Create client
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/conversationProfiles/[CONVERSATION_PROFILE]";
// Make the request
conversationProfilesClient.DeleteConversationProfile(name);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
ConversationProfileName name = ConversationProfileName.FromProjectConversationProfile("[PROJECT]", "[CONVERSATION_PROFILE]");
// Make the request
await conversationProfilesClient.DeleteConversationProfileAsync(name);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
ConversationProfileName name = ConversationProfileName.FromProjectConversationProfile("[PROJECT]", "[CONVERSATION_PROFILE]");
// Make the request
await conversationProfilesClient.DeleteConversationProfileAsync(name);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
DeleteConversationProfileRequest request = new DeleteConversationProfileRequest
{
    ConversationProfileName = ConversationProfileName.FromProjectConversationProfile("[PROJECT]", "[CONVERSATION_PROFILE]"),
};
// Make the request
await conversationProfilesClient.DeleteConversationProfileAsync(request);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
DeleteConversationProfileRequest request = new DeleteConversationProfileRequest
{
    ConversationProfileName = ConversationProfileName.FromProjectConversationProfile("[PROJECT]", "[CONVERSATION_PROFILE]"),
};
// Make the request
await conversationProfilesClient.DeleteConversationProfileAsync(request);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/conversationProfiles/[CONVERSATION_PROFILE]";
// Make the request
await conversationProfilesClient.DeleteConversationProfileAsync(name);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/conversationProfiles/[CONVERSATION_PROFILE]";
// Make the request
await conversationProfilesClient.DeleteConversationProfileAsync(name);

// Create client
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
ConversationProfileName name = ConversationProfileName.FromProjectConversationProfile("[PROJECT]", "[CONVERSATION_PROFILE]");
// Make the request
ConversationProfile response = conversationProfilesClient.GetConversationProfile(name);

// Create client
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
GetConversationProfileRequest request = new GetConversationProfileRequest
{
    ConversationProfileName = ConversationProfileName.FromProjectConversationProfile("[PROJECT]", "[CONVERSATION_PROFILE]"),
};
// Make the request
ConversationProfile response = conversationProfilesClient.GetConversationProfile(request);

// Create client
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/conversationProfiles/[CONVERSATION_PROFILE]";
// Make the request
ConversationProfile response = conversationProfilesClient.GetConversationProfile(name);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
ConversationProfileName name = ConversationProfileName.FromProjectConversationProfile("[PROJECT]", "[CONVERSATION_PROFILE]");
// Make the request
ConversationProfile response = await conversationProfilesClient.GetConversationProfileAsync(name);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
ConversationProfileName name = ConversationProfileName.FromProjectConversationProfile("[PROJECT]", "[CONVERSATION_PROFILE]");
// Make the request
ConversationProfile response = await conversationProfilesClient.GetConversationProfileAsync(name);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
GetConversationProfileRequest request = new GetConversationProfileRequest
{
    ConversationProfileName = ConversationProfileName.FromProjectConversationProfile("[PROJECT]", "[CONVERSATION_PROFILE]"),
};
// Make the request
ConversationProfile response = await conversationProfilesClient.GetConversationProfileAsync(request);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
GetConversationProfileRequest request = new GetConversationProfileRequest
{
    ConversationProfileName = ConversationProfileName.FromProjectConversationProfile("[PROJECT]", "[CONVERSATION_PROFILE]"),
};
// Make the request
ConversationProfile response = await conversationProfilesClient.GetConversationProfileAsync(request);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/conversationProfiles/[CONVERSATION_PROFILE]";
// Make the request
ConversationProfile response = await conversationProfilesClient.GetConversationProfileAsync(name);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/conversationProfiles/[CONVERSATION_PROFILE]";
// Make the request
ConversationProfile response = await conversationProfilesClient.GetConversationProfileAsync(name);

// Create client
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListConversationProfilesResponse, ConversationProfile> response = conversationProfilesClient.ListConversationProfiles(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (ConversationProfile 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 (ListConversationProfilesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ConversationProfile 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<ConversationProfile> 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 (ConversationProfile 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
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
// Make the request
PagedEnumerable<ListConversationProfilesResponse, ConversationProfile> response = conversationProfilesClient.ListConversationProfiles(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (ConversationProfile 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 (ListConversationProfilesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ConversationProfile 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<ConversationProfile> 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 (ConversationProfile 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
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
ListConversationProfilesRequest request = new ListConversationProfilesRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
};
// Make the request
PagedEnumerable<ListConversationProfilesResponse, ConversationProfile> response = conversationProfilesClient.ListConversationProfiles(request);

// Iterate over all response items, lazily performing RPCs as required
foreach (ConversationProfile 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 (ListConversationProfilesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ConversationProfile 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<ConversationProfile> 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 (ConversationProfile 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
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]";
// Make the request
PagedEnumerable<ListConversationProfilesResponse, ConversationProfile> response = conversationProfilesClient.ListConversationProfiles(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (ConversationProfile 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 (ListConversationProfilesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ConversationProfile 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<ConversationProfile> 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 (ConversationProfile 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
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedAsyncEnumerable<ListConversationProfilesResponse, ConversationProfile> response = conversationProfilesClient.ListConversationProfilesAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ConversationProfile 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((ListConversationProfilesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ConversationProfile 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<ConversationProfile> 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 (ConversationProfile 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
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
ProjectName parent = ProjectName.FromProject("[PROJECT]");
// Make the request
PagedAsyncEnumerable<ListConversationProfilesResponse, ConversationProfile> response = conversationProfilesClient.ListConversationProfilesAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ConversationProfile 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((ListConversationProfilesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ConversationProfile 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<ConversationProfile> 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 (ConversationProfile 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
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
ListConversationProfilesRequest request = new ListConversationProfilesRequest
{
    ParentAsProjectName = ProjectName.FromProject("[PROJECT]"),
};
// Make the request
PagedAsyncEnumerable<ListConversationProfilesResponse, ConversationProfile> response = conversationProfilesClient.ListConversationProfilesAsync(request);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ConversationProfile 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((ListConversationProfilesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ConversationProfile 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<ConversationProfile> 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 (ConversationProfile 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
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]";
// Make the request
PagedAsyncEnumerable<ListConversationProfilesResponse, ConversationProfile> response = conversationProfilesClient.ListConversationProfilesAsync(parent);

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((ConversationProfile 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((ListConversationProfilesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (ConversationProfile 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<ConversationProfile> 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 (ConversationProfile 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
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
SetSuggestionFeatureConfigRequest request = new SetSuggestionFeatureConfigRequest
{
    ConversationProfile = "",
    ParticipantRole = Participant.Types.Role.Unspecified,
    SuggestionFeatureConfig = new HumanAgentAssistantConfig.Types.SuggestionFeatureConfig(),
};
// Make the request
Operation<ConversationProfile, SetSuggestionFeatureConfigOperationMetadata> response = conversationProfilesClient.SetSuggestionFeatureConfig(request);

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

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

// Create client
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
string conversationProfile = "";
// Make the request
Operation<ConversationProfile, SetSuggestionFeatureConfigOperationMetadata> response = conversationProfilesClient.SetSuggestionFeatureConfig(conversationProfile);

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

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

// Create client
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
string conversationProfile = "";
Participant.Types.Role participantRole = Participant.Types.Role.Unspecified;
HumanAgentAssistantConfig.Types.SuggestionFeatureConfig suggestionFeatureConfig = new HumanAgentAssistantConfig.Types.SuggestionFeatureConfig();
// Make the request
Operation<ConversationProfile, SetSuggestionFeatureConfigOperationMetadata> response = conversationProfilesClient.SetSuggestionFeatureConfig(conversationProfile, participantRole, suggestionFeatureConfig);

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

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

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
SetSuggestionFeatureConfigRequest request = new SetSuggestionFeatureConfigRequest
{
    ConversationProfile = "",
    ParticipantRole = Participant.Types.Role.Unspecified,
    SuggestionFeatureConfig = new HumanAgentAssistantConfig.Types.SuggestionFeatureConfig(),
};
// Make the request
Operation<ConversationProfile, SetSuggestionFeatureConfigOperationMetadata> response = await conversationProfilesClient.SetSuggestionFeatureConfigAsync(request);

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

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

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
SetSuggestionFeatureConfigRequest request = new SetSuggestionFeatureConfigRequest
{
    ConversationProfile = "",
    ParticipantRole = Participant.Types.Role.Unspecified,
    SuggestionFeatureConfig = new HumanAgentAssistantConfig.Types.SuggestionFeatureConfig(),
};
// Make the request
Operation<ConversationProfile, SetSuggestionFeatureConfigOperationMetadata> response = await conversationProfilesClient.SetSuggestionFeatureConfigAsync(request);

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

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

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
string conversationProfile = "";
// Make the request
Operation<ConversationProfile, SetSuggestionFeatureConfigOperationMetadata> response = await conversationProfilesClient.SetSuggestionFeatureConfigAsync(conversationProfile);

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

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

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
string conversationProfile = "";
Participant.Types.Role participantRole = Participant.Types.Role.Unspecified;
HumanAgentAssistantConfig.Types.SuggestionFeatureConfig suggestionFeatureConfig = new HumanAgentAssistantConfig.Types.SuggestionFeatureConfig();
// Make the request
Operation<ConversationProfile, SetSuggestionFeatureConfigOperationMetadata> response = await conversationProfilesClient.SetSuggestionFeatureConfigAsync(conversationProfile, participantRole, suggestionFeatureConfig);

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

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

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
string conversationProfile = "";
Participant.Types.Role participantRole = Participant.Types.Role.Unspecified;
HumanAgentAssistantConfig.Types.SuggestionFeatureConfig suggestionFeatureConfig = new HumanAgentAssistantConfig.Types.SuggestionFeatureConfig();
// Make the request
Operation<ConversationProfile, SetSuggestionFeatureConfigOperationMetadata> response = await conversationProfilesClient.SetSuggestionFeatureConfigAsync(conversationProfile, participantRole, suggestionFeatureConfig);

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

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

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
string conversationProfile = "";
// Make the request
Operation<ConversationProfile, SetSuggestionFeatureConfigOperationMetadata> response = await conversationProfilesClient.SetSuggestionFeatureConfigAsync(conversationProfile);

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

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

// Create client
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
ConversationProfile conversationProfile = new ConversationProfile();
FieldMask updateMask = new FieldMask();
// Make the request
ConversationProfile response = conversationProfilesClient.UpdateConversationProfile(conversationProfile, updateMask);

// Create client
ConversationProfilesClient conversationProfilesClient = ConversationProfilesClient.Create();
// Initialize request argument(s)
UpdateConversationProfileRequest request = new UpdateConversationProfileRequest
{
    ConversationProfile = new ConversationProfile(),
    UpdateMask = new FieldMask(),
};
// Make the request
ConversationProfile response = conversationProfilesClient.UpdateConversationProfile(request);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
ConversationProfile conversationProfile = new ConversationProfile();
FieldMask updateMask = new FieldMask();
// Make the request
ConversationProfile response = await conversationProfilesClient.UpdateConversationProfileAsync(conversationProfile, updateMask);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
ConversationProfile conversationProfile = new ConversationProfile();
FieldMask updateMask = new FieldMask();
// Make the request
ConversationProfile response = await conversationProfilesClient.UpdateConversationProfileAsync(conversationProfile, updateMask);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
UpdateConversationProfileRequest request = new UpdateConversationProfileRequest
{
    ConversationProfile = new ConversationProfile(),
    UpdateMask = new FieldMask(),
};
// Make the request
ConversationProfile response = await conversationProfilesClient.UpdateConversationProfileAsync(request);

// Create client
ConversationProfilesClient conversationProfilesClient = await ConversationProfilesClient.CreateAsync();
// Initialize request argument(s)
UpdateConversationProfileRequest request = new UpdateConversationProfileRequest
{
    ConversationProfile = new ConversationProfile(),
    UpdateMask = new FieldMask(),
};
// Make the request
ConversationProfile response = await conversationProfilesClient.UpdateConversationProfileAsync(request);