curl \
  -X PUT 'MEILISEARCH_URL/indexes/movies/settings/filterable-attributes' \
  -H 'Content-Type: application/json' \
  --data-binary '[
    "genres",
    "director",
    {
      "attributePatterns": ["*_ratings"],
      "features": {
        "facetSearch": false,
        "filter": {
          "equality": true,
          "comparison": false
        }
      }
    }
  ]'

client.index('movies')
  .updateFilterableAttributes([
    "genres",
    {
      attributePatterns: ["genre"],
      features: {
        facetSearch: true,
        filter: { equality: true, comparison: false },
      },
    }
  ])

$client->index('movies')->updateFilterableAttributes([
  'author',
  [
      'attributePatterns' => ['genres'],
      'features' => [
          'facetSearch' => true,
          'filter' => [
              'equality' => true,
              'comparison' => false,
          ],
      ],
  ],
]);

client.index('movies').update_filterable_attributes([
  'genres',
  'director'
])

FilterableAttributesConfig genres = FilterableAttributesConfig.simple("genres");

FilterableAttributesFilter directorFilter = new FilterableAttributesFilter();
directorFilter.setEquality(true);
directorFilter.setComparison(false);

FilterableAttributesFeatures directorFeatures = new FilterableAttributesFeatures();
directorFeatures.setFacetSearch(true);
directorFeatures.setFilter(directorFilter);

FilterableAttributesConfig director = new FilterableAttributesConfig();
director.setAttributePatterns(new String[] {"director"});
director.setFeatures(directorFeatures);

// Update settings
client.index("movies").updateGranularFilterableAttributesSettings(
  new FilterableAttributesConfig[] {genres, director});

client.index('movies').update_filterable_attributes([
  'genres',
  'director'
])

filterableAttributes := []interface{}{
  "genres",
  "director",
  AttributeRule{
    AttributePatterns: []string{"tag"}
    Features: AttributeFeatures{
      FacetSearch: false,
      Filter: FilterFeatures{
        Equality:   true,
        Comparison: false,
      }
    }
  },
  map[string]interface{}{
    "attributePatterns": []interface{}{"year"}
    "features": map[string]interface{}{
      "facetSearch": false,
      "filter": map[string]interface{}{
        "equality":   true,
        "comparison": true,
      }
    }
  }
}
client.Index("movies").UpdateFilterableAttributes(&filterableAttributes)

var attributes = new FilterableAttribute[]
{
    "director",
    new FilterableAttribute
    {
        AttributePatterns = new[] { "genres" },
        Features = new FilterableAttributeFeatures
        {
            FacetSearch = true,
            Filter = new FilterableAttributeFilterFeatures
            {
                Equality = true,
                Comparison = true,
            },
        },
    },
};
TaskInfo result = await client.Index("movies").UpdateFilterableAttributesAsync(attributes);

use meilisearch_sdk::settings::{
  FilterableAttribute,
  FilterableAttributesSettings,
  FilterFeatures,
  FilterFeatureModes,
};

// Mixed legacy + new syntax
let filterable_attributes: Vec<FilterableAttribute> = vec![
  // legacy: plain attribute name
  "author".into(),
  // new syntax: settings object
  FilterableAttribute::Settings(FilterableAttributesSettings {
    attribute_patterns: vec!["genre".to_string()],
    features: FilterFeatures {
      facet_search: true,
      filter: FilterFeatureModes { equality: true, comparison: false },
    },
  }),
];

let task: TaskInfo = client
  .index("movies")
  .set_filterable_attributes_advanced(filterable_attributes)
  .await
  .unwrap();

await client
    .index('movies')
    .updateFilterableAttributes(['genres', 'director']);

client.index("movies").updateFilterableAttributes(["genre", "director"]) { (result) in
    switch result {
    case .success(let task):
        print(task)
    case .failure(let error):
        print(error)
    }
}

{
  "taskUid": 147,
  "indexUid": "movies",
  "status": "enqueued",
  "type": "settingsUpdate",
  "enqueuedAt": "2024-08-08T17:05:55.791772Z"
}

{
  "message": "The Authorization header is missing. It must use the bearer authorization method.",
  "code": "missing_authorization_header",
  "type": "auth",
  "link": "https://docs.meilisearch.com/errors#missing_authorization_header"
}

{
  "message": "Index `movies` not found.",
  "code": "index_not_found",
  "type": "invalid_request",
  "link": "https://docs.meilisearch.com/errors#index_not_found"
}