Cloud AI Platform v1beta1 API - Class FeaturestoreServiceClient (1.0.0-beta12)

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
BatchCreateFeaturesRequest request = new BatchCreateFeaturesRequest
{
    ParentAsEntityTypeName = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]"),
    Requests =
    {
        new CreateFeatureRequest(),
    },
};
// Make the request
Operation<BatchCreateFeaturesResponse, BatchCreateFeaturesOperationMetadata> response = featurestoreServiceClient.BatchCreateFeatures(request);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
EntityTypeName parent = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
IEnumerable<CreateFeatureRequest> requests = new CreateFeatureRequest[]
{
    new CreateFeatureRequest(),
};
// Make the request
Operation<BatchCreateFeaturesResponse, BatchCreateFeaturesOperationMetadata> response = featurestoreServiceClient.BatchCreateFeatures(parent, requests);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
FeatureGroupName parent = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]");
IEnumerable<CreateFeatureRequest> requests = new CreateFeatureRequest[]
{
    new CreateFeatureRequest(),
};
// Make the request
Operation<BatchCreateFeaturesResponse, BatchCreateFeaturesOperationMetadata> response = featurestoreServiceClient.BatchCreateFeatures(parent, requests);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
IEnumerable<CreateFeatureRequest> requests = new CreateFeatureRequest[]
{
    new CreateFeatureRequest(),
};
// Make the request
Operation<BatchCreateFeaturesResponse, BatchCreateFeaturesOperationMetadata> response = featurestoreServiceClient.BatchCreateFeatures(parent, requests);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
BatchCreateFeaturesRequest request = new BatchCreateFeaturesRequest
{
    ParentAsEntityTypeName = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]"),
    Requests =
    {
        new CreateFeatureRequest(),
    },
};
// Make the request
Operation<BatchCreateFeaturesResponse, BatchCreateFeaturesOperationMetadata> response = await featurestoreServiceClient.BatchCreateFeaturesAsync(request);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
BatchCreateFeaturesRequest request = new BatchCreateFeaturesRequest
{
    ParentAsEntityTypeName = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]"),
    Requests =
    {
        new CreateFeatureRequest(),
    },
};
// Make the request
Operation<BatchCreateFeaturesResponse, BatchCreateFeaturesOperationMetadata> response = await featurestoreServiceClient.BatchCreateFeaturesAsync(request);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
EntityTypeName parent = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
IEnumerable<CreateFeatureRequest> requests = new CreateFeatureRequest[]
{
    new CreateFeatureRequest(),
};
// Make the request
Operation<BatchCreateFeaturesResponse, BatchCreateFeaturesOperationMetadata> response = await featurestoreServiceClient.BatchCreateFeaturesAsync(parent, requests);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
EntityTypeName parent = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
IEnumerable<CreateFeatureRequest> requests = new CreateFeatureRequest[]
{
    new CreateFeatureRequest(),
};
// Make the request
Operation<BatchCreateFeaturesResponse, BatchCreateFeaturesOperationMetadata> response = await featurestoreServiceClient.BatchCreateFeaturesAsync(parent, requests);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
FeatureGroupName parent = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]");
IEnumerable<CreateFeatureRequest> requests = new CreateFeatureRequest[]
{
    new CreateFeatureRequest(),
};
// Make the request
Operation<BatchCreateFeaturesResponse, BatchCreateFeaturesOperationMetadata> response = await featurestoreServiceClient.BatchCreateFeaturesAsync(parent, requests);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
FeatureGroupName parent = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]");
IEnumerable<CreateFeatureRequest> requests = new CreateFeatureRequest[]
{
    new CreateFeatureRequest(),
};
// Make the request
Operation<BatchCreateFeaturesResponse, BatchCreateFeaturesOperationMetadata> response = await featurestoreServiceClient.BatchCreateFeaturesAsync(parent, requests);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
IEnumerable<CreateFeatureRequest> requests = new CreateFeatureRequest[]
{
    new CreateFeatureRequest(),
};
// Make the request
Operation<BatchCreateFeaturesResponse, BatchCreateFeaturesOperationMetadata> response = await featurestoreServiceClient.BatchCreateFeaturesAsync(parent, requests);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
IEnumerable<CreateFeatureRequest> requests = new CreateFeatureRequest[]
{
    new CreateFeatureRequest(),
};
// Make the request
Operation<BatchCreateFeaturesResponse, BatchCreateFeaturesOperationMetadata> response = await featurestoreServiceClient.BatchCreateFeaturesAsync(parent, requests);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
BatchReadFeatureValuesRequest request = new BatchReadFeatureValuesRequest
{
    FeaturestoreAsFeaturestoreName = FeaturestoreName.FromProjectLocationFeaturestore("[PROJECT]", "[LOCATION]", "[FEATURESTORE]"),
    CsvReadInstances = new CsvSource(),
    Destination = new FeatureValueDestination(),
    EntityTypeSpecs =
    {
        new BatchReadFeatureValuesRequest.Types.EntityTypeSpec(),
    },
    PassThroughFields =
    {
        new BatchReadFeatureValuesRequest.Types.PassThroughField(),
    },
    StartTime = new Timestamp(),
};
// Make the request
Operation<BatchReadFeatureValuesResponse, BatchReadFeatureValuesOperationMetadata> response = featurestoreServiceClient.BatchReadFeatureValues(request);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
FeaturestoreName featurestore = FeaturestoreName.FromProjectLocationFeaturestore("[PROJECT]", "[LOCATION]", "[FEATURESTORE]");
// Make the request
Operation<BatchReadFeatureValuesResponse, BatchReadFeatureValuesOperationMetadata> response = featurestoreServiceClient.BatchReadFeatureValues(featurestore);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
string featurestore = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]";
// Make the request
Operation<BatchReadFeatureValuesResponse, BatchReadFeatureValuesOperationMetadata> response = featurestoreServiceClient.BatchReadFeatureValues(featurestore);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
BatchReadFeatureValuesRequest request = new BatchReadFeatureValuesRequest
{
    FeaturestoreAsFeaturestoreName = FeaturestoreName.FromProjectLocationFeaturestore("[PROJECT]", "[LOCATION]", "[FEATURESTORE]"),
    CsvReadInstances = new CsvSource(),
    Destination = new FeatureValueDestination(),
    EntityTypeSpecs =
    {
        new BatchReadFeatureValuesRequest.Types.EntityTypeSpec(),
    },
    PassThroughFields =
    {
        new BatchReadFeatureValuesRequest.Types.PassThroughField(),
    },
    StartTime = new Timestamp(),
};
// Make the request
Operation<BatchReadFeatureValuesResponse, BatchReadFeatureValuesOperationMetadata> response = await featurestoreServiceClient.BatchReadFeatureValuesAsync(request);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
BatchReadFeatureValuesRequest request = new BatchReadFeatureValuesRequest
{
    FeaturestoreAsFeaturestoreName = FeaturestoreName.FromProjectLocationFeaturestore("[PROJECT]", "[LOCATION]", "[FEATURESTORE]"),
    CsvReadInstances = new CsvSource(),
    Destination = new FeatureValueDestination(),
    EntityTypeSpecs =
    {
        new BatchReadFeatureValuesRequest.Types.EntityTypeSpec(),
    },
    PassThroughFields =
    {
        new BatchReadFeatureValuesRequest.Types.PassThroughField(),
    },
    StartTime = new Timestamp(),
};
// Make the request
Operation<BatchReadFeatureValuesResponse, BatchReadFeatureValuesOperationMetadata> response = await featurestoreServiceClient.BatchReadFeatureValuesAsync(request);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
FeaturestoreName featurestore = FeaturestoreName.FromProjectLocationFeaturestore("[PROJECT]", "[LOCATION]", "[FEATURESTORE]");
// Make the request
Operation<BatchReadFeatureValuesResponse, BatchReadFeatureValuesOperationMetadata> response = await featurestoreServiceClient.BatchReadFeatureValuesAsync(featurestore);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
FeaturestoreName featurestore = FeaturestoreName.FromProjectLocationFeaturestore("[PROJECT]", "[LOCATION]", "[FEATURESTORE]");
// Make the request
Operation<BatchReadFeatureValuesResponse, BatchReadFeatureValuesOperationMetadata> response = await featurestoreServiceClient.BatchReadFeatureValuesAsync(featurestore);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string featurestore = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]";
// Make the request
Operation<BatchReadFeatureValuesResponse, BatchReadFeatureValuesOperationMetadata> response = await featurestoreServiceClient.BatchReadFeatureValuesAsync(featurestore);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string featurestore = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]";
// Make the request
Operation<BatchReadFeatureValuesResponse, BatchReadFeatureValuesOperationMetadata> response = await featurestoreServiceClient.BatchReadFeatureValuesAsync(featurestore);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
CreateEntityTypeRequest request = new CreateEntityTypeRequest
{
    ParentAsFeaturestoreName = FeaturestoreName.FromProjectLocationFeaturestore("[PROJECT]", "[LOCATION]", "[FEATURESTORE]"),
    EntityType = new EntityType(),
    EntityTypeId = "",
};
// Make the request
Operation<EntityType, CreateEntityTypeOperationMetadata> response = featurestoreServiceClient.CreateEntityType(request);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
FeaturestoreName parent = FeaturestoreName.FromProjectLocationFeaturestore("[PROJECT]", "[LOCATION]", "[FEATURESTORE]");
EntityType entityType = new EntityType();
// Make the request
Operation<EntityType, CreateEntityTypeOperationMetadata> response = featurestoreServiceClient.CreateEntityType(parent, entityType);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
FeaturestoreName parent = FeaturestoreName.FromProjectLocationFeaturestore("[PROJECT]", "[LOCATION]", "[FEATURESTORE]");
EntityType entityType = new EntityType();
string entityTypeId = "";
// Make the request
Operation<EntityType, CreateEntityTypeOperationMetadata> response = featurestoreServiceClient.CreateEntityType(parent, entityType, entityTypeId);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]";
EntityType entityType = new EntityType();
// Make the request
Operation<EntityType, CreateEntityTypeOperationMetadata> response = featurestoreServiceClient.CreateEntityType(parent, entityType);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]";
EntityType entityType = new EntityType();
string entityTypeId = "";
// Make the request
Operation<EntityType, CreateEntityTypeOperationMetadata> response = featurestoreServiceClient.CreateEntityType(parent, entityType, entityTypeId);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
CreateEntityTypeRequest request = new CreateEntityTypeRequest
{
    ParentAsFeaturestoreName = FeaturestoreName.FromProjectLocationFeaturestore("[PROJECT]", "[LOCATION]", "[FEATURESTORE]"),
    EntityType = new EntityType(),
    EntityTypeId = "",
};
// Make the request
Operation<EntityType, CreateEntityTypeOperationMetadata> response = await featurestoreServiceClient.CreateEntityTypeAsync(request);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
CreateEntityTypeRequest request = new CreateEntityTypeRequest
{
    ParentAsFeaturestoreName = FeaturestoreName.FromProjectLocationFeaturestore("[PROJECT]", "[LOCATION]", "[FEATURESTORE]"),
    EntityType = new EntityType(),
    EntityTypeId = "",
};
// Make the request
Operation<EntityType, CreateEntityTypeOperationMetadata> response = await featurestoreServiceClient.CreateEntityTypeAsync(request);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
FeaturestoreName parent = FeaturestoreName.FromProjectLocationFeaturestore("[PROJECT]", "[LOCATION]", "[FEATURESTORE]");
EntityType entityType = new EntityType();
// Make the request
Operation<EntityType, CreateEntityTypeOperationMetadata> response = await featurestoreServiceClient.CreateEntityTypeAsync(parent, entityType);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
FeaturestoreName parent = FeaturestoreName.FromProjectLocationFeaturestore("[PROJECT]", "[LOCATION]", "[FEATURESTORE]");
EntityType entityType = new EntityType();
string entityTypeId = "";
// Make the request
Operation<EntityType, CreateEntityTypeOperationMetadata> response = await featurestoreServiceClient.CreateEntityTypeAsync(parent, entityType, entityTypeId);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
FeaturestoreName parent = FeaturestoreName.FromProjectLocationFeaturestore("[PROJECT]", "[LOCATION]", "[FEATURESTORE]");
EntityType entityType = new EntityType();
string entityTypeId = "";
// Make the request
Operation<EntityType, CreateEntityTypeOperationMetadata> response = await featurestoreServiceClient.CreateEntityTypeAsync(parent, entityType, entityTypeId);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
FeaturestoreName parent = FeaturestoreName.FromProjectLocationFeaturestore("[PROJECT]", "[LOCATION]", "[FEATURESTORE]");
EntityType entityType = new EntityType();
// Make the request
Operation<EntityType, CreateEntityTypeOperationMetadata> response = await featurestoreServiceClient.CreateEntityTypeAsync(parent, entityType);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]";
EntityType entityType = new EntityType();
// Make the request
Operation<EntityType, CreateEntityTypeOperationMetadata> response = await featurestoreServiceClient.CreateEntityTypeAsync(parent, entityType);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]";
EntityType entityType = new EntityType();
string entityTypeId = "";
// Make the request
Operation<EntityType, CreateEntityTypeOperationMetadata> response = await featurestoreServiceClient.CreateEntityTypeAsync(parent, entityType, entityTypeId);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]";
EntityType entityType = new EntityType();
string entityTypeId = "";
// Make the request
Operation<EntityType, CreateEntityTypeOperationMetadata> response = await featurestoreServiceClient.CreateEntityTypeAsync(parent, entityType, entityTypeId);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]";
EntityType entityType = new EntityType();
// Make the request
Operation<EntityType, CreateEntityTypeOperationMetadata> response = await featurestoreServiceClient.CreateEntityTypeAsync(parent, entityType);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
CreateFeatureRequest request = new CreateFeatureRequest
{
    ParentAsEntityTypeName = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]"),
    Feature = new Feature(),
    FeatureId = "",
};
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = featurestoreServiceClient.CreateFeature(request);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
EntityTypeName parent = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
Feature feature = new Feature();
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = featurestoreServiceClient.CreateFeature(parent, feature);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
EntityTypeName parent = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
Feature feature = new Feature();
string featureId = "";
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = featurestoreServiceClient.CreateFeature(parent, feature, featureId);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
FeatureGroupName parent = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]");
Feature feature = new Feature();
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = featurestoreServiceClient.CreateFeature(parent, feature);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
FeatureGroupName parent = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]");
Feature feature = new Feature();
string featureId = "";
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = featurestoreServiceClient.CreateFeature(parent, feature, featureId);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
Feature feature = new Feature();
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = featurestoreServiceClient.CreateFeature(parent, feature);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
Feature feature = new Feature();
string featureId = "";
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = featurestoreServiceClient.CreateFeature(parent, feature, featureId);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
CreateFeatureRequest request = new CreateFeatureRequest
{
    ParentAsEntityTypeName = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]"),
    Feature = new Feature(),
    FeatureId = "",
};
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featurestoreServiceClient.CreateFeatureAsync(request);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
CreateFeatureRequest request = new CreateFeatureRequest
{
    ParentAsEntityTypeName = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]"),
    Feature = new Feature(),
    FeatureId = "",
};
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featurestoreServiceClient.CreateFeatureAsync(request);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
EntityTypeName parent = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
Feature feature = new Feature();
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featurestoreServiceClient.CreateFeatureAsync(parent, feature);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
EntityTypeName parent = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
Feature feature = new Feature();
string featureId = "";
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featurestoreServiceClient.CreateFeatureAsync(parent, feature, featureId);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
EntityTypeName parent = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
Feature feature = new Feature();
string featureId = "";
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featurestoreServiceClient.CreateFeatureAsync(parent, feature, featureId);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
EntityTypeName parent = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
Feature feature = new Feature();
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featurestoreServiceClient.CreateFeatureAsync(parent, feature);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
FeatureGroupName parent = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]");
Feature feature = new Feature();
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featurestoreServiceClient.CreateFeatureAsync(parent, feature);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
FeatureGroupName parent = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]");
Feature feature = new Feature();
string featureId = "";
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featurestoreServiceClient.CreateFeatureAsync(parent, feature, featureId);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
FeatureGroupName parent = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]");
Feature feature = new Feature();
string featureId = "";
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featurestoreServiceClient.CreateFeatureAsync(parent, feature, featureId);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
FeatureGroupName parent = FeatureGroupName.FromProjectLocationFeatureGroup("[PROJECT]", "[LOCATION]", "[FEATURE_GROUP]");
Feature feature = new Feature();
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featurestoreServiceClient.CreateFeatureAsync(parent, feature);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
Feature feature = new Feature();
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featurestoreServiceClient.CreateFeatureAsync(parent, feature);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
Feature feature = new Feature();
string featureId = "";
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featurestoreServiceClient.CreateFeatureAsync(parent, feature, featureId);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
Feature feature = new Feature();
string featureId = "";
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featurestoreServiceClient.CreateFeatureAsync(parent, feature, featureId);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
Feature feature = new Feature();
// Make the request
Operation<Feature, CreateFeatureOperationMetadata> response = await featurestoreServiceClient.CreateFeatureAsync(parent, feature);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Featurestore featurestore = new Featurestore();
// Make the request
Operation<Featurestore, CreateFeaturestoreOperationMetadata> response = featurestoreServiceClient.CreateFeaturestore(parent, featurestore);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Featurestore featurestore = new Featurestore();
string featurestoreId = "";
// Make the request
Operation<Featurestore, CreateFeaturestoreOperationMetadata> response = featurestoreServiceClient.CreateFeaturestore(parent, featurestore, featurestoreId);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
CreateFeaturestoreRequest request = new CreateFeaturestoreRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Featurestore = new Featurestore(),
    FeaturestoreId = "",
};
// Make the request
Operation<Featurestore, CreateFeaturestoreOperationMetadata> response = featurestoreServiceClient.CreateFeaturestore(request);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Featurestore featurestore = new Featurestore();
// Make the request
Operation<Featurestore, CreateFeaturestoreOperationMetadata> response = featurestoreServiceClient.CreateFeaturestore(parent, featurestore);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Featurestore featurestore = new Featurestore();
string featurestoreId = "";
// Make the request
Operation<Featurestore, CreateFeaturestoreOperationMetadata> response = featurestoreServiceClient.CreateFeaturestore(parent, featurestore, featurestoreId);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Featurestore featurestore = new Featurestore();
// Make the request
Operation<Featurestore, CreateFeaturestoreOperationMetadata> response = await featurestoreServiceClient.CreateFeaturestoreAsync(parent, featurestore);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Featurestore featurestore = new Featurestore();
string featurestoreId = "";
// Make the request
Operation<Featurestore, CreateFeaturestoreOperationMetadata> response = await featurestoreServiceClient.CreateFeaturestoreAsync(parent, featurestore, featurestoreId);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Featurestore featurestore = new Featurestore();
string featurestoreId = "";
// Make the request
Operation<Featurestore, CreateFeaturestoreOperationMetadata> response = await featurestoreServiceClient.CreateFeaturestoreAsync(parent, featurestore, featurestoreId);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
LocationName parent = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]");
Featurestore featurestore = new Featurestore();
// Make the request
Operation<Featurestore, CreateFeaturestoreOperationMetadata> response = await featurestoreServiceClient.CreateFeaturestoreAsync(parent, featurestore);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
CreateFeaturestoreRequest request = new CreateFeaturestoreRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Featurestore = new Featurestore(),
    FeaturestoreId = "",
};
// Make the request
Operation<Featurestore, CreateFeaturestoreOperationMetadata> response = await featurestoreServiceClient.CreateFeaturestoreAsync(request);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
CreateFeaturestoreRequest request = new CreateFeaturestoreRequest
{
    ParentAsLocationName = LocationName.FromProjectLocation("[PROJECT]", "[LOCATION]"),
    Featurestore = new Featurestore(),
    FeaturestoreId = "",
};
// Make the request
Operation<Featurestore, CreateFeaturestoreOperationMetadata> response = await featurestoreServiceClient.CreateFeaturestoreAsync(request);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Featurestore featurestore = new Featurestore();
// Make the request
Operation<Featurestore, CreateFeaturestoreOperationMetadata> response = await featurestoreServiceClient.CreateFeaturestoreAsync(parent, featurestore);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Featurestore featurestore = new Featurestore();
string featurestoreId = "";
// Make the request
Operation<Featurestore, CreateFeaturestoreOperationMetadata> response = await featurestoreServiceClient.CreateFeaturestoreAsync(parent, featurestore, featurestoreId);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Featurestore featurestore = new Featurestore();
string featurestoreId = "";
// Make the request
Operation<Featurestore, CreateFeaturestoreOperationMetadata> response = await featurestoreServiceClient.CreateFeaturestoreAsync(parent, featurestore, featurestoreId);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string parent = "projects/[PROJECT]/locations/[LOCATION]";
Featurestore featurestore = new Featurestore();
// Make the request
Operation<Featurestore, CreateFeaturestoreOperationMetadata> response = await featurestoreServiceClient.CreateFeaturestoreAsync(parent, featurestore);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
DeleteEntityTypeRequest request = new DeleteEntityTypeRequest
{
    EntityTypeName = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]"),
    Force = false,
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = featurestoreServiceClient.DeleteEntityType(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 = featurestoreServiceClient.PollOnceDeleteEntityType(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
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
EntityTypeName name = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = featurestoreServiceClient.DeleteEntityType(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 = featurestoreServiceClient.PollOnceDeleteEntityType(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
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
EntityTypeName name = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
bool force = false;
// Make the request
Operation<Empty, DeleteOperationMetadata> response = featurestoreServiceClient.DeleteEntityType(name, force);

// 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 = featurestoreServiceClient.PollOnceDeleteEntityType(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
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = featurestoreServiceClient.DeleteEntityType(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 = featurestoreServiceClient.PollOnceDeleteEntityType(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
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
bool force = false;
// Make the request
Operation<Empty, DeleteOperationMetadata> response = featurestoreServiceClient.DeleteEntityType(name, force);

// 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 = featurestoreServiceClient.PollOnceDeleteEntityType(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
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteEntityTypeRequest request = new DeleteEntityTypeRequest
{
    EntityTypeName = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]"),
    Force = false,
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featurestoreServiceClient.DeleteEntityTypeAsync(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 featurestoreServiceClient.PollOnceDeleteEntityTypeAsync(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
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteEntityTypeRequest request = new DeleteEntityTypeRequest
{
    EntityTypeName = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]"),
    Force = false,
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featurestoreServiceClient.DeleteEntityTypeAsync(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 featurestoreServiceClient.PollOnceDeleteEntityTypeAsync(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
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
EntityTypeName name = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featurestoreServiceClient.DeleteEntityTypeAsync(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 featurestoreServiceClient.PollOnceDeleteEntityTypeAsync(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
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
EntityTypeName name = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
bool force = false;
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featurestoreServiceClient.DeleteEntityTypeAsync(name, force);

// 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 featurestoreServiceClient.PollOnceDeleteEntityTypeAsync(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
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
EntityTypeName name = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
bool force = false;
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featurestoreServiceClient.DeleteEntityTypeAsync(name, force);

// 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 featurestoreServiceClient.PollOnceDeleteEntityTypeAsync(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
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
EntityTypeName name = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featurestoreServiceClient.DeleteEntityTypeAsync(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 featurestoreServiceClient.PollOnceDeleteEntityTypeAsync(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
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featurestoreServiceClient.DeleteEntityTypeAsync(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 featurestoreServiceClient.PollOnceDeleteEntityTypeAsync(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
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
bool force = false;
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featurestoreServiceClient.DeleteEntityTypeAsync(name, force);

// 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 featurestoreServiceClient.PollOnceDeleteEntityTypeAsync(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
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
bool force = false;
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featurestoreServiceClient.DeleteEntityTypeAsync(name, force);

// 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 featurestoreServiceClient.PollOnceDeleteEntityTypeAsync(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
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featurestoreServiceClient.DeleteEntityTypeAsync(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 featurestoreServiceClient.PollOnceDeleteEntityTypeAsync(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
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
DeleteFeatureRequest request = new DeleteFeatureRequest
{
    FeatureName = FeatureName.FromProjectLocationFeaturestoreEntityTypeFeature("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]", "[FEATURE]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = featurestoreServiceClient.DeleteFeature(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 = featurestoreServiceClient.PollOnceDeleteFeature(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
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
FeatureName name = FeatureName.FromProjectLocationFeaturestoreEntityTypeFeature("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]", "[FEATURE]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = featurestoreServiceClient.DeleteFeature(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 = featurestoreServiceClient.PollOnceDeleteFeature(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
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]/features/[FEATURE]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = featurestoreServiceClient.DeleteFeature(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 = featurestoreServiceClient.PollOnceDeleteFeature(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
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteFeatureRequest request = new DeleteFeatureRequest
{
    FeatureName = FeatureName.FromProjectLocationFeaturestoreEntityTypeFeature("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]", "[FEATURE]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featurestoreServiceClient.DeleteFeatureAsync(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 featurestoreServiceClient.PollOnceDeleteFeatureAsync(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
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteFeatureRequest request = new DeleteFeatureRequest
{
    FeatureName = FeatureName.FromProjectLocationFeaturestoreEntityTypeFeature("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]", "[FEATURE]"),
};
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featurestoreServiceClient.DeleteFeatureAsync(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 featurestoreServiceClient.PollOnceDeleteFeatureAsync(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
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
FeatureName name = FeatureName.FromProjectLocationFeaturestoreEntityTypeFeature("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]", "[FEATURE]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featurestoreServiceClient.DeleteFeatureAsync(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 featurestoreServiceClient.PollOnceDeleteFeatureAsync(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
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
FeatureName name = FeatureName.FromProjectLocationFeaturestoreEntityTypeFeature("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]", "[FEATURE]");
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featurestoreServiceClient.DeleteFeatureAsync(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 featurestoreServiceClient.PollOnceDeleteFeatureAsync(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
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]/features/[FEATURE]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featurestoreServiceClient.DeleteFeatureAsync(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 featurestoreServiceClient.PollOnceDeleteFeatureAsync(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
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]/features/[FEATURE]";
// Make the request
Operation<Empty, DeleteOperationMetadata> response = await featurestoreServiceClient.DeleteFeatureAsync(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 featurestoreServiceClient.PollOnceDeleteFeatureAsync(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
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
DeleteFeatureValuesRequest request = new DeleteFeatureValuesRequest
{
    EntityTypeAsEntityTypeName = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]"),
    SelectEntity = new DeleteFeatureValuesRequest.Types.SelectEntity(),
};
// Make the request
Operation<DeleteFeatureValuesResponse, DeleteFeatureValuesOperationMetadata> response = featurestoreServiceClient.DeleteFeatureValues(request);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
EntityTypeName entityType = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
// Make the request
Operation<DeleteFeatureValuesResponse, DeleteFeatureValuesOperationMetadata> response = featurestoreServiceClient.DeleteFeatureValues(entityType);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = FeaturestoreServiceClient.Create();
// Initialize request argument(s)
string entityType = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
// Make the request
Operation<DeleteFeatureValuesResponse, DeleteFeatureValuesOperationMetadata> response = featurestoreServiceClient.DeleteFeatureValues(entityType);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteFeatureValuesRequest request = new DeleteFeatureValuesRequest
{
    EntityTypeAsEntityTypeName = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]"),
    SelectEntity = new DeleteFeatureValuesRequest.Types.SelectEntity(),
};
// Make the request
Operation<DeleteFeatureValuesResponse, DeleteFeatureValuesOperationMetadata> response = await featurestoreServiceClient.DeleteFeatureValuesAsync(request);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
DeleteFeatureValuesRequest request = new DeleteFeatureValuesRequest
{
    EntityTypeAsEntityTypeName = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]"),
    SelectEntity = new DeleteFeatureValuesRequest.Types.SelectEntity(),
};
// Make the request
Operation<DeleteFeatureValuesResponse, DeleteFeatureValuesOperationMetadata> response = await featurestoreServiceClient.DeleteFeatureValuesAsync(request);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
EntityTypeName entityType = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
// Make the request
Operation<DeleteFeatureValuesResponse, DeleteFeatureValuesOperationMetadata> response = await featurestoreServiceClient.DeleteFeatureValuesAsync(entityType);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
EntityTypeName entityType = EntityTypeName.FromProjectLocationFeaturestoreEntityType("[PROJECT]", "[LOCATION]", "[FEATURESTORE]", "[ENTITY_TYPE]");
// Make the request
Operation<DeleteFeatureValuesResponse, DeleteFeatureValuesOperationMetadata> response = await featurestoreServiceClient.DeleteFeatureValuesAsync(entityType);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string entityType = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
// Make the request
Operation<DeleteFeatureValuesResponse, DeleteFeatureValuesOperationMetadata> response = await featurestoreServiceClient.DeleteFeatureValuesAsync(entityType);

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

// Create client
FeaturestoreServiceClient featurestoreServiceClient = await FeaturestoreServiceClient.CreateAsync();
// Initialize request argument(s)
string entityType = "projects/[PROJECT]/locations/[LOCATION]/featurestores/[FEATURESTORE]/entityTypes/[ENTITY_TYPE]";
// Make the request
Operation<DeleteFeatureValuesResponse, DeleteFeatureValuesOperationMetadata> response = await featurestoreServiceClient.DeleteFeatureValuesAsync(entityType);

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