Cloud AI Platform v1 API - Class IndexServiceClient (3.9.0)

// Create client
gcav::IndexServiceClient indexServiceClient = gcav::IndexServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcav::Index index = new gcav::Index();
// Make the request
Operation<gcav::Index, gcav::CreateIndexOperationMetadata> response = indexServiceClient.CreateIndex(parent, index);

// Poll until the returned long-running operation is complete
Operation<gcav::Index, gcav::CreateIndexOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcav::Index 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<gcav::Index, gcav::CreateIndexOperationMetadata> retrievedResponse = indexServiceClient.PollOnceCreateIndex(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Index retrievedResult = retrievedResponse.Result;
}

// Create client
gcav::IndexServiceClient indexServiceClient = gcav::IndexServiceClient.Create();
// Initialize request argument(s)
gcav::CreateIndexRequest request = new gcav::CreateIndexRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Index = new gcav::Index(),
};
// Make the request
Operation<gcav::Index, gcav::CreateIndexOperationMetadata> response = indexServiceClient.CreateIndex(request);

// Poll until the returned long-running operation is complete
Operation<gcav::Index, gcav::CreateIndexOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcav::Index 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<gcav::Index, gcav::CreateIndexOperationMetadata> retrievedResponse = indexServiceClient.PollOnceCreateIndex(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Index retrievedResult = retrievedResponse.Result;
}

// Create client
gcav::IndexServiceClient indexServiceClient = gcav::IndexServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcav::Index index = new gcav::Index();
// Make the request
Operation<gcav::Index, gcav::CreateIndexOperationMetadata> response = indexServiceClient.CreateIndex(parent, index);

// Poll until the returned long-running operation is complete
Operation<gcav::Index, gcav::CreateIndexOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcav::Index 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<gcav::Index, gcav::CreateIndexOperationMetadata> retrievedResponse = indexServiceClient.PollOnceCreateIndex(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Index retrievedResult = retrievedResponse.Result;
}

// Create client
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcav::Index index = new gcav::Index();
// Make the request
Operation<gcav::Index, gcav::CreateIndexOperationMetadata> response = await indexServiceClient.CreateIndexAsync(parent, index);

// Poll until the returned long-running operation is complete
Operation<gcav::Index, gcav::CreateIndexOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcav::Index 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<gcav::Index, gcav::CreateIndexOperationMetadata> retrievedResponse = await indexServiceClient.PollOnceCreateIndexAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Index retrievedResult = retrievedResponse.Result;
}

// Create client
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
gcav::Index index = new gcav::Index();
// Make the request
Operation<gcav::Index, gcav::CreateIndexOperationMetadata> response = await indexServiceClient.CreateIndexAsync(parent, index);

// Poll until the returned long-running operation is complete
Operation<gcav::Index, gcav::CreateIndexOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcav::Index 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<gcav::Index, gcav::CreateIndexOperationMetadata> retrievedResponse = await indexServiceClient.PollOnceCreateIndexAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Index retrievedResult = retrievedResponse.Result;
}

// Create client
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
gcav::CreateIndexRequest request = new gcav::CreateIndexRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Index = new gcav::Index(),
};
// Make the request
Operation<gcav::Index, gcav::CreateIndexOperationMetadata> response = await indexServiceClient.CreateIndexAsync(request);

// Poll until the returned long-running operation is complete
Operation<gcav::Index, gcav::CreateIndexOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcav::Index 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<gcav::Index, gcav::CreateIndexOperationMetadata> retrievedResponse = await indexServiceClient.PollOnceCreateIndexAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Index retrievedResult = retrievedResponse.Result;
}

// Create client
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
gcav::CreateIndexRequest request = new gcav::CreateIndexRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Index = new gcav::Index(),
};
// Make the request
Operation<gcav::Index, gcav::CreateIndexOperationMetadata> response = await indexServiceClient.CreateIndexAsync(request);

// Poll until the returned long-running operation is complete
Operation<gcav::Index, gcav::CreateIndexOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcav::Index 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<gcav::Index, gcav::CreateIndexOperationMetadata> retrievedResponse = await indexServiceClient.PollOnceCreateIndexAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Index retrievedResult = retrievedResponse.Result;
}

// Create client
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcav::Index index = new gcav::Index();
// Make the request
Operation<gcav::Index, gcav::CreateIndexOperationMetadata> response = await indexServiceClient.CreateIndexAsync(parent, index);

// Poll until the returned long-running operation is complete
Operation<gcav::Index, gcav::CreateIndexOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcav::Index 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<gcav::Index, gcav::CreateIndexOperationMetadata> retrievedResponse = await indexServiceClient.PollOnceCreateIndexAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Index retrievedResult = retrievedResponse.Result;
}

// Create client
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
gcav::Index index = new gcav::Index();
// Make the request
Operation<gcav::Index, gcav::CreateIndexOperationMetadata> response = await indexServiceClient.CreateIndexAsync(parent, index);

// Poll until the returned long-running operation is complete
Operation<gcav::Index, gcav::CreateIndexOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcav::Index 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<gcav::Index, gcav::CreateIndexOperationMetadata> retrievedResponse = await indexServiceClient.PollOnceCreateIndexAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Index retrievedResult = retrievedResponse.Result;
}

// Create client
gcav::IndexServiceClient indexServiceClient = gcav::IndexServiceClient.Create();
// Initialize request argument(s)
gcav::DeleteIndexRequest request = new gcav::DeleteIndexRequest
{
    IndexName = gcav::IndexName.FromProjectLocationIndex("[PROJECT]", "[LOCATION]", "[INDEX]"),
};
// Make the request
Operation<Empty, gcav::DeleteOperationMetadata> response = indexServiceClient.DeleteIndex(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::DeleteOperationMetadata> 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, gcav::DeleteOperationMetadata> retrievedResponse = indexServiceClient.PollOnceDeleteIndex(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
gcav::IndexServiceClient indexServiceClient = gcav::IndexServiceClient.Create();
// Initialize request argument(s)
gcav::IndexName name = gcav::IndexName.FromProjectLocationIndex("[PROJECT]", "[LOCATION]", "[INDEX]");
// Make the request
Operation<Empty, gcav::DeleteOperationMetadata> response = indexServiceClient.DeleteIndex(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::DeleteOperationMetadata> 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, gcav::DeleteOperationMetadata> retrievedResponse = indexServiceClient.PollOnceDeleteIndex(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
gcav::IndexServiceClient indexServiceClient = gcav::IndexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/indexes/[INDEX]";
// Make the request
Operation<Empty, gcav::DeleteOperationMetadata> response = indexServiceClient.DeleteIndex(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::DeleteOperationMetadata> 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, gcav::DeleteOperationMetadata> retrievedResponse = indexServiceClient.PollOnceDeleteIndex(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
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
gcav::DeleteIndexRequest request = new gcav::DeleteIndexRequest
{
    IndexName = gcav::IndexName.FromProjectLocationIndex("[PROJECT]", "[LOCATION]", "[INDEX]"),
};
// Make the request
Operation<Empty, gcav::DeleteOperationMetadata> response = await indexServiceClient.DeleteIndexAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::DeleteOperationMetadata> 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, gcav::DeleteOperationMetadata> retrievedResponse = await indexServiceClient.PollOnceDeleteIndexAsync(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
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
gcav::DeleteIndexRequest request = new gcav::DeleteIndexRequest
{
    IndexName = gcav::IndexName.FromProjectLocationIndex("[PROJECT]", "[LOCATION]", "[INDEX]"),
};
// Make the request
Operation<Empty, gcav::DeleteOperationMetadata> response = await indexServiceClient.DeleteIndexAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::DeleteOperationMetadata> 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, gcav::DeleteOperationMetadata> retrievedResponse = await indexServiceClient.PollOnceDeleteIndexAsync(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
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
gcav::IndexName name = gcav::IndexName.FromProjectLocationIndex("[PROJECT]", "[LOCATION]", "[INDEX]");
// Make the request
Operation<Empty, gcav::DeleteOperationMetadata> response = await indexServiceClient.DeleteIndexAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::DeleteOperationMetadata> 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, gcav::DeleteOperationMetadata> retrievedResponse = await indexServiceClient.PollOnceDeleteIndexAsync(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
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
gcav::IndexName name = gcav::IndexName.FromProjectLocationIndex("[PROJECT]", "[LOCATION]", "[INDEX]");
// Make the request
Operation<Empty, gcav::DeleteOperationMetadata> response = await indexServiceClient.DeleteIndexAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::DeleteOperationMetadata> 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, gcav::DeleteOperationMetadata> retrievedResponse = await indexServiceClient.PollOnceDeleteIndexAsync(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
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/indexes/[INDEX]";
// Make the request
Operation<Empty, gcav::DeleteOperationMetadata> response = await indexServiceClient.DeleteIndexAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::DeleteOperationMetadata> 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, gcav::DeleteOperationMetadata> retrievedResponse = await indexServiceClient.PollOnceDeleteIndexAsync(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
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/indexes/[INDEX]";
// Make the request
Operation<Empty, gcav::DeleteOperationMetadata> response = await indexServiceClient.DeleteIndexAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, gcav::DeleteOperationMetadata> 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, gcav::DeleteOperationMetadata> retrievedResponse = await indexServiceClient.PollOnceDeleteIndexAsync(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
gcav::IndexServiceClient indexServiceClient = gcav::IndexServiceClient.Create();
// Initialize request argument(s)
gcav::GetIndexRequest request = new gcav::GetIndexRequest
{
    IndexName = gcav::IndexName.FromProjectLocationIndex("[PROJECT]", "[LOCATION]", "[INDEX]"),
};
// Make the request
gcav::Index response = indexServiceClient.GetIndex(request);

// Create client
gcav::IndexServiceClient indexServiceClient = gcav::IndexServiceClient.Create();
// Initialize request argument(s)
gcav::IndexName name = gcav::IndexName.FromProjectLocationIndex("[PROJECT]", "[LOCATION]", "[INDEX]");
// Make the request
gcav::Index response = indexServiceClient.GetIndex(name);

// Create client
gcav::IndexServiceClient indexServiceClient = gcav::IndexServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/indexes/[INDEX]";
// Make the request
gcav::Index response = indexServiceClient.GetIndex(name);

// Create client
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
gcav::GetIndexRequest request = new gcav::GetIndexRequest
{
    IndexName = gcav::IndexName.FromProjectLocationIndex("[PROJECT]", "[LOCATION]", "[INDEX]"),
};
// Make the request
gcav::Index response = await indexServiceClient.GetIndexAsync(request);

// Create client
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
gcav::GetIndexRequest request = new gcav::GetIndexRequest
{
    IndexName = gcav::IndexName.FromProjectLocationIndex("[PROJECT]", "[LOCATION]", "[INDEX]"),
};
// Make the request
gcav::Index response = await indexServiceClient.GetIndexAsync(request);

// Create client
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
gcav::IndexName name = gcav::IndexName.FromProjectLocationIndex("[PROJECT]", "[LOCATION]", "[INDEX]");
// Make the request
gcav::Index response = await indexServiceClient.GetIndexAsync(name);

// Create client
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
gcav::IndexName name = gcav::IndexName.FromProjectLocationIndex("[PROJECT]", "[LOCATION]", "[INDEX]");
// Make the request
gcav::Index response = await indexServiceClient.GetIndexAsync(name);

// Create client
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/indexes/[INDEX]";
// Make the request
gcav::Index response = await indexServiceClient.GetIndexAsync(name);

// Create client
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/indexes/[INDEX]";
// Make the request
gcav::Index response = await indexServiceClient.GetIndexAsync(name);

// Create client
gcav::IndexServiceClient indexServiceClient = gcav::IndexServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<gcav::ListIndexesResponse, gcav::Index> response = indexServiceClient.ListIndexes(parent);

// Iterate over all response items, lazily performing RPCs as required
foreach (gcav::Index 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 (gcav::ListIndexesResponse page in response.AsRawResponses())
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (gcav::Index 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<gcav::Index> 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 (gcav::Index 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
gcav::IndexServiceClient indexServiceClient = gcav::IndexServiceClient.Create();
// Initialize request argument(s)
gcav::ListIndexesRequest request = new gcav::ListIndexesRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    ReadMask = new FieldMask(),
};
// Make the request
PagedEnumerable<gcav::ListIndexesResponse, gcav::Index> response = indexServiceClient.ListIndexes(request);

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

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

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((gcav::Index 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((gcav::ListIndexesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (gcav::Index 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<gcav::Index> 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 (gcav::Index 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
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
gcav::ListIndexesRequest request = new gcav::ListIndexesRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Filter = "",
    ReadMask = new FieldMask(),
};
// Make the request
PagedAsyncEnumerable<gcav::ListIndexesResponse, gcav::Index> response = indexServiceClient.ListIndexesAsync(request);

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

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((gcav::Index 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((gcav::ListIndexesResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (gcav::Index 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<gcav::Index> 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 (gcav::Index 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
gcav::IndexServiceClient indexServiceClient = gcav::IndexServiceClient.Create();
// Initialize request argument(s)
gcav::RemoveDatapointsRequest request = new gcav::RemoveDatapointsRequest
{
    IndexAsIndexName = gcav::IndexName.FromProjectLocationIndex("[PROJECT]", "[LOCATION]", "[INDEX]"),
    DatapointIds = { "", },
};
// Make the request
gcav::RemoveDatapointsResponse response = indexServiceClient.RemoveDatapoints(request);

// Create client
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
gcav::RemoveDatapointsRequest request = new gcav::RemoveDatapointsRequest
{
    IndexAsIndexName = gcav::IndexName.FromProjectLocationIndex("[PROJECT]", "[LOCATION]", "[INDEX]"),
    DatapointIds = { "", },
};
// Make the request
gcav::RemoveDatapointsResponse response = await indexServiceClient.RemoveDatapointsAsync(request);

// Create client
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
gcav::RemoveDatapointsRequest request = new gcav::RemoveDatapointsRequest
{
    IndexAsIndexName = gcav::IndexName.FromProjectLocationIndex("[PROJECT]", "[LOCATION]", "[INDEX]"),
    DatapointIds = { "", },
};
// Make the request
gcav::RemoveDatapointsResponse response = await indexServiceClient.RemoveDatapointsAsync(request);

// Create client
gcav::IndexServiceClient indexServiceClient = gcav::IndexServiceClient.Create();
// Initialize request argument(s)
gcav::Index index = new gcav::Index();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcav::Index, gcav::UpdateIndexOperationMetadata> response = indexServiceClient.UpdateIndex(index, updateMask);

// Poll until the returned long-running operation is complete
Operation<gcav::Index, gcav::UpdateIndexOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcav::Index 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<gcav::Index, gcav::UpdateIndexOperationMetadata> retrievedResponse = indexServiceClient.PollOnceUpdateIndex(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Index retrievedResult = retrievedResponse.Result;
}

// Create client
gcav::IndexServiceClient indexServiceClient = gcav::IndexServiceClient.Create();
// Initialize request argument(s)
gcav::UpdateIndexRequest request = new gcav::UpdateIndexRequest
{
    Index = new gcav::Index(),
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<gcav::Index, gcav::UpdateIndexOperationMetadata> response = indexServiceClient.UpdateIndex(request);

// Poll until the returned long-running operation is complete
Operation<gcav::Index, gcav::UpdateIndexOperationMetadata> completedResponse = response.PollUntilCompleted();
// Retrieve the operation result
gcav::Index 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<gcav::Index, gcav::UpdateIndexOperationMetadata> retrievedResponse = indexServiceClient.PollOnceUpdateIndex(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Index retrievedResult = retrievedResponse.Result;
}

// Create client
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
gcav::Index index = new gcav::Index();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcav::Index, gcav::UpdateIndexOperationMetadata> response = await indexServiceClient.UpdateIndexAsync(index, updateMask);

// Poll until the returned long-running operation is complete
Operation<gcav::Index, gcav::UpdateIndexOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcav::Index 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<gcav::Index, gcav::UpdateIndexOperationMetadata> retrievedResponse = await indexServiceClient.PollOnceUpdateIndexAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Index retrievedResult = retrievedResponse.Result;
}

// Create client
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
gcav::Index index = new gcav::Index();
FieldMask updateMask = new FieldMask();
// Make the request
Operation<gcav::Index, gcav::UpdateIndexOperationMetadata> response = await indexServiceClient.UpdateIndexAsync(index, updateMask);

// Poll until the returned long-running operation is complete
Operation<gcav::Index, gcav::UpdateIndexOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcav::Index 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<gcav::Index, gcav::UpdateIndexOperationMetadata> retrievedResponse = await indexServiceClient.PollOnceUpdateIndexAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Index retrievedResult = retrievedResponse.Result;
}

// Create client
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
gcav::UpdateIndexRequest request = new gcav::UpdateIndexRequest
{
    Index = new gcav::Index(),
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<gcav::Index, gcav::UpdateIndexOperationMetadata> response = await indexServiceClient.UpdateIndexAsync(request);

// Poll until the returned long-running operation is complete
Operation<gcav::Index, gcav::UpdateIndexOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcav::Index 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<gcav::Index, gcav::UpdateIndexOperationMetadata> retrievedResponse = await indexServiceClient.PollOnceUpdateIndexAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Index retrievedResult = retrievedResponse.Result;
}

// Create client
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
gcav::UpdateIndexRequest request = new gcav::UpdateIndexRequest
{
    Index = new gcav::Index(),
    UpdateMask = new FieldMask(),
};
// Make the request
Operation<gcav::Index, gcav::UpdateIndexOperationMetadata> response = await indexServiceClient.UpdateIndexAsync(request);

// Poll until the returned long-running operation is complete
Operation<gcav::Index, gcav::UpdateIndexOperationMetadata> completedResponse = await response.PollUntilCompletedAsync();
// Retrieve the operation result
gcav::Index 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<gcav::Index, gcav::UpdateIndexOperationMetadata> retrievedResponse = await indexServiceClient.PollOnceUpdateIndexAsync(operationName);
// Check if the retrieved long-running operation has completed
if (retrievedResponse.IsCompleted)
{
    // If it has completed, then access the result
    gcav::Index retrievedResult = retrievedResponse.Result;
}

// Create client
gcav::IndexServiceClient indexServiceClient = gcav::IndexServiceClient.Create();
// Initialize request argument(s)
gcav::UpsertDatapointsRequest request = new gcav::UpsertDatapointsRequest
{
    IndexAsIndexName = gcav::IndexName.FromProjectLocationIndex("[PROJECT]", "[LOCATION]", "[INDEX]"),
    Datapoints =
    {
        new gcav::IndexDatapoint(),
    },
    UpdateMask = new FieldMask(),
};
// Make the request
gcav::UpsertDatapointsResponse response = indexServiceClient.UpsertDatapoints(request);

// Create client
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
gcav::UpsertDatapointsRequest request = new gcav::UpsertDatapointsRequest
{
    IndexAsIndexName = gcav::IndexName.FromProjectLocationIndex("[PROJECT]", "[LOCATION]", "[INDEX]"),
    Datapoints =
    {
        new gcav::IndexDatapoint(),
    },
    UpdateMask = new FieldMask(),
};
// Make the request
gcav::UpsertDatapointsResponse response = await indexServiceClient.UpsertDatapointsAsync(request);

// Create client
gcav::IndexServiceClient indexServiceClient = await gcav::IndexServiceClient.CreateAsync();
// Initialize request argument(s)
gcav::UpsertDatapointsRequest request = new gcav::UpsertDatapointsRequest
{
    IndexAsIndexName = gcav::IndexName.FromProjectLocationIndex("[PROJECT]", "[LOCATION]", "[INDEX]"),
    Datapoints =
    {
        new gcav::IndexDatapoint(),
    },
    UpdateMask = new FieldMask(),
};
// Make the request
gcav::UpsertDatapointsResponse response = await indexServiceClient.UpsertDatapointsAsync(request);