curl --request POST \
  --url 'https://algolia_application_id.algolia.net/1/indexes/ALGOLIA_INDEX_NAME/rules/batch?forwardToReplicas=true&clearExistingRules=true' \
  --header 'accept: application/json' \
  --header 'content-type: application/json' \
  --header 'x-algolia-api-key: ALGOLIA_API_KEY' \
  --header 'x-algolia-application-id: ALGOLIA_APPLICATION_ID' \
  --data '
[
  {
    "objectID": "lorem",
    "conditions": [
      {
        "pattern": "{facet:genre}",
        "anchoring": "is",
        "alternatives": false,
        "context": "mobile",
        "filters": "genre:comedy"
      }
    ],
    "consequence": {
      "params": {
        "similarQuery": "comedy drama crime Macy Buscemi",
        "filters": "(category:Book OR category:Ebook) AND _tags:published",
        "facetFilters": [
          [
            "category:Book",
            "category:-Movie"
          ],
          "author:John Doe"
        ],
        "optionalFilters": [
          "category:Book",
          "author:John Doe"
        ],
        "numericFilters": [
          [
            "inStock = 1",
            "deliveryDate < 1441755506"
          ],
          "price < 1000"
        ],
        "tagFilters": [
          [
            "Book",
            "Movie"
          ],
          "SciFi"
        ],
        "sumOrFiltersScores": false,
        "restrictSearchableAttributes": [
          "title",
          "author"
        ],
        "facets": [
          "*"
        ],
        "facetingAfterDistinct": false,
        "page": 0,
        "offset": 42,
        "length": 0,
        "aroundLatLng": "40.71,-74.01",
        "aroundLatLngViaIP": false,
        "aroundRadius": 1,
        "aroundPrecision": 10,
        "minimumAroundRadius": 1,
        "insideBoundingBox": "lorem",
        "insidePolygon": [
          [
            47.3165,
            4.9665,
            47.3424,
            5.0201,
            47.32,
            4.9
          ],
          [
            40.9234,
            2.1185,
            38.643,
            1.9916,
            39.2587,
            2.0104
          ]
        ],
        "naturalLanguages": [],
        "ruleContexts": [
          "mobile"
        ],
        "personalizationImpact": 100,
        "userToken": "test-user-123",
        "getRankingInfo": false,
        "synonyms": true,
        "clickAnalytics": false,
        "analytics": true,
        "analyticsTags": [],
        "percentileComputation": true,
        "enableABTest": true,
        "attributesToRetrieve": [
          "author",
          "title",
          "content"
        ],
        "ranking": [
          "typo",
          "geo",
          "words",
          "filters",
          "proximity",
          "attribute",
          "exact",
          "custom"
        ],
        "relevancyStrictness": 90,
        "attributesToHighlight": [
          "author",
          "title",
          "conten",
          "content"
        ],
        "attributesToSnippet": [
          "content:80",
          "description"
        ],
        "highlightPreTag": "<em>",
        "highlightPostTag": "</em>",
        "snippetEllipsisText": "…",
        "restrictHighlightAndSnippetArrays": false,
        "hitsPerPage": 20,
        "minWordSizefor1Typo": 4,
        "minWordSizefor2Typos": 8,
        "typoTolerance": true,
        "allowTyposOnNumericTokens": true,
        "disableTypoToleranceOnAttributes": [
          "sku"
        ],
        "ignorePlurals": [
          "ca",
          "es"
        ],
        "removeStopWords": [
          "ca",
          "es"
        ],
        "queryLanguages": [
          "es"
        ],
        "decompoundQuery": true,
        "enableRules": true,
        "enablePersonalization": false,
        "queryType": "prefixLast",
        "removeWordsIfNoResults": "firstWords",
        "mode": "keywordSearch",
        "semanticSearch": {
          "eventSources": [
            "lorem"
          ]
        },
        "advancedSyntax": false,
        "optionalWords": "lorem",
        "disableExactOnAttributes": [
          "description"
        ],
        "exactOnSingleWordQuery": "attribute",
        "alternativesAsExact": [
          "ignorePlurals",
          "singleWordSynonym"
        ],
        "advancedSyntaxFeatures": [
          "exactPhrase",
          "excludeWords"
        ],
        "distinct": 1,
        "replaceSynonymsInHighlight": false,
        "minProximity": 1,
        "responseFields": [
          "*"
        ],
        "maxValuesPerFacet": 100,
        "sortFacetValuesBy": "count",
        "attributeCriteriaComputedByMinProximity": false,
        "attributeCriteriaComputedBy": "best",
        "renderingContent": {
          "facetOrdering": {
            "facets": {
              "order": [
                "lorem"
              ]
            },
            "values": {
              "property1": {
                "order": [
                  "lorem"
                ],
                "sortRemainingBy": "count",
                "hide": [
                  "lorem"
                ]
              },
              "property2": {
                "order": [
                  "lorem"
                ],
                "sortRemainingBy": "count",
                "hide": [
                  "lorem"
                ]
              }
            }
          },
          "redirect": {
            "url": "lorem"
          },
          "widgets": {
            "banners": [
              {
                "image": {
                  "urls": [
                    {
                      "url": "lorem"
                    }
                  ],
                  "title": "lorem"
                },
                "link": {
                  "url": "lorem"
                }
              }
            ],
            "resultCard": {
              "enabled": true
            }
          }
        },
        "enableReRanking": true,
        "reRankingApplyFilter": [
          []
        ],
        "query": {
          "remove": [
            "lorem"
          ],
          "edits": [
            {
              "type": "remove",
              "delete": "lorem",
              "insert": "lorem"
            }
          ]
        },
        "automaticFacetFilters": [
          {
            "facet": "lorem",
            "score": 1,
            "disjunctive": false
          }
        ],
        "automaticOptionalFacetFilters": [
          {
            "facet": "lorem",
            "score": 1,
            "disjunctive": false
          }
        ]
      },
      "promote": [
        {
          "objectIDs": [
            "test-record-123"
          ],
          "position": 0
        }
      ],
      "filterPromotes": false,
      "hide": [
        {
          "objectID": "test-record-123"
        }
      ],
      "redirect": {
        "indexName": "lorem"
      },
      "userData": {
        "settingID": "f2a7b51e3503acc6a39b3784ffb84300",
        "pluginVersion": "1.6.0"
      }
    },
    "description": "Display a promotional banner",
    "enabled": true,
    "validity": [
      {
        "from": 42,
        "until": 42
      }
    ],
    "tags": [
      "lorem"
    ],
    "scope": "lorem",
    "condition": {
      "pattern": "{facet:genre}",
      "anchoring": "is",
      "alternatives": false,
      "context": "mobile",
      "filters": "genre:comedy"
    }
  }
]
'

// Initialize the client
var client = new SearchClient(new SearchConfig("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY"));

// Call the API
var response = await client.SaveRulesAsync(
  "<YOUR_INDEX_NAME>",
  new List<Rule>
  {
    new Rule
    {
      ObjectID = "a-rule-id",
      Conditions = new List<Condition>
      {
        new Condition { Pattern = "smartphone", Anchoring = Enum.Parse<Anchoring>("Contains") },
      },
      Consequence = new Consequence
      {
        Params = new ConsequenceParams { Filters = "brand:apple" },
      },
    },
    new Rule
    {
      ObjectID = "a-second-rule-id",
      Conditions = new List<Condition>
      {
        new Condition { Pattern = "apple", Anchoring = Enum.Parse<Anchoring>("Contains") },
      },
      Consequence = new Consequence
      {
        Params = new ConsequenceParams { Filters = "brand:samsung" },
      },
    },
  },
  false,
  true
);

// print the response
Console.WriteLine(response);

// Initialize the client
final client =
    SearchClient(appId: 'ALGOLIA_APPLICATION_ID', apiKey: 'ALGOLIA_API_KEY');

// Call the API
final response = await client.saveRules(
  indexName: "<YOUR_INDEX_NAME>",
  rules: [
    Rule(
      objectID: "a-rule-id",
      conditions: [
        Condition(
          pattern: "smartphone",
          anchoring: Anchoring.fromJson("contains"),
        ),
      ],
      consequence: Consequence(
        params: ConsequenceParams(
          filters: "brand:apple",
        ),
      ),
    ),
    Rule(
      objectID: "a-second-rule-id",
      conditions: [
        Condition(
          pattern: "apple",
          anchoring: Anchoring.fromJson("contains"),
        ),
      ],
      consequence: Consequence(
        params: ConsequenceParams(
          filters: "brand:samsung",
        ),
      ),
    ),
  ],
  forwardToReplicas: false,
  clearExistingRules: true,
);

// print the response
print(response);

// Initialize the client
client, err := search.NewClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")
if err != nil {
  // The client can fail to initialize if you pass an invalid parameter.
  panic(err)
}

// Call the API
response, err := client.SaveRules(client.NewApiSaveRulesRequest(
  "<YOUR_INDEX_NAME>",
  []search.Rule{*search.NewEmptyRule().SetObjectID("a-rule-id").SetConditions(
    []search.Condition{*search.NewEmptyCondition().SetPattern("smartphone").SetAnchoring(search.Anchoring("contains"))}).SetConsequence(
    search.NewEmptyConsequence().SetParams(
      search.NewEmptyConsequenceParams().SetFilters("brand:apple"))), *search.NewEmptyRule().SetObjectID("a-second-rule-id").SetConditions(
    []search.Condition{*search.NewEmptyCondition().SetPattern("apple").SetAnchoring(search.Anchoring("contains"))}).SetConsequence(
    search.NewEmptyConsequence().SetParams(
      search.NewEmptyConsequenceParams().SetFilters("brand:samsung")))}).WithForwardToReplicas(false).WithClearExistingRules(true))
if err != nil {
  // handle the eventual error
  panic(err)
}


// print the response
print(response)

// Initialize the client
SearchClient client = new SearchClient("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY");

// Call the API
UpdatedAtResponse response = client.saveRules(
  "<YOUR_INDEX_NAME>",
  Arrays.asList(
    new Rule()
      .setObjectID("a-rule-id")
      .setConditions(Arrays.asList(new Condition().setPattern("smartphone").setAnchoring(Anchoring.CONTAINS)))
      .setConsequence(new Consequence().setParams(new ConsequenceParams().setFilters("brand:apple"))),
    new Rule()
      .setObjectID("a-second-rule-id")
      .setConditions(Arrays.asList(new Condition().setPattern("apple").setAnchoring(Anchoring.CONTAINS)))
      .setConsequence(new Consequence().setParams(new ConsequenceParams().setFilters("brand:samsung")))
  ),
  false,
  true
);

// print the response
System.out.println(response);

// Initialize the client
const client = algoliasearch('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY');

// Call the API
const response = await client.saveRules({
  indexName: '<YOUR_INDEX_NAME>',
  rules: [
    {
      objectID: 'a-rule-id',
      conditions: [{ pattern: 'smartphone', anchoring: 'contains' }],
      consequence: { params: { filters: 'brand:apple' } },
    },
    {
      objectID: 'a-second-rule-id',
      conditions: [{ pattern: 'apple', anchoring: 'contains' }],
      consequence: { params: { filters: 'brand:samsung' } },
    },
  ],
  forwardToReplicas: false,
  clearExistingRules: true,
});


// print the response
console.log(response);

// Initialize the client
val client = SearchClient(appId = "ALGOLIA_APPLICATION_ID", apiKey = "ALGOLIA_API_KEY")

// Call the API
var response =
  client.saveRules(
    indexName = "<YOUR_INDEX_NAME>",
    rules =
      listOf(
        Rule(
          objectID = "a-rule-id",
          conditions =
            listOf(
              Condition(
                pattern = "smartphone",
                anchoring = Anchoring.entries.first { it.value == "contains" },
              )
            ),
          consequence = Consequence(params = ConsequenceParams(filters = "brand:apple")),
        ),
        Rule(
          objectID = "a-second-rule-id",
          conditions =
            listOf(
              Condition(
                pattern = "apple",
                anchoring = Anchoring.entries.first { it.value == "contains" },
              )
            ),
          consequence = Consequence(params = ConsequenceParams(filters = "brand:samsung")),
        ),
      ),
    forwardToReplicas = false,
    clearExistingRules = true,
  )


// print the response
println(response)

// Initialize the client
$client = SearchClient::create('ALGOLIA_APPLICATION_ID', 'ALGOLIA_API_KEY');

// Call the API
$response = $client->saveRules(
    '<YOUR_INDEX_NAME>',
    [
        ['objectID' => 'a-rule-id',
            'conditions' => [
                ['pattern' => 'smartphone',
                    'anchoring' => 'contains',
                ],
            ],
            'consequence' => ['params' => ['filters' => 'brand:apple',
            ],
            ],
        ],

        ['objectID' => 'a-second-rule-id',
            'conditions' => [
                ['pattern' => 'apple',
                    'anchoring' => 'contains',
                ],
            ],
            'consequence' => ['params' => ['filters' => 'brand:samsung',
            ],
            ],
        ],
    ],
    false,
    true,
);


// print the response
var_dump($response);

# Initialize the client
# In an asynchronous context, you can use SearchClient instead, which exposes the exact same methods.
client = SearchClientSync("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")

# Call the API
response = client.save_rules(
    index_name="<YOUR_INDEX_NAME>",
    rules=[
        {
            "objectID": "a-rule-id",
            "conditions": [
                {
                    "pattern": "smartphone",
                    "anchoring": "contains",
                },
            ],
            "consequence": {
                "params": {
                    "filters": "brand:apple",
                },
            },
        },
        {
            "objectID": "a-second-rule-id",
            "conditions": [
                {
                    "pattern": "apple",
                    "anchoring": "contains",
                },
            ],
            "consequence": {
                "params": {
                    "filters": "brand:samsung",
                },
            },
        },
    ],
    forward_to_replicas=False,
    clear_existing_rules=True,
)


# print the response
print(response)

# Initialize the client
client = Algolia::SearchClient.create("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")

# Call the API
response = client.save_rules(
  "<YOUR_INDEX_NAME>",
  [
    Algolia::Search::Rule.new(
      algolia_object_id: "a-rule-id",
      conditions: [Algolia::Search::Condition.new(pattern: "smartphone", anchoring: "contains")],
      consequence: Algolia::Search::Consequence.new(
        params: Algolia::Search::ConsequenceParams.new(filters: "brand:apple")
      )
    ),
    Algolia::Search::Rule.new(
      algolia_object_id: "a-second-rule-id",
      conditions: [Algolia::Search::Condition.new(pattern: "apple", anchoring: "contains")],
      consequence: Algolia::Search::Consequence.new(
        params: Algolia::Search::ConsequenceParams.new(filters: "brand:samsung")
      )
    )
  ],
  false,
  true
)


# print the response
puts(response)

// Initialize the client
val client = SearchClient(appId = "ALGOLIA_APPLICATION_ID", apiKey = "ALGOLIA_API_KEY")

// Call the API
val response = Await.result(
  client.saveRules(
    indexName = "<YOUR_INDEX_NAME>",
    rules = Seq(
      Rule(
        objectID = "a-rule-id",
        conditions = Some(
          Seq(
            Condition(
              pattern = Some("smartphone"),
              anchoring = Some(Anchoring.withName("contains"))
            )
          )
        ),
        consequence = Consequence(
          params = Some(
            ConsequenceParams(
              filters = Some("brand:apple")
            )
          )
        )
      ),
      Rule(
        objectID = "a-second-rule-id",
        conditions = Some(
          Seq(
            Condition(
              pattern = Some("apple"),
              anchoring = Some(Anchoring.withName("contains"))
            )
          )
        ),
        consequence = Consequence(
          params = Some(
            ConsequenceParams(
              filters = Some("brand:samsung")
            )
          )
        )
      )
    ),
    forwardToReplicas = Some(false),
    clearExistingRules = Some(true)
  ),
  Duration(100, "sec")
)

// print the response
println(response)

// Initialize the client
let client = try SearchClient(appID: "ALGOLIA_APPLICATION_ID", apiKey: "ALGOLIA_API_KEY")

// Call the API
let response = try await client.saveRules(
    indexName: "<YOUR_INDEX_NAME>",
    rules: [
        Rule(objectID: "a-rule-id", conditions: [SearchCondition(
            pattern: "smartphone",
            anchoring: SearchAnchoring.contains
        )], consequence: SearchConsequence(params: SearchConsequenceParams(filters: "brand:apple"))),
        Rule(
            objectID: "a-second-rule-id",
            conditions: [SearchCondition(pattern: "apple", anchoring: SearchAnchoring.contains)],
            consequence: SearchConsequence(params: SearchConsequenceParams(filters: "brand:samsung"))
        ),
    ],
    forwardToReplicas: false,
    clearExistingRules: true
)

// print the response
print(response)

{
  "taskID": 1514562690001,
  "updatedAt": "2023-07-04T12:49:15Z"
}

{
  "message": "Invalid Application-Id or API-Key"
}

{
  "message": "Invalid Application-Id or API-Key"
}

{
  "message": "Invalid Application-Id or API-Key"
}

{
  "message": "Invalid Application-Id or API-Key"
}