Cloud AI Platform v1beta1 API - Class IndexEndpointServiceClient (1.0.0-beta09)

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = IndexEndpointServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
IndexEndpoint indexEndpoint = new IndexEndpoint();
// Make the request
Operation<IndexEndpoint, CreateIndexEndpointOperationMetadata> response = indexEndpointServiceClient.CreateIndexEndpoint(parent, indexEndpoint);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = IndexEndpointServiceClient.Create();
// Initialize request argument(s)
CreateIndexEndpointRequest request = new CreateIndexEndpointRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    IndexEndpoint = new IndexEndpoint(),
};
// Make the request
Operation<IndexEndpoint, CreateIndexEndpointOperationMetadata> response = indexEndpointServiceClient.CreateIndexEndpoint(request);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = IndexEndpointServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
IndexEndpoint indexEndpoint = new IndexEndpoint();
// Make the request
Operation<IndexEndpoint, CreateIndexEndpointOperationMetadata> response = indexEndpointServiceClient.CreateIndexEndpoint(parent, indexEndpoint);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
IndexEndpoint indexEndpoint = new IndexEndpoint();
// Make the request
Operation<IndexEndpoint, CreateIndexEndpointOperationMetadata> response = await indexEndpointServiceClient.CreateIndexEndpointAsync(parent, indexEndpoint);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
IndexEndpoint indexEndpoint = new IndexEndpoint();
// Make the request
Operation<IndexEndpoint, CreateIndexEndpointOperationMetadata> response = await indexEndpointServiceClient.CreateIndexEndpointAsync(parent, indexEndpoint);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
CreateIndexEndpointRequest request = new CreateIndexEndpointRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    IndexEndpoint = new IndexEndpoint(),
};
// Make the request
Operation<IndexEndpoint, CreateIndexEndpointOperationMetadata> response = await indexEndpointServiceClient.CreateIndexEndpointAsync(request);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
CreateIndexEndpointRequest request = new CreateIndexEndpointRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    IndexEndpoint = new IndexEndpoint(),
};
// Make the request
Operation<IndexEndpoint, CreateIndexEndpointOperationMetadata> response = await indexEndpointServiceClient.CreateIndexEndpointAsync(request);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
IndexEndpoint indexEndpoint = new IndexEndpoint();
// Make the request
Operation<IndexEndpoint, CreateIndexEndpointOperationMetadata> response = await indexEndpointServiceClient.CreateIndexEndpointAsync(parent, indexEndpoint);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
IndexEndpoint indexEndpoint = new IndexEndpoint();
// Make the request
Operation<IndexEndpoint, CreateIndexEndpointOperationMetadata> response = await indexEndpointServiceClient.CreateIndexEndpointAsync(parent, indexEndpoint);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = IndexEndpointServiceClient.Create();
// Initialize request argument(s)
DeleteIndexEndpointRequest request = new DeleteIndexEndpointRequest
{
    IndexEndpointName = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = indexEndpointServiceClient.DeleteIndexEndpoint(request);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, DeleteOperationMetadata> retrievedResponse = indexEndpointServiceClient.PollOnceDeleteIndexEndpoint(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
IndexEndpointServiceClient indexEndpointServiceClient = IndexEndpointServiceClient.Create();
// Initialize request argument(s)
IndexEndpointName name = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = indexEndpointServiceClient.DeleteIndexEndpoint(name);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, DeleteOperationMetadata> retrievedResponse = indexEndpointServiceClient.PollOnceDeleteIndexEndpoint(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
IndexEndpointServiceClient indexEndpointServiceClient = IndexEndpointServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/indexEndpoints/[INDEX_ENDPOINT]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = indexEndpointServiceClient.DeleteIndexEndpoint(name);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, DeleteOperationMetadata> retrievedResponse = indexEndpointServiceClient.PollOnceDeleteIndexEndpoint(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
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteIndexEndpointRequest request = new DeleteIndexEndpointRequest
{
    IndexEndpointName = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await indexEndpointServiceClient.DeleteIndexEndpointAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, DeleteOperationMetadata> retrievedResponse = await indexEndpointServiceClient.PollOnceDeleteIndexEndpointAsync(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
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteIndexEndpointRequest request = new DeleteIndexEndpointRequest
{
    IndexEndpointName = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await indexEndpointServiceClient.DeleteIndexEndpointAsync(request);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, DeleteOperationMetadata> retrievedResponse = await indexEndpointServiceClient.PollOnceDeleteIndexEndpointAsync(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
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
IndexEndpointName name = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await indexEndpointServiceClient.DeleteIndexEndpointAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, DeleteOperationMetadata> retrievedResponse = await indexEndpointServiceClient.PollOnceDeleteIndexEndpointAsync(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
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
IndexEndpointName name = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await indexEndpointServiceClient.DeleteIndexEndpointAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, DeleteOperationMetadata> retrievedResponse = await indexEndpointServiceClient.PollOnceDeleteIndexEndpointAsync(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
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/indexEndpoints/[INDEX_ENDPOINT]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await indexEndpointServiceClient.DeleteIndexEndpointAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, DeleteOperationMetadata> retrievedResponse = await indexEndpointServiceClient.PollOnceDeleteIndexEndpointAsync(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
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/indexEndpoints/[INDEX_ENDPOINT]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await indexEndpointServiceClient.DeleteIndexEndpointAsync(name);

// Poll until the returned long-running operation is complete
Operation<Empty, 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, DeleteOperationMetadata> retrievedResponse = await indexEndpointServiceClient.PollOnceDeleteIndexEndpointAsync(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
IndexEndpointServiceClient indexEndpointServiceClient = IndexEndpointServiceClient.Create();
// Initialize request argument(s)
DeployIndexRequest request = new DeployIndexRequest
{
    IndexEndpointAsIndexEndpointName = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]"),
    DeployedIndex = new DeployedIndex(),
};
// Make the request
Operation<DeployIndexResponse, DeployIndexOperationMetadata> response = indexEndpointServiceClient.DeployIndex(request);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = IndexEndpointServiceClient.Create();
// Initialize request argument(s)
IndexEndpointName indexEndpoint = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]");
DeployedIndex deployedIndex = new DeployedIndex();
// Make the request
Operation<DeployIndexResponse, DeployIndexOperationMetadata> response = indexEndpointServiceClient.DeployIndex(indexEndpoint, deployedIndex);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = IndexEndpointServiceClient.Create();
// Initialize request argument(s)
string indexEndpoint = "projects/[PROJECT]/locations/[LOCATION]/indexEndpoints/[INDEX_ENDPOINT]";
DeployedIndex deployedIndex = new DeployedIndex();
// Make the request
Operation<DeployIndexResponse, DeployIndexOperationMetadata> response = indexEndpointServiceClient.DeployIndex(indexEndpoint, deployedIndex);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
DeployIndexRequest request = new DeployIndexRequest
{
    IndexEndpointAsIndexEndpointName = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]"),
    DeployedIndex = new DeployedIndex(),
};
// Make the request
Operation<DeployIndexResponse, DeployIndexOperationMetadata> response = await indexEndpointServiceClient.DeployIndexAsync(request);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
DeployIndexRequest request = new DeployIndexRequest
{
    IndexEndpointAsIndexEndpointName = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]"),
    DeployedIndex = new DeployedIndex(),
};
// Make the request
Operation<DeployIndexResponse, DeployIndexOperationMetadata> response = await indexEndpointServiceClient.DeployIndexAsync(request);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
IndexEndpointName indexEndpoint = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]");
DeployedIndex deployedIndex = new DeployedIndex();
// Make the request
Operation<DeployIndexResponse, DeployIndexOperationMetadata> response = await indexEndpointServiceClient.DeployIndexAsync(indexEndpoint, deployedIndex);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
IndexEndpointName indexEndpoint = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]");
DeployedIndex deployedIndex = new DeployedIndex();
// Make the request
Operation<DeployIndexResponse, DeployIndexOperationMetadata> response = await indexEndpointServiceClient.DeployIndexAsync(indexEndpoint, deployedIndex);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
string indexEndpoint = "projects/[PROJECT]/locations/[LOCATION]/indexEndpoints/[INDEX_ENDPOINT]";
DeployedIndex deployedIndex = new DeployedIndex();
// Make the request
Operation<DeployIndexResponse, DeployIndexOperationMetadata> response = await indexEndpointServiceClient.DeployIndexAsync(indexEndpoint, deployedIndex);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
string indexEndpoint = "projects/[PROJECT]/locations/[LOCATION]/indexEndpoints/[INDEX_ENDPOINT]";
DeployedIndex deployedIndex = new DeployedIndex();
// Make the request
Operation<DeployIndexResponse, DeployIndexOperationMetadata> response = await indexEndpointServiceClient.DeployIndexAsync(indexEndpoint, deployedIndex);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = IndexEndpointServiceClient.Create();
// Initialize request argument(s)
GetIndexEndpointRequest request = new GetIndexEndpointRequest
{
    IndexEndpointName = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]"),
};
// Make the request
IndexEndpoint response = indexEndpointServiceClient.GetIndexEndpoint(request);

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = IndexEndpointServiceClient.Create();
// Initialize request argument(s)
IndexEndpointName name = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]");
// Make the request
IndexEndpoint response = indexEndpointServiceClient.GetIndexEndpoint(name);

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = IndexEndpointServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/indexEndpoints/[INDEX_ENDPOINT]";
// Make the request
IndexEndpoint response = indexEndpointServiceClient.GetIndexEndpoint(name);

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
GetIndexEndpointRequest request = new GetIndexEndpointRequest
{
    IndexEndpointName = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]"),
};
// Make the request
IndexEndpoint response = await indexEndpointServiceClient.GetIndexEndpointAsync(request);

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
GetIndexEndpointRequest request = new GetIndexEndpointRequest
{
    IndexEndpointName = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]"),
};
// Make the request
IndexEndpoint response = await indexEndpointServiceClient.GetIndexEndpointAsync(request);

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
IndexEndpointName name = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]");
// Make the request
IndexEndpoint response = await indexEndpointServiceClient.GetIndexEndpointAsync(name);

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
IndexEndpointName name = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]");
// Make the request
IndexEndpoint response = await indexEndpointServiceClient.GetIndexEndpointAsync(name);

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/indexEndpoints/[INDEX_ENDPOINT]";
// Make the request
IndexEndpoint response = await indexEndpointServiceClient.GetIndexEndpointAsync(name);

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/indexEndpoints/[INDEX_ENDPOINT]";
// Make the request
IndexEndpoint response = await indexEndpointServiceClient.GetIndexEndpointAsync(name);

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = IndexEndpointServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
// Make the request
PagedEnumerable<ListIndexEndpointsResponse, IndexEndpoint> response = indexEndpointServiceClient.ListIndexEndpoints(parent);

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

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

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

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

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

// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((IndexEndpoint 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((ListIndexEndpointsResponse page) =>
{
    // Do something with each page of items
    Console.WriteLine("A page of results:");
    foreach (IndexEndpoint 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<IndexEndpoint> 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 (IndexEndpoint 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
IndexEndpointServiceClient indexEndpointServiceClient = IndexEndpointServiceClient.Create();
// Initialize request argument(s)
IndexEndpointName indexEndpoint = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]");
DeployedIndex deployedIndex = new DeployedIndex();
// Make the request
Operation<MutateDeployedIndexResponse, MutateDeployedIndexOperationMetadata> response = indexEndpointServiceClient.MutateDeployedIndex(indexEndpoint, deployedIndex);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = IndexEndpointServiceClient.Create();
// Initialize request argument(s)
MutateDeployedIndexRequest request = new MutateDeployedIndexRequest
{
    IndexEndpointAsIndexEndpointName = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]"),
    DeployedIndex = new DeployedIndex(),
};
// Make the request
Operation<MutateDeployedIndexResponse, MutateDeployedIndexOperationMetadata> response = indexEndpointServiceClient.MutateDeployedIndex(request);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = IndexEndpointServiceClient.Create();
// Initialize request argument(s)
string indexEndpoint = "projects/[PROJECT]/locations/[LOCATION]/indexEndpoints/[INDEX_ENDPOINT]";
DeployedIndex deployedIndex = new DeployedIndex();
// Make the request
Operation<MutateDeployedIndexResponse, MutateDeployedIndexOperationMetadata> response = indexEndpointServiceClient.MutateDeployedIndex(indexEndpoint, deployedIndex);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
IndexEndpointName indexEndpoint = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]");
DeployedIndex deployedIndex = new DeployedIndex();
// Make the request
Operation<MutateDeployedIndexResponse, MutateDeployedIndexOperationMetadata> response = await indexEndpointServiceClient.MutateDeployedIndexAsync(indexEndpoint, deployedIndex);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
IndexEndpointName indexEndpoint = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]");
DeployedIndex deployedIndex = new DeployedIndex();
// Make the request
Operation<MutateDeployedIndexResponse, MutateDeployedIndexOperationMetadata> response = await indexEndpointServiceClient.MutateDeployedIndexAsync(indexEndpoint, deployedIndex);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
MutateDeployedIndexRequest request = new MutateDeployedIndexRequest
{
    IndexEndpointAsIndexEndpointName = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]"),
    DeployedIndex = new DeployedIndex(),
};
// Make the request
Operation<MutateDeployedIndexResponse, MutateDeployedIndexOperationMetadata> response = await indexEndpointServiceClient.MutateDeployedIndexAsync(request);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
MutateDeployedIndexRequest request = new MutateDeployedIndexRequest
{
    IndexEndpointAsIndexEndpointName = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]"),
    DeployedIndex = new DeployedIndex(),
};
// Make the request
Operation<MutateDeployedIndexResponse, MutateDeployedIndexOperationMetadata> response = await indexEndpointServiceClient.MutateDeployedIndexAsync(request);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
string indexEndpoint = "projects/[PROJECT]/locations/[LOCATION]/indexEndpoints/[INDEX_ENDPOINT]";
DeployedIndex deployedIndex = new DeployedIndex();
// Make the request
Operation<MutateDeployedIndexResponse, MutateDeployedIndexOperationMetadata> response = await indexEndpointServiceClient.MutateDeployedIndexAsync(indexEndpoint, deployedIndex);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
string indexEndpoint = "projects/[PROJECT]/locations/[LOCATION]/indexEndpoints/[INDEX_ENDPOINT]";
DeployedIndex deployedIndex = new DeployedIndex();
// Make the request
Operation<MutateDeployedIndexResponse, MutateDeployedIndexOperationMetadata> response = await indexEndpointServiceClient.MutateDeployedIndexAsync(indexEndpoint, deployedIndex);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = IndexEndpointServiceClient.Create();
// Initialize request argument(s)
IndexEndpointName indexEndpoint = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]");
string deployedIndexId = "";
// Make the request
Operation<UndeployIndexResponse, UndeployIndexOperationMetadata> response = indexEndpointServiceClient.UndeployIndex(indexEndpoint, deployedIndexId);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = IndexEndpointServiceClient.Create();
// Initialize request argument(s)
UndeployIndexRequest request = new UndeployIndexRequest
{
    IndexEndpointAsIndexEndpointName = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]"),
    DeployedIndexId = "",
};
// Make the request
Operation<UndeployIndexResponse, UndeployIndexOperationMetadata> response = indexEndpointServiceClient.UndeployIndex(request);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = IndexEndpointServiceClient.Create();
// Initialize request argument(s)
string indexEndpoint = "projects/[PROJECT]/locations/[LOCATION]/indexEndpoints/[INDEX_ENDPOINT]";
string deployedIndexId = "";
// Make the request
Operation<UndeployIndexResponse, UndeployIndexOperationMetadata> response = indexEndpointServiceClient.UndeployIndex(indexEndpoint, deployedIndexId);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
IndexEndpointName indexEndpoint = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]");
string deployedIndexId = "";
// Make the request
Operation<UndeployIndexResponse, UndeployIndexOperationMetadata> response = await indexEndpointServiceClient.UndeployIndexAsync(indexEndpoint, deployedIndexId);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
IndexEndpointName indexEndpoint = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]");
string deployedIndexId = "";
// Make the request
Operation<UndeployIndexResponse, UndeployIndexOperationMetadata> response = await indexEndpointServiceClient.UndeployIndexAsync(indexEndpoint, deployedIndexId);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
UndeployIndexRequest request = new UndeployIndexRequest
{
    IndexEndpointAsIndexEndpointName = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]"),
    DeployedIndexId = "",
};
// Make the request
Operation<UndeployIndexResponse, UndeployIndexOperationMetadata> response = await indexEndpointServiceClient.UndeployIndexAsync(request);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
UndeployIndexRequest request = new UndeployIndexRequest
{
    IndexEndpointAsIndexEndpointName = IndexEndpointName.FromProjectLocationIndexEndpoint("[PROJECT]", "[LOCATION]", "[INDEX_ENDPOINT]"),
    DeployedIndexId = "",
};
// Make the request
Operation<UndeployIndexResponse, UndeployIndexOperationMetadata> response = await indexEndpointServiceClient.UndeployIndexAsync(request);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
string indexEndpoint = "projects/[PROJECT]/locations/[LOCATION]/indexEndpoints/[INDEX_ENDPOINT]";
string deployedIndexId = "";
// Make the request
Operation<UndeployIndexResponse, UndeployIndexOperationMetadata> response = await indexEndpointServiceClient.UndeployIndexAsync(indexEndpoint, deployedIndexId);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
string indexEndpoint = "projects/[PROJECT]/locations/[LOCATION]/indexEndpoints/[INDEX_ENDPOINT]";
string deployedIndexId = "";
// Make the request
Operation<UndeployIndexResponse, UndeployIndexOperationMetadata> response = await indexEndpointServiceClient.UndeployIndexAsync(indexEndpoint, deployedIndexId);

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

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = IndexEndpointServiceClient.Create();
// Initialize request argument(s)
IndexEndpoint indexEndpoint = new IndexEndpoint();
FieldMask updateMask = new FieldMask();
// Make the request
IndexEndpoint response = indexEndpointServiceClient.UpdateIndexEndpoint(indexEndpoint, updateMask);

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = IndexEndpointServiceClient.Create();
// Initialize request argument(s)
UpdateIndexEndpointRequest request = new UpdateIndexEndpointRequest
{
    IndexEndpoint = new IndexEndpoint(),
    UpdateMask = new FieldMask(),
};
// Make the request
IndexEndpoint response = indexEndpointServiceClient.UpdateIndexEndpoint(request);

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
IndexEndpoint indexEndpoint = new IndexEndpoint();
FieldMask updateMask = new FieldMask();
// Make the request
IndexEndpoint response = await indexEndpointServiceClient.UpdateIndexEndpointAsync(indexEndpoint, updateMask);

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
IndexEndpoint indexEndpoint = new IndexEndpoint();
FieldMask updateMask = new FieldMask();
// Make the request
IndexEndpoint response = await indexEndpointServiceClient.UpdateIndexEndpointAsync(indexEndpoint, updateMask);

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateIndexEndpointRequest request = new UpdateIndexEndpointRequest
{
    IndexEndpoint = new IndexEndpoint(),
    UpdateMask = new FieldMask(),
};
// Make the request
IndexEndpoint response = await indexEndpointServiceClient.UpdateIndexEndpointAsync(request);

// Create client
IndexEndpointServiceClient indexEndpointServiceClient = await IndexEndpointServiceClient.CreateAsync();
// Initialize request argument(s)
UpdateIndexEndpointRequest request = new UpdateIndexEndpointRequest
{
    IndexEndpoint = new IndexEndpoint(),
    UpdateMask = new FieldMask(),
};
// Make the request
IndexEndpoint response = await indexEndpointServiceClient.UpdateIndexEndpointAsync(request);