curl --request PUT \
  --url https://algolia_application_id.algolia.net/1/compositions/my_composition_object_id/rules/lorem \
  --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": "my_composition_rule_object_id",
  "conditions": [
    {
      "pattern": "{facet:genre}",
      "anchoring": "is",
      "context": "mobile",
      "filters": "genre:comedy",
      "sortBy": "price-low-to-high"
    }
  ],
  "consequence": {
    "behavior": {
      "injection": {
        "main": {
          "source": {
            "search": {
              "index": "Products",
              "params": {
                "advancedSyntax": false,
                "advancedSyntaxFeatures": [
                  "exactPhrase",
                  "excludeWords"
                ],
                "allowTyposOnNumericTokens": true,
                "alternativesAsExact": [
                  "ignorePlurals",
                  "singleWordSynonym"
                ],
                "attributeCriteriaComputedByMinProximity": false,
                "attributesToHighlight": [
                  "author",
                  "title",
                  "conten",
                  "content"
                ],
                "attributesToRetrieve": [
                  "author",
                  "title",
                  "content"
                ],
                "attributesToSnippet": [
                  "content:80",
                  "description"
                ],
                "clickAnalytics": false,
                "disableExactOnAttributes": [
                  "description"
                ],
                "disableTypoToleranceOnAttributes": [
                  "sku"
                ],
                "distinct": 1,
                "enableABTest": true,
                "enablePersonalization": false,
                "enableReRanking": true,
                "enableRules": true,
                "exactOnSingleWordQuery": "attribute",
                "facetFilters": [
                  [
                    "category:Book",
                    "category:-Movie"
                  ],
                  "author:John Doe"
                ],
                "filters": "(category:Book OR category:Ebook) AND _tags:published",
                "getRankingInfo": false,
                "highlightPostTag": "</em>",
                "highlightPreTag": "<em>",
                "ignorePlurals": [
                  "ca",
                  "es"
                ],
                "minProximity": 1,
                "minWordSizefor1Typo": 4,
                "minWordSizefor2Typos": 8,
                "naturalLanguages": [],
                "numericFilters": [
                  [
                    "inStock = 1",
                    "deliveryDate < 1441755506"
                  ],
                  "price < 1000"
                ],
                "optionalFilters": [
                  "category:Book",
                  "author:John Doe"
                ],
                "optionalWords": "lorem",
                "percentileComputation": true,
                "personalizationImpact": 100,
                "queryLanguages": [
                  "es"
                ],
                "queryType": "prefixLast",
                "removeStopWords": [
                  "ca",
                  "es"
                ],
                "removeWordsIfNoResults": "firstWords",
                "replaceSynonymsInHighlight": false,
                "responseFields": [
                  "*"
                ],
                "restrictHighlightAndSnippetArrays": false,
                "restrictSearchableAttributes": [
                  "title",
                  "author"
                ],
                "ruleContexts": [
                  "mobile"
                ],
                "snippetEllipsisText": "…",
                "synonyms": true,
                "typoTolerance": true,
                "facetingAfterDistinct": false,
                "facets": [
                  "category",
                  "disjunctive(brand)",
                  "price"
                ],
                "hitsPerPage": 20,
                "maxValuesPerFacet": 100,
                "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
                    }
                  }
                },
                "sortFacetValuesBy": "count",
                "sumOrFiltersScores": false
              }
            }
          }
        },
        "injectedItems": [
          {
            "key": "lorem",
            "source": {
              "search": {
                "index": "Products",
                "params": {
                  "advancedSyntax": false,
                  "advancedSyntaxFeatures": [
                    "exactPhrase",
                    "excludeWords"
                  ],
                  "allowTyposOnNumericTokens": true,
                  "alternativesAsExact": [
                    "ignorePlurals",
                    "singleWordSynonym"
                  ],
                  "attributeCriteriaComputedByMinProximity": false,
                  "attributesToHighlight": [
                    "author",
                    "title",
                    "conten",
                    "content"
                  ],
                  "attributesToRetrieve": [
                    "author",
                    "title",
                    "content"
                  ],
                  "attributesToSnippet": [
                    "content:80",
                    "description"
                  ],
                  "clickAnalytics": false,
                  "disableExactOnAttributes": [
                    "description"
                  ],
                  "disableTypoToleranceOnAttributes": [
                    "sku"
                  ],
                  "distinct": 1,
                  "enableABTest": true,
                  "enablePersonalization": false,
                  "enableReRanking": true,
                  "enableRules": true,
                  "exactOnSingleWordQuery": "attribute",
                  "facetFilters": [
                    [
                      "category:Book",
                      "category:-Movie"
                    ],
                    "author:John Doe"
                  ],
                  "filters": "(category:Book OR category:Ebook) AND _tags:published",
                  "getRankingInfo": false,
                  "highlightPostTag": "</em>",
                  "highlightPreTag": "<em>",
                  "ignorePlurals": [
                    "ca",
                    "es"
                  ],
                  "minProximity": 1,
                  "minWordSizefor1Typo": 4,
                  "minWordSizefor2Typos": 8,
                  "naturalLanguages": [],
                  "numericFilters": [
                    [
                      "inStock = 1",
                      "deliveryDate < 1441755506"
                    ],
                    "price < 1000"
                  ],
                  "optionalFilters": [
                    "category:Book",
                    "author:John Doe"
                  ],
                  "optionalWords": "lorem",
                  "percentileComputation": true,
                  "personalizationImpact": 100,
                  "queryLanguages": [
                    "es"
                  ],
                  "queryType": "prefixLast",
                  "removeStopWords": [
                    "ca",
                    "es"
                  ],
                  "removeWordsIfNoResults": "firstWords",
                  "replaceSynonymsInHighlight": false,
                  "responseFields": [
                    "*"
                  ],
                  "restrictHighlightAndSnippetArrays": false,
                  "restrictSearchableAttributes": [
                    "title",
                    "author"
                  ],
                  "ruleContexts": [
                    "mobile"
                  ],
                  "snippetEllipsisText": "…",
                  "synonyms": true,
                  "typoTolerance": true
                }
              }
            },
            "position": 0,
            "length": 0,
            "metadata": {
              "hits": {
                "addItemKey": true,
                "extra": {}
              }
            }
          }
        ],
        "deduplication": {
          "positioning": "highest"
        }
      }
    }
  },
  "description": "Display a promotional banner",
  "enabled": true,
  "validity": [
    {
      "from": 42,
      "until": 42
    }
  ],
  "tags": [
    "conditional"
  ]
}
'

// Initialize the client
var client = new CompositionClient(
  new CompositionConfig("ALGOLIA_APPLICATION_ID", "ALGOLIA_API_KEY")
);

// Call the API
var response = await client.PutCompositionRuleAsync(
  "compositionID",
  "rule-with-external-provider-source",
  new CompositionRule
  {
    ObjectID = "rule-with-external-provider-source",
    Conditions = new List<Condition>
    {
      new Condition { Anchoring = Enum.Parse<Anchoring>("Contains"), Pattern = "harry" },
    },
    Consequence = new CompositionRuleConsequence
    {
      Behavior = new CompositionBehavior(
        new CompositionInjectionBehavior
        {
          Injection = new Injection
          {
            Main = new InjectionMain
            {
              Source = new InjectionMainSource(
                new InjectionMainSearchSource
                {
                  Search = new InjectionMainSearch { Index = "my-index" },
                }
              ),
            },
            InjectedItems = new List<InjectionInjectedItem>
            {
              new InjectionInjectedItem
              {
                Key = "my-unique-external-provider-group-from-rule-key",
                Source = new InjectedItemSource(
                  new InjectedItemExternalProviderSource
                  {
                    ExternalProvider = new InjectedItemExternalProvider
                    {
                      Index = "my-index",
                      ConfigurationID = "my-rmn-connection",
                      ConfigurationParams = new Dictionary<string, object>
                      {
                        { "campaign_id", "summer-sale" },
                      },
                      Ordering = Enum.Parse<ExternalProviderOrdering>("ProviderDefined"),
                    },
                  }
                ),
                Position = 0,
                Length = 3,
              },
            },
          },
        }
      ),
    },
  }
);

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

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

// Call the API
final response = await client.putCompositionRule(
  compositionID: "compositionID",
  objectID: "rule-with-external-provider-source",
  compositionRule: CompositionRule(
    objectID: "rule-with-external-provider-source",
    conditions: [
      Condition(
        anchoring: Anchoring.fromJson("contains"),
        pattern: "harry",
      ),
    ],
    consequence: CompositionRuleConsequence(
      behavior: CompositionInjectionBehavior(
        injection: Injection(
          main: InjectionMain(
            source: InjectionMainSearchSource(
              search: InjectionMainSearch(
                index: "my-index",
              ),
            ),
          ),
          injectedItems: [
            InjectionInjectedItem(
              key: "my-unique-external-provider-group-from-rule-key",
              source: InjectedItemExternalProviderSource(
                externalProvider: InjectedItemExternalProvider(
                  index: "my-index",
                  configurationID: "my-rmn-connection",
                  configurationParams: {
                    'campaign_id': "summer-sale",
                  },
                  ordering:
                      ExternalProviderOrdering.fromJson("providerDefined"),
                ),
              ),
              position: 0,
              length: 3,
            ),
          ],
        ),
      ),
    ),
  ),
);

// print the response
print(response);

// Initialize the client
client, err := composition.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.PutCompositionRule(client.NewApiPutCompositionRuleRequest(
  "compositionID", "rule-with-external-provider-source",
  composition.NewEmptyCompositionRule().SetObjectID("rule-with-external-provider-source").SetConditions(
    []composition.Condition{
      *composition.NewEmptyCondition().SetAnchoring(composition.Anchoring("contains")).SetPattern("harry"),
    }).
    SetConsequence(
      composition.NewEmptyCompositionRuleConsequence().SetBehavior(composition.CompositionInjectionBehaviorAsCompositionBehavior(
        composition.NewEmptyCompositionInjectionBehavior().SetInjection(
          composition.NewEmptyInjection().SetMain(
            composition.NewEmptyInjectionMain().SetSource(composition.InjectionMainSearchSourceAsInjectionMainSource(
              composition.NewEmptyInjectionMainSearchSource().SetSearch(
                composition.NewEmptyInjectionMainSearch().SetIndex("my-index"))))).SetInjectedItems(
            []composition.InjectionInjectedItem{
              *composition.NewEmptyInjectionInjectedItem().SetKey("my-unique-external-provider-group-from-rule-key").SetSource(composition.InjectedItemExternalProviderSourceAsInjectedItemSource(
                composition.NewEmptyInjectedItemExternalProviderSource().SetExternalProvider(
                  composition.NewEmptyInjectedItemExternalProvider().SetIndex("my-index").SetConfigurationID("my-rmn-connection").SetConfigurationParams(map[string]any{"campaign_id": "summer-sale"}).SetOrdering(composition.ExternalProviderOrdering("providerDefined"))))).SetPosition(0).SetLength(3),
            }),
        ))))))
if err != nil {
  // handle the eventual error
  panic(err)
}


// print the response
print(response)

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

// Call the API
TaskIDResponse response = client.putCompositionRule(
  "compositionID",
  "rule-with-external-provider-source",
  new CompositionRule()
    .setObjectID("rule-with-external-provider-source")
    .setConditions(Arrays.asList(new Condition().setAnchoring(Anchoring.CONTAINS).setPattern("harry")))
    .setConsequence(
      new CompositionRuleConsequence().setBehavior(
        new CompositionInjectionBehavior().setInjection(
          new Injection()
            .setMain(
              new InjectionMain().setSource(new InjectionMainSearchSource().setSearch(new InjectionMainSearch().setIndex("my-index")))
            )
            .setInjectedItems(
              Arrays.asList(
                new InjectionInjectedItem()
                  .setKey("my-unique-external-provider-group-from-rule-key")
                  .setSource(
                    new InjectedItemExternalProviderSource().setExternalProvider(
                      new InjectedItemExternalProvider()
                        .setIndex("my-index")
                        .setConfigurationID("my-rmn-connection")
                        .setConfigurationParams(
                          new HashMap() {
                            {
                              put("campaign_id", "summer-sale");
                            }
                          }
                        )
                        .setOrdering(ExternalProviderOrdering.PROVIDER_DEFINED)
                    )
                  )
                  .setPosition(0)
                  .setLength(3)
              )
            )
        )
      )
    )
);

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

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

// Call the API
const response = await client.putCompositionRule({
  compositionID: 'compositionID',
  objectID: 'rule-with-external-provider-source',
  compositionRule: {
    objectID: 'rule-with-external-provider-source',
    conditions: [{ anchoring: 'contains', pattern: 'harry' }],
    consequence: {
      behavior: {
        injection: {
          main: { source: { search: { index: 'my-index' } } },
          injectedItems: [
            {
              key: 'my-unique-external-provider-group-from-rule-key',
              source: {
                externalProvider: {
                  index: 'my-index',
                  configurationID: 'my-rmn-connection',
                  configurationParams: { campaign_id: 'summer-sale' },
                  ordering: 'providerDefined',
                },
              },
              position: 0,
              length: 3,
            },
          ],
        },
      },
    },
  },
});


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

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

// Call the API
var response =
  client.putCompositionRule(
    compositionID = "compositionID",
    objectID = "rule-with-external-provider-source",
    compositionRule =
      CompositionRule(
        objectID = "rule-with-external-provider-source",
        conditions =
          listOf(
            Condition(
              anchoring = Anchoring.entries.first { it.value == "contains" },
              pattern = "harry",
            )
          ),
        consequence =
          CompositionRuleConsequence(
            behavior =
              CompositionInjectionBehavior(
                injection =
                  Injection(
                    main =
                      InjectionMain(
                        source =
                          InjectionMainSearchSource(
                            search = InjectionMainSearch(index = "my-index")
                          )
                      ),
                    injectedItems =
                      listOf(
                        InjectionInjectedItem(
                          key = "my-unique-external-provider-group-from-rule-key",
                          source =
                            InjectedItemExternalProviderSource(
                              externalProvider =
                                InjectedItemExternalProvider(
                                  index = "my-index",
                                  configurationID = "my-rmn-connection",
                                  configurationParams =
                                    buildJsonObject {
                                      put("campaign_id", JsonPrimitive("summer-sale"))
                                    },
                                  ordering =
                                    ExternalProviderOrdering.entries.first {
                                      it.value == "providerDefined"
                                    },
                                )
                            ),
                          position = 0,
                          length = 3,
                        )
                      ),
                  )
              )
          ),
      ),
  )


// print the response
println(response)

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

// Call the API
$response = $client->putCompositionRule(
    'compositionID',
    'rule-with-external-provider-source',
    ['objectID' => 'rule-with-external-provider-source',
        'conditions' => [
            ['anchoring' => 'contains',
                'pattern' => 'harry',
            ],
        ],
        'consequence' => ['behavior' => ['injection' => ['main' => ['source' => ['search' => ['index' => 'my-index',
        ],
        ],
        ],
            'injectedItems' => [
                ['key' => 'my-unique-external-provider-group-from-rule-key',
                    'source' => ['externalProvider' => ['index' => 'my-index',
                        'configurationID' => 'my-rmn-connection',
                        'configurationParams' => ['campaign_id' => 'summer-sale',
                        ],
                        'ordering' => 'providerDefined',
                    ],
                    ],
                    'position' => 0,
                    'length' => 3,
                ],
            ],
        ],
        ],
        ],
    ],
);


// print the response
var_dump($response);

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

# Call the API
response = client.put_composition_rule(
    composition_id="compositionID",
    object_id="rule-with-external-provider-source",
    composition_rule={
        "objectID": "rule-with-external-provider-source",
        "conditions": [
            {
                "anchoring": "contains",
                "pattern": "harry",
            },
        ],
        "consequence": {
            "behavior": {
                "injection": {
                    "main": {
                        "source": {
                            "search": {
                                "index": "my-index",
                            },
                        },
                    },
                    "injectedItems": [
                        {
                            "key": "my-unique-external-provider-group-from-rule-key",
                            "source": {
                                "externalProvider": {
                                    "index": "my-index",
                                    "configurationID": "my-rmn-connection",
                                    "configurationParams": {
                                        "campaign_id": "summer-sale",
                                    },
                                    "ordering": "providerDefined",
                                },
                            },
                            "position": 0,
                            "length": 3,
                        },
                    ],
                },
            },
        },
    },
)


# print the response
print(response)

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

# Call the API
response = client.put_composition_rule(
  "compositionID",
  "rule-with-external-provider-source",
  Algolia::Composition::CompositionRule.new(
    algolia_object_id: "rule-with-external-provider-source",
    conditions: [Algolia::Composition::Condition.new(anchoring: "contains", pattern: "harry")],
    consequence: Algolia::Composition::CompositionRuleConsequence.new(
      behavior: Algolia::Composition::CompositionInjectionBehavior.new(
        injection: Algolia::Composition::Injection.new(
          main: Algolia::Composition::InjectionMain.new(
            source: Algolia::Composition::InjectionMainSearchSource.new(
              search: Algolia::Composition::InjectionMainSearch.new(index: "my-index")
            )
          ),
          injected_items: [
            Algolia::Composition::InjectionInjectedItem.new(
              key: "my-unique-external-provider-group-from-rule-key",
              source: Algolia::Composition::InjectedItemExternalProviderSource.new(
                external_provider: Algolia::Composition::InjectedItemExternalProvider.new(
                  index: "my-index",
                  configuration_id: "my-rmn-connection",
                  configuration_params: {campaign_id: "summer-sale"},
                  ordering: "providerDefined"
                )
              ),
              position: 0,
              length: 3
            )
          ]
        )
      )
    )
  )
)


# print the response
puts(response)

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

// Call the API
val response = Await.result(
  client.putCompositionRule(
    compositionID = "compositionID",
    objectID = "rule-with-external-provider-source",
    compositionRule = CompositionRule(
      objectID = "rule-with-external-provider-source",
      conditions = Some(
        Seq(
          Condition(
            anchoring = Some(Anchoring.withName("contains")),
            pattern = Some("harry")
          )
        )
      ),
      consequence = CompositionRuleConsequence(
        behavior = CompositionInjectionBehavior(
          injection = Injection(
            main = InjectionMain(
              source = Some(
                InjectionMainSearchSource(
                  search = InjectionMainSearch(
                    index = "my-index"
                  )
                )
              )
            ),
            injectedItems = Some(
              Seq(
                InjectionInjectedItem(
                  key = "my-unique-external-provider-group-from-rule-key",
                  source = InjectedItemExternalProviderSource(
                    externalProvider = InjectedItemExternalProvider(
                      index = "my-index",
                      configurationID = "my-rmn-connection",
                      configurationParams = Some(Map("campaign_id" -> "summer-sale")),
                      ordering = Some(ExternalProviderOrdering.withName("providerDefined"))
                    )
                  ),
                  position = 0,
                  length = 3
                )
              )
            )
          )
        )
      )
    )
  ),
  Duration(100, "sec")
)

// print the response
println(response)

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

// Call the API
let response = try await client.putCompositionRule(
    compositionID: "compositionID",
    objectID: "rule-with-external-provider-source",
    compositionRule: CompositionRule(
        objectID: "rule-with-external-provider-source",
        conditions: [CompositionCondition(pattern: "harry", anchoring: CompositionAnchoring.contains)],
        consequence: CompositionRuleConsequence(behavior: CompositionBehavior
            .compositionInjectionBehavior(CompositionInjectionBehavior(injection: Injection(
                main: InjectionMain(source: InjectionMainSource
                    .injectionMainSearchSource(
                        InjectionMainSearchSource(search: InjectionMainSearch(index: "my-index"))
                    )),
                injectedItems: [InjectionInjectedItem(
                    key: "my-unique-external-provider-group-from-rule-key",
                    source: InjectedItemSource
                        .injectedItemExternalProviderSource(
                            InjectedItemExternalProviderSource(externalProvider: InjectedItemExternalProvider(
                                index: "my-index",
                                configurationID: "my-rmn-connection",
                                configurationParams: ["campaign_id": AnyCodable("summer-sale")],
                                ordering: ExternalProviderOrdering.providerDefined
                            ))
                        ),
                    position: 0,
                    length: 3
                )]
            ))))
    )
)

// print the response
print(response)

{
  "taskID": 1514562690001
}

{
  "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"
}

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