@algolia/composition 1.13.0 → 1.15.0

package/dist/browser.d.ts

@@ -1,6 +1,513 @@
 import * as _algolia_client_common from '@algolia/client-common';
 import { CreateClientOptions, RequestOptions, ClientOptions } from '@algolia/client-common';
 
+/**
+ * Type of Composition Batch operation.
+ */
+type Action = 'upsert' | 'delete';
+
+/**
+ * Adds the provided metadata to each injected hit via an `_extra` attribute.
+ */
+type InjectedItemHitsMetadata = {
+    /**
+     * When true, the `_injectedItemKey` field is set in the `_extra` object of each affected hit.
+     */
+    addItemKey?: boolean | undefined;
+    /**
+     * The user-defined key-value pairs that will be placed in the `_extra` field of each affected hit.
+     */
+    extra?: {
+        [key: string]: any;
+    } | undefined;
+};
+
+/**
+ * Used to add metadata to the results of the injectedItem.
+ */
+type InjectedItemMetadata = {
+    hits?: InjectedItemHitsMetadata | undefined;
+};
+
+type AdvancedSyntaxFeatures = 'exactPhrase' | 'excludeWords';
+
+type AlternativesAsExact = 'ignorePlurals' | 'singleWordSynonym' | 'multiWordsSynonym' | 'ignoreConjugations';
+
+/**
+ * Determines how many records of a group are included in the search results.  Records with the same value for the `attributeForDistinct` attribute are considered a group. The `distinct` setting controls how many members of the group are returned. This is useful for [deduplication and grouping](https://www.algolia.com/doc/guides/managing-results/refine-results/grouping/#introducing-algolias-distinct-feature).  The `distinct` setting is ignored if `attributeForDistinct` is not set.
+ */
+type Distinct = boolean | number;
+
+/**
+ * Determines how the [Exact ranking criterion](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/override-search-engine-defaults/in-depth/adjust-exact-settings/#turn-off-exact-for-some-attributes) is computed when the search query has only one word.  - `attribute`.   The Exact ranking criterion is 1 if the query word and attribute value are the same.   For example, a search for \"road\" will match the value \"road\", but not \"road trip\".  - `none`.   The Exact ranking criterion is ignored on single-word searches.  - `word`.   The Exact ranking criterion is 1 if the query word is found in the attribute value.   The query word must have at least 3 characters and must not be a stop word.   Only exact matches will be highlighted,   partial and prefix matches won\'t.
+ */
+type ExactOnSingleWordQuery = 'attribute' | 'none' | 'word';
+
+/**
+ * Filter the search by facet values, so that only records with the same facet values are retrieved.  **Prefer using the `filters` parameter, which supports all filter types and combinations with boolean operators.**  - `[filter1, filter2]` is interpreted as `filter1 AND filter2`. - `[[filter1, filter2], filter3]` is interpreted as `filter1 OR filter2 AND filter3`. - `facet:-value` is interpreted as `NOT facet:value`.  While it\'s best to avoid attributes that start with a `-`, you can still filter them by escaping with a backslash: `facet:\\-value`.
+ */
+type FacetFilters = Array<FacetFilters> | string;
+
+type BooleanString = 'true' | 'false';
+
+/**
+ * ISO code for a supported language.
+ */
+type SupportedLanguage = 'af' | 'ar' | 'az' | 'bg' | 'bn' | 'ca' | 'cs' | 'cy' | 'da' | 'de' | 'el' | 'en' | 'eo' | 'es' | 'et' | 'eu' | 'fa' | 'fi' | 'fo' | 'fr' | 'ga' | 'gl' | 'he' | 'hi' | 'hu' | 'hy' | 'id' | 'is' | 'it' | 'ja' | 'ka' | 'kk' | 'ko' | 'ku' | 'ky' | 'lt' | 'lv' | 'mi' | 'mn' | 'mr' | 'ms' | 'mt' | 'nb' | 'nl' | 'no' | 'ns' | 'pl' | 'ps' | 'pt' | 'pt-br' | 'qu' | 'ro' | 'ru' | 'sk' | 'sq' | 'sv' | 'sw' | 'ta' | 'te' | 'th' | 'tl' | 'tn' | 'tr' | 'tt' | 'uk' | 'ur' | 'uz' | 'zh';
+
+/**
+ * Treat singular, plurals, and other forms of declensions as equivalent. You should only use this feature for the languages used in your index.
+ */
+type IgnorePlurals = Array<SupportedLanguage> | BooleanString | boolean;
+
+/**
+ * Filter by numeric facets.  **Prefer using the `filters` parameter, which supports all filter types and combinations with boolean operators.**  You can use numeric comparison operators: `<`, `<=`, `=`, `!=`, `>`, `>=`. Comparisons are precise up to 3 decimals. You can also provide ranges: `facet:<lower> TO <upper>`. The range includes the lower and upper boundaries. The same combination rules apply as for `facetFilters`.
+ */
+type NumericFilters = Array<NumericFilters> | string;
+
+/**
+ * Filters to promote or demote records in the search results.  Optional filters work like facet filters, but they don\'t exclude records from the search results. Records that match the optional filter rank before records that don\'t match. If you\'re using a negative filter `facet:-value`, matching records rank after records that don\'t match.  - Optional filters don\'t work on virtual replicas. - Optional filters are applied _after_ sort-by attributes. - Optional filters are applied _before_ custom ranking attributes (in the default [ranking](https://www.algolia.com/doc/guides/managing-results/relevance-overview/in-depth/ranking-criteria/)). - Optional filters don\'t work with numeric attributes.
+ */
+type OptionalFilters = Array<OptionalFilters> | string;
+
+/**
+ * Words that should be considered optional when found in the query.  By default, records must match all words in the search query to be included in the search results. Adding optional words can help to increase the number of search results by running an additional search query that doesn\'t include the optional words. For example, if the search query is \"action video\" and \"video\" is an optional word, the search engine runs two queries. One for \"action video\" and one for \"action\". Records that match all words are ranked higher.  For a search query with 4 or more words **and** all its words are optional, the number of matched words required for a record to be included in the search results increases for every 1,000 records:  - If `optionalWords` has less than 10 words, the required number of matched words increases by 1:   results 1 to 1,000 require 1 matched word, results 1,001 to 2000 need 2 matched words. - If `optionalWords` has 10 or more words, the number of required matched words increases by the number of optional words divided by 5 (rounded down).   For example, with 18 optional words: results 1 to 1,000 require 1 matched word, results 1,001 to 2000 need 4 matched words.  For more information, see [Optional words](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/empty-or-insufficient-results/#creating-a-list-of-optional-words).
+ */
+type OptionalWords = string | Array<string>;
+
+/**
+ * Determines if and how query words are interpreted as prefixes.  By default, only the last query word is treated as a prefix (`prefixLast`). To turn off prefix search, use `prefixNone`. Avoid `prefixAll`, which treats all query words as prefixes. This might lead to counterintuitive results and makes your search slower.  For more information, see [Prefix searching](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/override-search-engine-defaults/in-depth/prefix-searching/).
+ */
+type QueryType = 'prefixLast' | 'prefixAll' | 'prefixNone';
+
+/**
+ * Removes stop words from the search query.  Stop words are common words like articles, conjunctions, prepositions, or pronouns that have little or no meaning on their own. In English, \"the\", \"a\", or \"and\" are stop words.  You should only use this feature for the languages used in your index.
+ */
+type RemoveStopWords = Array<SupportedLanguage> | boolean;
+
+/**
+ * Strategy for removing words from the query when it doesn\'t return any results. This helps to avoid returning empty search results.  - `none`.   No words are removed when a query doesn\'t return results.  - `lastWords`.   Treat the last (then second to last, then third to last) word as optional,   until there are results or at most 5 words have been removed.  - `firstWords`.   Treat the first (then second, then third) word as optional,   until there are results or at most 5 words have been removed.  - `allOptional`.   Treat all words as optional.  For more information, see [Remove words to improve results](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/empty-or-insufficient-results/in-depth/why-use-remove-words-if-no-results/).
+ */
+type RemoveWordsIfNoResults = 'none' | 'lastWords' | 'firstWords' | 'allOptional';
+
+/**
+ * - `min`. Return matches with the lowest number of typos.   For example, if you have matches without typos, only include those.   But if there are no matches without typos (with 1 typo), include matches with 1 typo (2 typos). - `strict`. Return matches with the two lowest numbers of typos.   With `strict`, the Typo ranking criterion is applied first in the `ranking` setting.
+ */
+type TypoToleranceEnum = 'min' | 'strict' | 'true' | 'false';
+
+/**
+ * Whether [typo tolerance](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/typo-tolerance/) is enabled and how it is applied.  If typo tolerance is true, `min`, or `strict`, [word splitting and concatenation](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/splitting-and-concatenation/) are also active.
+ */
+type TypoTolerance = boolean | TypoToleranceEnum;
+
+type BaseInjectionQueryParameters = {
+    /**
+     * Whether to support phrase matching and excluding words from search queries Use the `advancedSyntaxFeatures` parameter to control which feature is supported.
+     */
+    advancedSyntax?: boolean | undefined;
+    /**
+     * Advanced search syntax features you want to support - `exactPhrase`.   Phrases in quotes must match exactly.   For example, `sparkly blue \"iPhone case\"` only returns records with the exact string \"iPhone case\" - `excludeWords`.   Query words prefixed with a `-` must not occur in a record.   For example, `search -engine` matches records that contain \"search\" but not \"engine\" This setting only has an effect if `advancedSyntax` is true.
+     */
+    advancedSyntaxFeatures?: Array<AdvancedSyntaxFeatures> | undefined;
+    /**
+     * Whether to allow typos on numbers in the search query Turn off this setting to reduce the number of irrelevant matches when searching in large sets of similar numbers.
+     */
+    allowTyposOnNumericTokens?: boolean | undefined;
+    /**
+     * Determine which plurals and synonyms should be considered an exact matches By default, Algolia treats singular and plural forms of a word, and single-word synonyms, as [exact](https://www.algolia.com/doc/guides/managing-results/relevance-overview/in-depth/ranking-criteria/#exact) matches when searching. For example - \"swimsuit\" and \"swimsuits\" are treated the same - \"swimsuit\" and \"swimwear\" are treated the same (if they are [synonyms](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/adding-synonyms/#regular-synonyms)) - `ignorePlurals`.   Plurals and similar declensions added by the `ignorePlurals` setting are considered exact matches - `singleWordSynonym`.   Single-word synonyms, such as \"NY\" = \"NYC\", are considered exact matches - `multiWordsSynonym`.   Multi-word synonyms, such as \"NY\" = \"New York\", are considered exact matches.
+     */
+    alternativesAsExact?: Array<AlternativesAsExact> | undefined;
+    /**
+     * Whether this search will be included in Analytics.
+     */
+    analytics?: boolean | undefined;
+    /**
+     * Whether the best matching attribute should be determined by minimum proximity This setting only affects ranking if the Attribute ranking criterion comes before Proximity in the `ranking` setting. If true, the best matching attribute is selected based on the minimum proximity of multiple matches. Otherwise, the best matching attribute is determined by the order in the `searchableAttributes` setting.
+     */
+    attributeCriteriaComputedByMinProximity?: boolean | undefined;
+    /**
+     * Attributes to highlight By default, all searchable attributes are highlighted. Use `*` to highlight all attributes or use an empty array `[]` to turn off highlighting. Attribute names are case-sensitive With highlighting, strings that match the search query are surrounded by HTML tags defined by `highlightPreTag` and `highlightPostTag`. You can use this to visually highlight matching parts of a search query in your UI For more information, see [Highlighting and snippeting](https://www.algolia.com/doc/guides/building-search-ui/ui-and-ux-patterns/highlighting-snippeting/js/).
+     */
+    attributesToHighlight?: Array<string> | undefined;
+    /**
+     * Attributes to include in the API response To reduce the size of your response, you can retrieve only some of the attributes. Attribute names are case-sensitive - `*` retrieves all attributes, except attributes included in the `customRanking` and `unretrievableAttributes` settings. - To retrieve all attributes except a specific one, prefix the attribute with a dash and combine it with the `*`: `[\"*\", \"-ATTRIBUTE\"]`. - The `objectID` attribute is always included.
+     */
+    attributesToRetrieve?: Array<string> | undefined;
+    /**
+     * Attributes for which to enable snippets. Attribute names are case-sensitive Snippets provide additional context to matched words. If you enable snippets, they include 10 words, including the matched word. The matched word will also be wrapped by HTML tags for highlighting. You can adjust the number of words with the following notation: `ATTRIBUTE:NUMBER`, where `NUMBER` is the number of words to be extracted.
+     */
+    attributesToSnippet?: Array<string> | undefined;
+    /**
+     * Whether to include a `queryID` attribute in the response The query ID is a unique identifier for a search query and is required for tracking [click and conversion events](https://www.algolia.com/guides/sending-events/getting-started/).
+     */
+    clickAnalytics?: boolean | undefined;
+    /**
+     * Whether to split compound words in the query into their building blocks For more information, see [Word segmentation](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/language-specific-configurations/#splitting-compound-words). Word segmentation is supported for these languages: German, Dutch, Finnish, Swedish, and Norwegian. Decompounding doesn\'t work for words with [non-spacing mark Unicode characters](https://www.charactercodes.net/category/non-spacing_mark). For example, `Gartenstühle` won\'t be decompounded if the `ü` consists of `u` (U+0075) and `◌̈` (U+0308).
+     */
+    decompoundQuery?: boolean | undefined;
+    /**
+     * Searchable attributes for which you want to [turn off the Exact ranking criterion](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/override-search-engine-defaults/in-depth/adjust-exact-settings/#turn-off-exact-for-some-attributes). Attribute names are case-sensitive This can be useful for attributes with long values, where the likelihood of an exact match is high, such as product descriptions. Turning off the Exact ranking criterion for these attributes favors exact matching on other attributes. This reduces the impact of individual attributes with a lot of content on ranking.
+     */
+    disableExactOnAttributes?: Array<string> | undefined;
+    /**
+     * Attributes for which you want to turn off [typo tolerance](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/typo-tolerance/). Attribute names are case-sensitive Returning only exact matches can help when - [Searching in hyphenated attributes](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/typo-tolerance/how-to/how-to-search-in-hyphenated-attributes/). - Reducing the number of matches when you have too many.   This can happen with attributes that are long blocks of text, such as product descriptions Consider alternatives such as `disableTypoToleranceOnWords` or adding synonyms if your attributes have intentional unusual spellings that might look like typos.
+     */
+    disableTypoToleranceOnAttributes?: Array<string> | undefined;
+    distinct?: Distinct | undefined;
+    /**
+     * Whether to enable A/B testing for this search.
+     */
+    enableABTest?: boolean | undefined;
+    /**
+     * Whether to enable Personalization.
+     */
+    enablePersonalization?: boolean | undefined;
+    /**
+     * Whether this search will use [Dynamic Re-Ranking](https://www.algolia.com/doc/guides/algolia-ai/re-ranking/) This setting only has an effect if you activated Dynamic Re-Ranking for this index in the Algolia dashboard.
+     */
+    enableReRanking?: boolean | undefined;
+    /**
+     * Whether to enable rules.
+     */
+    enableRules?: boolean | undefined;
+    exactOnSingleWordQuery?: ExactOnSingleWordQuery | undefined;
+    facetFilters?: FacetFilters | undefined;
+    /**
+     * Filter expression to only include items that match the filter criteria in the response.  You can use these filter expressions:  - **Numeric filters.** `<facet> <op> <number>`, where `<op>` is one of `<`, `<=`, `=`, `!=`, `>`, `>=`. - **Ranges.** `<facet>:<lower> TO <upper>` where `<lower>` and `<upper>` are the lower and upper limits of the range (inclusive). - **Facet filters.** `<facet>:<value>` where `<facet>` is a facet attribute (case-sensitive) and `<value>` a facet value. - **Tag filters.** `_tags:<value>` or just `<value>` (case-sensitive). - **Boolean filters.** `<facet>: true | false`.  You can combine filters with `AND`, `OR`, and `NOT` operators with the following restrictions:  - You can only combine filters of the same type with `OR`.   **Not supported:** `facet:value OR num > 3`. - You can\'t use `NOT` with combinations of filters.   **Not supported:** `NOT(facet:value OR facet:value)` - You can\'t combine conjunctions (`AND`) with `OR`.   **Not supported:** `facet:value OR (facet:value AND facet:value)`  Use quotes around your filters, if the facet attribute name or facet value has spaces, keywords (`OR`, `AND`, `NOT`), or quotes. If a facet attribute is an array, the filter matches if it matches at least one element of the array.  For more information, see [Filters](https://www.algolia.com/doc/guides/managing-results/refine-results/filtering/).
+     */
+    filters?: string | undefined;
+    /**
+     * Whether the search response should include detailed ranking information.
+     */
+    getRankingInfo?: boolean | undefined;
+    /**
+     * HTML tag to insert after the highlighted parts in all highlighted results and snippets.
+     */
+    highlightPostTag?: string | undefined;
+    /**
+     * HTML tag to insert before the highlighted parts in all highlighted results and snippets.
+     */
+    highlightPreTag?: string | undefined;
+    ignorePlurals?: IgnorePlurals | undefined;
+    /**
+     * Maximum number of facet values to return when [searching for facet values](https://www.algolia.com/doc/guides/managing-results/refine-results/faceting/#search-for-facet-values).
+     */
+    maxFacetHits?: number | undefined;
+    /**
+     * Minimum proximity score for two matching words This adjusts the [Proximity ranking criterion](https://www.algolia.com/doc/guides/managing-results/relevance-overview/in-depth/ranking-criteria/#proximity) by equally scoring matches that are farther apart For example, if `minProximity` is 2, neighboring matches and matches with one word between them would have the same score.
+     */
+    minProximity?: number | undefined;
+    /**
+     * Minimum number of characters a word in the search query must contain to accept matches with [one typo](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/typo-tolerance/in-depth/configuring-typo-tolerance/#configuring-word-length-for-typos).
+     */
+    minWordSizefor1Typo?: number | undefined;
+    /**
+     * Minimum number of characters a word in the search query must contain to accept matches with [two typos](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/typo-tolerance/in-depth/configuring-typo-tolerance/#configuring-word-length-for-typos).
+     */
+    minWordSizefor2Typos?: number | undefined;
+    /**
+     * ISO language codes that adjust settings that are useful for processing natural language queries (as opposed to keyword searches) - Sets `removeStopWords` and `ignorePlurals` to the list of provided languages. - Sets `removeWordsIfNoResults` to `allOptional`. - Adds a `natural_language` attribute to `ruleContexts` and `analyticsTags`.
+     */
+    naturalLanguages?: Array<SupportedLanguage> | undefined;
+    numericFilters?: NumericFilters | undefined;
+    optionalFilters?: OptionalFilters | undefined;
+    optionalWords?: OptionalWords | null | undefined;
+    /**
+     * Whether to include this search when calculating processing-time percentiles.
+     */
+    percentileComputation?: boolean | undefined;
+    /**
+     * Impact that Personalization should have on this search The higher this value is, the more Personalization determines the ranking compared to other factors. For more information, see [Understanding Personalization impact](https://www.algolia.com/doc/guides/personalization/personalizing-results/in-depth/configuring-personalization/#understanding-personalization-impact).
+     */
+    personalizationImpact?: number | undefined;
+    /**
+     * Languages for language-specific query processing steps such as plurals, stop-word removal, and word-detection dictionaries  This setting sets a default list of languages used by the `removeStopWords` and `ignorePlurals` settings. This setting also sets a dictionary for word detection in the logogram-based [CJK](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/normalization/#normalization-for-logogram-based-languages-cjk) languages. To support this, you must place the CJK language **first**  **You should always specify a query language.** If you don\'t specify an indexing language, the search engine uses all [supported languages](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/supported-languages/), or the languages you specified with the `ignorePlurals` or `removeStopWords` parameters. This can lead to unexpected search results. For more information, see [Language-specific configuration](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/language-specific-configurations/).
+     */
+    queryLanguages?: Array<SupportedLanguage> | undefined;
+    queryType?: QueryType | undefined;
+    removeStopWords?: RemoveStopWords | undefined;
+    removeWordsIfNoResults?: RemoveWordsIfNoResults | undefined;
+    /**
+     * Whether to replace a highlighted word with the matched synonym By default, the original words are highlighted even if a synonym matches. For example, with `home` as a synonym for `house` and a search for `home`, records matching either \"home\" or \"house\" are included in the search results, and either \"home\" or \"house\" are highlighted With `replaceSynonymsInHighlight` set to `true`, a search for `home` still matches the same records, but all occurrences of \"house\" are replaced by \"home\" in the highlighted response.
+     */
+    replaceSynonymsInHighlight?: boolean | undefined;
+    /**
+     * Properties to include in the API response of search and browse requests By default, all response properties are included. To reduce the response size, you can select which properties should be included An empty list may lead to an empty API response (except properties you can\'t exclude) You can\'t exclude these properties: `message`, `warning`, `cursor`, `abTestVariantID`, or any property added by setting `getRankingInfo` to true Your search depends on the `hits` field. If you omit this field, searches won\'t return any results. Your UI might also depend on other properties, for example, for pagination. Before restricting the response size, check the impact on your search experience.
+     */
+    responseFields?: Array<string> | undefined;
+    /**
+     * Whether to restrict highlighting and snippeting to items that at least partially matched the search query. By default, all items are highlighted and snippeted.
+     */
+    restrictHighlightAndSnippetArrays?: boolean | undefined;
+    /**
+     * Restricts a search to a subset of your searchable attributes. Attribute names are case-sensitive.
+     */
+    restrictSearchableAttributes?: Array<string> | undefined;
+    /**
+     * Assigns a rule context to the search query [Rule contexts](https://www.algolia.com/doc/guides/managing-results/rules/rules-overview/how-to/customize-search-results-by-platform/#whats-a-context) are strings that you can use to trigger matching rules.
+     */
+    ruleContexts?: Array<string> | undefined;
+    /**
+     * String used as an ellipsis indicator when a snippet is truncated.
+     */
+    snippetEllipsisText?: string | undefined;
+    /**
+     * Whether to take into account an index\'s synonyms for this search.
+     */
+    synonyms?: boolean | undefined;
+    typoTolerance?: TypoTolerance | undefined;
+};
+
+type ExternalOrdering = 'default' | 'userDefined';
+
+type External = {
+    /**
+     * Composition Index name.
+     */
+    index: string;
+    params?: BaseInjectionQueryParameters | undefined;
+    ordering?: ExternalOrdering | undefined;
+};
+
+/**
+ * Injected items will originate from externally provided objectIDs (that must exist in the index) given at runtime in the run request payload.
+ */
+type ExternalSource = {
+    external: External;
+};
+
+type Search = {
+    /**
+     * Composition Index name.
+     */
+    index: string;
+    params?: BaseInjectionQueryParameters | undefined;
+};
+
+/**
+ * Injected items will originate from a search request performed on the specified index.
+ */
+type SearchSource = {
+    search: Search;
+};
+
+type InjectedItemSource = SearchSource | ExternalSource;
+
+type InjectedItem = {
+    /**
+     * injected Item unique identifier.
+     */
+    key: string;
+    source: InjectedItemSource;
+    position: number;
+    length: number;
+    metadata?: InjectedItemMetadata | undefined;
+};
+
+type MainInjectionQueryParameters = BaseInjectionQueryParameters & Record<string, unknown>;
+
+type CompositionSourceSearch = {
+    /**
+     * Composition Main Index name.
+     */
+    index: string;
+    params?: MainInjectionQueryParameters | undefined;
+};
+
+type CompositionSource = {
+    search: CompositionSourceSearch;
+};
+
+type Main = {
+    source: CompositionSource;
+};
+
+type Injection = {
+    main: Main;
+    /**
+     * list of injected items of the current Composition.
+     */
+    injectedItems?: Array<InjectedItem> | undefined;
+};
+
+type CompositionBehavior = {
+    injection: Injection;
+};
+
+type Composition = {
+    /**
+     * Composition unique identifier.
+     */
+    objectID: string;
+    /**
+     * Composition name.
+     */
+    name: string;
+    /**
+     * Composition description.
+     */
+    description?: string | undefined;
+    behavior: CompositionBehavior;
+};
+
+/**
+ * Operation arguments when deleting.
+ */
+type DeleteCompositionAction = {
+    /**
+     * Composition unique identifier.
+     */
+    objectID: string;
+};
+
+type BatchCompositionAction = Composition | DeleteCompositionAction;
+
+type MultipleBatchRequest = {
+    action: Action;
+    body: BatchCompositionAction;
+};
+
+/**
+ * Batch parameters.
+ */
+type BatchParams = {
+    requests: Array<MultipleBatchRequest>;
+};
+
+/**
+ * Effect of the rule.
+ */
+type CompositionRuleConsequence = {
+    behavior: CompositionBehavior;
+};
+
+/**
+ * Which part of the search query the pattern should match:  - `startsWith`. The pattern must match the beginning of the query. - `endsWith`. The pattern must match the end of the query. - `is`. The pattern must match the query exactly. - `contains`. The pattern must match anywhere in the query.  Empty queries are only allowed as patterns with `anchoring: is`.
+ */
+type Anchoring = 'is' | 'startsWith' | 'endsWith' | 'contains';
+
+type Condition = {
+    /**
+     * Query pattern that triggers the rule.  You can use either a literal string, or a special pattern `{facet:ATTRIBUTE}`, where `ATTRIBUTE` is a facet name. The rule is triggered if the query matches the literal string or a value of the specified facet. For example, with `pattern: {facet:genre}`, the rule is triggered when users search for a genre, such as \"comedy\".
+     */
+    pattern?: string | undefined;
+    anchoring?: Anchoring | undefined;
+    /**
+     * An additional restriction that only triggers the rule, when the search has the same value as `ruleContexts` parameter. For example, if `context: mobile`, the rule is only triggered when the search request has a matching `ruleContexts: mobile`. A rule context must only contain alphanumeric characters.
+     */
+    context?: string | undefined;
+    /**
+     * Filters that trigger the rule.  You can add add filters using the syntax `facet:value` so that the rule is triggered, when the specific filter is selected. You can use `filters` on its own or combine it with the `pattern` parameter.
+     */
+    filters?: string | undefined;
+};
+
+type TimeRange = {
+    /**
+     * When the rule should start to be active, in Unix epoch time.
+     */
+    from?: number | undefined;
+    /**
+     * When the rule should stop to be active, in Unix epoch time.
+     */
+    until?: number | undefined;
+};
+
+type CompositionRule = {
+    /**
+     * Composition rule unique identifier.
+     */
+    objectID: string;
+    /**
+     * Conditions that trigger a composition rule.
+     */
+    conditions: Array<Condition>;
+    consequence: CompositionRuleConsequence;
+    /**
+     * Description of the rule\'s purpose to help you distinguish between different rules.
+     */
+    description?: string | undefined;
+    /**
+     * Whether the rule is active.
+     */
+    enabled?: boolean | undefined;
+    /**
+     * Time periods when the rule is active.
+     */
+    validity?: Array<TimeRange> | undefined;
+    /**
+     * A list of tags.
+     */
+    tags?: Array<string> | undefined;
+};
+
+/**
+ * Task status, `published` if the task is completed, `notPublished` otherwise.
+ */
+type TaskStatus = 'published' | 'notPublished';
+
+type GetTaskResponse = {
+    status: TaskStatus;
+};
+
+type ListCompositionsResponse = {
+    /**
+     * All compositions in your Algolia application.
+     */
+    items: Array<Composition>;
+    /**
+     * Number of pages.
+     */
+    nbPages: number;
+    /**
+     * Current page.
+     */
+    page: number;
+    /**
+     * Number of items per page.
+     */
+    hitsPerPage: number;
+    /**
+     * Number of items.
+     */
+    nbHits: number;
+};
+
+type MultipleBatchResponse = {
+    /**
+     * Task IDs. One for each index.
+     */
+    taskID: {
+        [key: string]: number;
+    };
+};
+
+type RulesMultipleBatchResponse = {
+    /**
+     * Unique identifier of a task.  A successful API response means that a task was added to a queue. It might not run immediately. You can check the task\'s progress with the [`task` operation](#tag/Indices/operation/getTask) and this `taskID`.
+     */
+    taskID: number;
+};
+
+type SearchCompositionRulesResponse = {
+    /**
+     * Composition rules that matched the search criteria.
+     */
+    hits: Array<CompositionRule>;
+    /**
+     * Number of composition rules that matched the search criteria.
+     */
+    nbHits: number;
+    /**
+     * Current page.
+     */
+    page: number;
+    /**
+     * Number of pages.
+     */
+    nbPages: number;
+};
+
 type FacetHits = {
     /**
      * Facet value.
@@ -565,21 +1072,52 @@ type SearchPagination = {
      */
     nbPages: number;
     /**
-     * Number of hits per page.
+     * Number of hits per page.
+     */
+    hitsPerPage: number;
+};
+
+type SearchResultsItem<T = Record<string, unknown>> = BaseSearchResponse & SearchPagination & SearchHits<T> & ResultsCompositionsResponse;
+
+type SearchResults<T = Record<string, unknown>> = {
+    /**
+     * Search results.
+     */
+    results: SearchResultsItem<T>[];
+};
+
+type SearchResponse<T = Record<string, unknown>> = CompositionBaseSearchResponse & SearchResults<T>;
+
+type TaskIDResponse = {
+    /**
+     * Unique identifier of a task.  A successful API response means that a task was added to a queue. It might not run immediately. You can check the task\'s progress with the [`task` operation](#tag/Indices/operation/getTask) and this `taskID`.
      */
-    hitsPerPage: number;
+    taskID: number;
 };
 
-type SearchResultsItem<T = Record<string, unknown>> = BaseSearchResponse & SearchPagination & SearchHits<T> & ResultsCompositionsResponse;
-
-type SearchResults<T = Record<string, unknown>> = {
+/**
+ * Operation arguments when deleting.
+ */
+type DeleteCompositionRuleAction = {
     /**
-     * Search results.
+     * Composition rule unique identifier.
      */
-    results: SearchResultsItem<T>[];
+    objectID: string;
 };
 
-type SearchResponse<T = Record<string, unknown>> = CompositionBaseSearchResponse & SearchResults<T>;
+type RulesBatchCompositionAction = CompositionRule | DeleteCompositionRuleAction;
+
+type RulesMultipleBatchRequest = {
+    action: Action;
+    body: RulesBatchCompositionAction;
+};
+
+/**
+ * Composition rules batch parameters.
+ */
+type CompositionRulesBatchParams = {
+    requests?: Array<RulesMultipleBatchRequest> | undefined;
+};
 
 /**
  * Range object with lower and upper values in meters to define custom ranges.
@@ -627,28 +1165,8 @@ type ExternalInjectedItem = {
     items: Array<ExternalInjection>;
 };
 
-/**
- * Filter the search by facet values, so that only records with the same facet values are retrieved.  **Prefer using the `filters` parameter, which supports all filter types and combinations with boolean operators.**  - `[filter1, filter2]` is interpreted as `filter1 AND filter2`. - `[[filter1, filter2], filter3]` is interpreted as `filter1 OR filter2 AND filter3`. - `facet:-value` is interpreted as `NOT facet:value`.  While it\'s best to avoid attributes that start with a `-`, you can still filter them by escaping with a backslash: `facet:\\-value`.
- */
-type FacetFilters = Array<FacetFilters> | string;
-
 type InsideBoundingBox = string | Array<Array<number>>;
 
-/**
- * Filter by numeric facets.  **Prefer using the `filters` parameter, which supports all filter types and combinations with boolean operators.**  You can use numeric comparison operators: `<`, `<=`, `=`, `!=`, `>`, `>=`. Comparisons are precise up to 3 decimals. You can also provide ranges: `facet:<lower> TO <upper>`. The range includes the lower and upper boundaries. The same combination rules apply as for `facetFilters`.
- */
-type NumericFilters = Array<NumericFilters> | string;
-
-/**
- * Filters to promote or demote records in the search results.  Optional filters work like facet filters, but they don\'t exclude records from the search results. Records that match the optional filter rank before records that don\'t match. If you\'re using a negative filter `facet:-value`, matching records rank after records that don\'t match.  - Optional filters don\'t work on virtual replicas. - Optional filters are applied _after_ sort-by attributes. - Optional filters are applied _before_ custom ranking attributes (in the default [ranking](https://www.algolia.com/doc/guides/managing-results/relevance-overview/in-depth/ranking-criteria/)). - Optional filters don\'t work with numeric attributes.
- */
-type OptionalFilters = Array<OptionalFilters> | string;
-
-/**
- * ISO code for a supported language.
- */
-type SupportedLanguage = 'af' | 'ar' | 'az' | 'bg' | 'bn' | 'ca' | 'cs' | 'cy' | 'da' | 'de' | 'el' | 'en' | 'eo' | 'es' | 'et' | 'eu' | 'fa' | 'fi' | 'fo' | 'fr' | 'ga' | 'gl' | 'he' | 'hi' | 'hu' | 'hy' | 'id' | 'is' | 'it' | 'ja' | 'ka' | 'kk' | 'ko' | 'ku' | 'ky' | 'lt' | 'lv' | 'mi' | 'mn' | 'mr' | 'ms' | 'mt' | 'nb' | 'nl' | 'no' | 'ns' | 'pl' | 'ps' | 'pt' | 'pt-br' | 'qu' | 'ro' | 'ru' | 'sk' | 'sq' | 'sv' | 'sw' | 'ta' | 'te' | 'th' | 'tl' | 'tn' | 'tr' | 'tt' | 'uk' | 'ur' | 'uz' | 'zh';
-
 type Params = {
     /**
      * Search query.
@@ -748,6 +1266,33 @@ type RequestBody = {
     params?: Params | undefined;
 };
 
+/**
+ * Composition Rules search parameters.
+ */
+type SearchCompositionRulesParams = {
+    /**
+     * Search query for rules.
+     */
+    query?: string | undefined;
+    anchoring?: Anchoring | undefined;
+    /**
+     * Only return composition rules that match the context (exact match).
+     */
+    context?: string | undefined;
+    /**
+     * Requested page of the API response.  Algolia uses `page` and `hitsPerPage` to control how search results are displayed ([paginated](https://www.algolia.com/doc/guides/building-search-ui/ui-and-ux-patterns/pagination/js/)).  - `hitsPerPage`: sets the number of search results (_hits_) displayed per page. - `page`: specifies the page number of the search results you want to retrieve. Page numbering starts at 0, so the first page is `page=0`, the second is `page=1`, and so on.  For example, to display 10 results per page starting from the third page, set `hitsPerPage` to 10 and `page` to 2.
+     */
+    page?: number | undefined;
+    /**
+     * Maximum number of hits per page.  Algolia uses `page` and `hitsPerPage` to control how search results are displayed ([paginated](https://www.algolia.com/doc/guides/building-search-ui/ui-and-ux-patterns/pagination/js/)).  - `hitsPerPage`: sets the number of search results (_hits_) displayed per page. - `page`: specifies the page number of the search results you want to retrieve. Page numbering starts at 0, so the first page is `page=0`, the second is `page=1`, and so on.  For example, to display 10 results per page starting from the third page, set `hitsPerPage` to 10 and `page` to 2.
+     */
+    hitsPerPage?: number | undefined;
+    /**
+     * If `true`, return only enabled composition rules. If `false`, return only inactive composition rules. By default, _all_ composition rules are returned.
+     */
+    enabled?: boolean | null | undefined;
+};
+
 type SearchForFacetValuesParams = {
     /**
      * Search query.
@@ -764,6 +1309,178 @@ type SearchForFacetValuesRequest = {
     params?: SearchForFacetValuesParams | undefined;
 };
 
+/**
+ * Properties for the `customDelete` method.
+ */
+type CustomDeleteProps = {
+    /**
+     * Path of the endpoint, for example `1/newFeature`.
+     */
+    path: string;
+    /**
+     * Query parameters to apply to the current query.
+     */
+    parameters?: {
+        [key: string]: any;
+    } | undefined;
+};
+/**
+ * Properties for the `customGet` method.
+ */
+type CustomGetProps = {
+    /**
+     * Path of the endpoint, for example `1/newFeature`.
+     */
+    path: string;
+    /**
+     * Query parameters to apply to the current query.
+     */
+    parameters?: {
+        [key: string]: any;
+    } | undefined;
+};
+/**
+ * Properties for the `customPost` method.
+ */
+type CustomPostProps = {
+    /**
+     * Path of the endpoint, for example `1/newFeature`.
+     */
+    path: string;
+    /**
+     * Query parameters to apply to the current query.
+     */
+    parameters?: {
+        [key: string]: any;
+    } | undefined;
+    /**
+     * Parameters to send with the custom request.
+     */
+    body?: Record<string, unknown> | undefined;
+};
+/**
+ * Properties for the `customPut` method.
+ */
+type CustomPutProps = {
+    /**
+     * Path of the endpoint, for example `1/newFeature`.
+     */
+    path: string;
+    /**
+     * Query parameters to apply to the current query.
+     */
+    parameters?: {
+        [key: string]: any;
+    } | undefined;
+    /**
+     * Parameters to send with the custom request.
+     */
+    body?: Record<string, unknown> | undefined;
+};
+/**
+ * Properties for the `deleteComposition` method.
+ */
+type DeleteCompositionProps = {
+    /**
+     * Unique Composition ObjectID.
+     */
+    compositionID: string;
+};
+/**
+ * Properties for the `deleteCompositionRule` method.
+ */
+type DeleteCompositionRuleProps = {
+    /**
+     * Unique Composition ObjectID.
+     */
+    compositionID: string;
+    /**
+     * Unique identifier of a rule object.
+     */
+    objectID: string;
+};
+/**
+ * Properties for the `getComposition` method.
+ */
+type GetCompositionProps = {
+    /**
+     * Unique Composition ObjectID.
+     */
+    compositionID: string;
+};
+/**
+ * Properties for the `getRule` method.
+ */
+type GetRuleProps = {
+    /**
+     * Unique Composition ObjectID.
+     */
+    compositionID: string;
+    /**
+     * Unique identifier of a rule object.
+     */
+    objectID: string;
+};
+/**
+ * Properties for the `getTask` method.
+ */
+type GetTaskProps = {
+    /**
+     * Unique Composition ObjectID.
+     */
+    compositionID: string;
+    /**
+     * Unique task identifier.
+     */
+    taskID: number;
+};
+/**
+ * Properties for the `listCompositions` method.
+ */
+type ListCompositionsProps = {
+    /**
+     * Requested page of the API response. If `null`, the API response is not paginated.
+     */
+    page?: number | undefined;
+    /**
+     * Number of hits per page.
+     */
+    hitsPerPage?: number | undefined;
+};
+/**
+ * Properties for the `putComposition` method.
+ */
+type PutCompositionProps = {
+    /**
+     * Unique Composition ObjectID.
+     */
+    compositionID: string;
+    composition: Composition;
+};
+/**
+ * Properties for the `putCompositionRule` method.
+ */
+type PutCompositionRuleProps = {
+    /**
+     * Unique Composition ObjectID.
+     */
+    compositionID: string;
+    /**
+     * Unique identifier of a rule object.
+     */
+    objectID: string;
+    compositionRule: CompositionRule;
+};
+/**
+ * Properties for the `saveRules` method.
+ */
+type SaveRulesProps = {
+    /**
+     * Unique Composition ObjectID.
+     */
+    compositionID: string;
+    rules: CompositionRulesBatchParams;
+};
 /**
  * Properties for the `search` method.
  */
@@ -774,6 +1491,16 @@ type SearchProps = {
     compositionID: string;
     requestBody: RequestBody;
 };
+/**
+ * Properties for the `searchCompositionRules` method.
+ */
+type SearchCompositionRulesProps = {
+    /**
+     * Unique Composition ObjectID.
+     */
+    compositionID: string;
+    searchCompositionRulesParams?: SearchCompositionRulesParams | undefined;
+};
 /**
  * Properties for the `searchForFacetValues` method.
  */
@@ -788,8 +1515,26 @@ type SearchForFacetValuesProps = {
     facetName: string;
     searchForFacetValuesRequest?: SearchForFacetValuesRequest | undefined;
 };
+type WaitForCompositionTaskOptions = {
+    /**
+     * The maximum number of retries. 50 by default.
+     */
+    maxRetries?: number | undefined;
+    /**
+     * The function to decide how long to wait between retries.
+     */
+    timeout?: (retryCount: number) => number;
+    /**
+     * The `taskID` returned by the method response.
+     */
+    taskID: number;
+    /**
+     * The `compositionID` where the operation was performed.
+     */
+    compositionID: string;
+};
 
-declare const apiClientVersion = "1.13.0";
+declare const apiClientVersion = "1.15.0";
 declare function createCompositionClient({ appId: appIdOption, apiKey: apiKeyOption, authMode, algoliaAgents, ...options }: CreateClientOptions): {
     transporter: _algolia_client_common.Transporter;
     /**
@@ -824,6 +1569,166 @@ declare function createCompositionClient({ appId: appIdOption, apiKey: apiKeyOpt
     setClientApiKey({ apiKey }: {
         apiKey: string;
     }): void;
+    /**
+     * Helper: Wait for a composition-level task to be published (completed) for a given `compositionID` and `taskID`.
+     *
+     * @summary Helper method that waits for a task to be published (completed).
+     * @param WaitForCompositionTaskOptions - The `WaitForCompositionTaskOptions` object.
+     * @param WaitForCompositionTaskOptions.compositionID - The `compositionID` where the operation was performed.
+     * @param WaitForCompositionTaskOptions.taskID - The `taskID` returned in the method response.
+     * @param WaitForCompositionTaskOptions.maxRetries - The maximum number of retries. 50 by default.
+     * @param WaitForCompositionTaskOptions.timeout - The function to decide how long to wait between retries.
+     * @param requestOptions - The requestOptions to send along with the query, they will be forwarded to the `getTask` method and merged with the transporter requestOptions.
+     */
+    waitForCompositionTask({ compositionID, taskID, maxRetries, timeout, }: WaitForCompositionTaskOptions, requestOptions?: RequestOptions): Promise<GetTaskResponse>;
+    /**
+     * This method lets you send requests to the Algolia REST API.
+     * @param customDelete - The customDelete object.
+     * @param customDelete.path - Path of the endpoint, for example `1/newFeature`.
+     * @param customDelete.parameters - Query parameters to apply to the current query.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    customDelete({ path, parameters }: CustomDeleteProps, requestOptions?: RequestOptions): Promise<Record<string, unknown>>;
+    /**
+     * This method lets you send requests to the Algolia REST API.
+     * @param customGet - The customGet object.
+     * @param customGet.path - Path of the endpoint, for example `1/newFeature`.
+     * @param customGet.parameters - Query parameters to apply to the current query.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    customGet({ path, parameters }: CustomGetProps, requestOptions?: RequestOptions): Promise<Record<string, unknown>>;
+    /**
+     * This method lets you send requests to the Algolia REST API.
+     * @param customPost - The customPost object.
+     * @param customPost.path - Path of the endpoint, for example `1/newFeature`.
+     * @param customPost.parameters - Query parameters to apply to the current query.
+     * @param customPost.body - Parameters to send with the custom request.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    customPost({ path, parameters, body }: CustomPostProps, requestOptions?: RequestOptions): Promise<Record<string, unknown>>;
+    /**
+     * This method lets you send requests to the Algolia REST API.
+     * @param customPut - The customPut object.
+     * @param customPut.path - Path of the endpoint, for example `1/newFeature`.
+     * @param customPut.parameters - Query parameters to apply to the current query.
+     * @param customPut.body - Parameters to send with the custom request.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    customPut({ path, parameters, body }: CustomPutProps, requestOptions?: RequestOptions): Promise<Record<string, unknown>>;
+    /**
+     * Delete a composition from the current Algolia application.
+     *
+     * Required API Key ACLs:
+     *  - editSettings
+     * @param deleteComposition - The deleteComposition object.
+     * @param deleteComposition.compositionID - Unique Composition ObjectID.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    deleteComposition({ compositionID }: DeleteCompositionProps, requestOptions?: RequestOptions): Promise<TaskIDResponse>;
+    /**
+     * Delete a Composition Rule from the specified Composition ID.
+     *
+     * Required API Key ACLs:
+     *  - editSettings
+     * @param deleteCompositionRule - The deleteCompositionRule object.
+     * @param deleteCompositionRule.compositionID - Unique Composition ObjectID.
+     * @param deleteCompositionRule.objectID - Unique identifier of a rule object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    deleteCompositionRule({ compositionID, objectID }: DeleteCompositionRuleProps, requestOptions?: RequestOptions): Promise<TaskIDResponse>;
+    /**
+     * Retrieve a single composition in the current Algolia application.
+     *
+     * Required API Key ACLs:
+     *  - editSettings
+     *  - settings
+     * @param getComposition - The getComposition object.
+     * @param getComposition.compositionID - Unique Composition ObjectID.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    getComposition({ compositionID }: GetCompositionProps, requestOptions?: RequestOptions): Promise<Composition>;
+    /**
+     * Retrieves a rule by its ID. To find the object ID of rules, use the [`search` operation](#tag/Rules/operation/searchRules).
+     *
+     * Required API Key ACLs:
+     *  - editSettings
+     *  - settings
+     * @param getRule - The getRule object.
+     * @param getRule.compositionID - Unique Composition ObjectID.
+     * @param getRule.objectID - Unique identifier of a rule object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    getRule({ compositionID, objectID }: GetRuleProps, requestOptions?: RequestOptions): Promise<CompositionRule>;
+    /**
+     * Checks the status of a given task.
+     *
+     * Required API Key ACLs:
+     *  - editSettings
+     *  - settings
+     *  - addObject
+     *  - deleteObject
+     *  - deleteIndex
+     * @param getTask - The getTask object.
+     * @param getTask.compositionID - Unique Composition ObjectID.
+     * @param getTask.taskID - Unique task identifier.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    getTask({ compositionID, taskID }: GetTaskProps, requestOptions?: RequestOptions): Promise<GetTaskResponse>;
+    /**
+     * Lists all compositions in the current Algolia application.
+     *
+     * Required API Key ACLs:
+     *  - editSettings
+     *  - settings
+     * @param listCompositions - The listCompositions object.
+     * @param listCompositions.page - Requested page of the API response. If `null`, the API response is not paginated.
+     * @param listCompositions.hitsPerPage - Number of hits per page.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    listCompositions({ page, hitsPerPage }?: ListCompositionsProps, requestOptions?: RequestOptions | undefined): Promise<ListCompositionsResponse>;
+    /**
+     * Adds, updates, or deletes compositions with a single API request.
+     *
+     * Required API Key ACLs:
+     *  - editSettings
+     * @param batchParams - The batchParams object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    multipleBatch(batchParams: BatchParams, requestOptions?: RequestOptions): Promise<MultipleBatchResponse>;
+    /**
+     * Upsert a composition in the current Algolia application.
+     *
+     * Required API Key ACLs:
+     *  - editSettings
+     * @param putComposition - The putComposition object.
+     * @param putComposition.compositionID - Unique Composition ObjectID.
+     * @param putComposition.composition - The composition object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    putComposition({ compositionID, composition }: PutCompositionProps, requestOptions?: RequestOptions): Promise<TaskIDResponse>;
+    /**
+     * Upsert a Composition Rule for the specified composition ID.
+     *
+     * Required API Key ACLs:
+     *  - editSettings
+     * @param putCompositionRule - The putCompositionRule object.
+     * @param putCompositionRule.compositionID - Unique Composition ObjectID.
+     * @param putCompositionRule.objectID - Unique identifier of a rule object.
+     * @param putCompositionRule.compositionRule - The compositionRule object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    putCompositionRule({ compositionID, objectID, compositionRule }: PutCompositionRuleProps, requestOptions?: RequestOptions): Promise<TaskIDResponse>;
+    /**
+     * Create or update or delete multiple composition rules.
+     *
+     * Required API Key ACLs:
+     *  - editSettings
+     * @param saveRules - The saveRules object.
+     * @param saveRules.compositionID - Unique Composition ObjectID.
+     * @param saveRules.rules - The rules object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    saveRules({ compositionID, rules }: SaveRulesProps, requestOptions?: RequestOptions): Promise<RulesMultipleBatchResponse>;
     /**
      * Runs a query on a single composition and returns matching results.
      *
@@ -835,6 +1740,17 @@ declare function createCompositionClient({ appId: appIdOption, apiKey: apiKeyOpt
      * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
      */
     search<T>({ compositionID, requestBody }: SearchProps, requestOptions?: RequestOptions): Promise<SearchResponse<T>>;
+    /**
+     * Searches for composition rules in your index.
+     *
+     * Required API Key ACLs:
+     *  - settings
+     * @param searchCompositionRules - The searchCompositionRules object.
+     * @param searchCompositionRules.compositionID - Unique Composition ObjectID.
+     * @param searchCompositionRules.searchCompositionRulesParams - The searchCompositionRulesParams object.
+     * @param requestOptions - The requestOptions to send along with the query, they will be merged with the transporter requestOptions.
+     */
+    searchCompositionRules({ compositionID, searchCompositionRulesParams }: SearchCompositionRulesProps, requestOptions?: RequestOptions): Promise<SearchCompositionRulesResponse>;
     /**
      * Searches for values of a specified facet attribute on the composition\'s main source\'s index.  - By default, facet values are sorted by decreasing count.   You can adjust this with the `sortFacetValueBy` parameter. - Searching for facet values doesn\'t work if you have **more than 65 searchable facets and searchable attributes combined**.
      *
@@ -859,4 +1775,4 @@ type ErrorBase = Record<string, any> & {
 declare function compositionClient(appId: string, apiKey: string, options?: ClientOptions | undefined): CompositionClient;
 type CompositionClient = ReturnType<typeof createCompositionClient>;
 
-export { type AroundPrecision, type AroundRadius, type AroundRadiusAll, type Banner, type BannerImage, type BannerImageUrl, type BannerLink, type BaseSearchResponse, type CompositionBaseSearchResponse, type CompositionClient, type CompositionIdRankingInfo, type CompositionRankingInfo, type CompositionRunAppliedRules, type CompositionRunSearchResponse, type CompositionsSearchResponse, type ErrorBase, type Exhaustive, type ExternalInjectedItem, type ExternalInjection, type FacetFilters, type FacetHits, type FacetOrdering, type FacetStats, type Facets, type HighlightResult, type HighlightResultOption, type Hit, type HitMetadata, type HitRankingInfo, type InsideBoundingBox, type MatchLevel, type MatchedGeoLocation, type NumericFilters, type OptionalFilters, type Params, type Personalization, type Range, type RankingInfo, type Redirect, type RedirectRuleIndexData, type RedirectRuleIndexMetadata, type RedirectURL, type RenderingContent, type RequestBody, type ResultsCompositionInfoResponse, type ResultsCompositionsResponse, type ResultsInjectedItemAppliedRulesInfoResponse, type ResultsInjectedItemInfoResponse, type SearchForFacetValuesParams, type SearchForFacetValuesProps, type SearchForFacetValuesRequest, type SearchForFacetValuesResponse, type SearchForFacetValuesResults, type SearchHits, type SearchPagination, type SearchProps, type SearchResponse, type SearchResults, type SearchResultsItem, type SnippetResult, type SnippetResultOption, type SortRemainingBy, type SupportedLanguage, type Value, type Widgets, apiClientVersion, compositionClient };
+export { type Action, type AdvancedSyntaxFeatures, type AlternativesAsExact, type Anchoring, type AroundPrecision, type AroundRadius, type AroundRadiusAll, type Banner, type BannerImage, type BannerImageUrl, type BannerLink, type BaseInjectionQueryParameters, type BaseSearchResponse, type BatchCompositionAction, type BatchParams, type BooleanString, type Composition, type CompositionBaseSearchResponse, type CompositionBehavior, type CompositionClient, type CompositionIdRankingInfo, type CompositionRankingInfo, type CompositionRule, type CompositionRuleConsequence, type CompositionRulesBatchParams, type CompositionRunAppliedRules, type CompositionRunSearchResponse, type CompositionSource, type CompositionSourceSearch, type CompositionsSearchResponse, type Condition, type CustomDeleteProps, type CustomGetProps, type CustomPostProps, type CustomPutProps, type DeleteCompositionAction, type DeleteCompositionProps, type DeleteCompositionRuleAction, type DeleteCompositionRuleProps, type Distinct, type ErrorBase, type ExactOnSingleWordQuery, type Exhaustive, type External, type ExternalInjectedItem, type ExternalInjection, type ExternalOrdering, type ExternalSource, type FacetFilters, type FacetHits, type FacetOrdering, type FacetStats, type Facets, type GetCompositionProps, type GetRuleProps, type GetTaskProps, type GetTaskResponse, type HighlightResult, type HighlightResultOption, type Hit, type HitMetadata, type HitRankingInfo, type IgnorePlurals, type InjectedItem, type InjectedItemHitsMetadata, type InjectedItemMetadata, type InjectedItemSource, type Injection, type InsideBoundingBox, type ListCompositionsProps, type ListCompositionsResponse, type Main, type MainInjectionQueryParameters, type MatchLevel, type MatchedGeoLocation, type MultipleBatchRequest, type MultipleBatchResponse, type NumericFilters, type OptionalFilters, type OptionalWords, type Params, type Personalization, type PutCompositionProps, type PutCompositionRuleProps, type QueryType, type Range, type RankingInfo, type Redirect, type RedirectRuleIndexData, type RedirectRuleIndexMetadata, type RedirectURL, type RemoveStopWords, type RemoveWordsIfNoResults, type RenderingContent, type RequestBody, type ResultsCompositionInfoResponse, type ResultsCompositionsResponse, type ResultsInjectedItemAppliedRulesInfoResponse, type ResultsInjectedItemInfoResponse, type RulesBatchCompositionAction, type RulesMultipleBatchRequest, type RulesMultipleBatchResponse, type SaveRulesProps, type Search, type SearchCompositionRulesParams, type SearchCompositionRulesProps, type SearchCompositionRulesResponse, type SearchForFacetValuesParams, type SearchForFacetValuesProps, type SearchForFacetValuesRequest, type SearchForFacetValuesResponse, type SearchForFacetValuesResults, type SearchHits, type SearchPagination, type SearchProps, type SearchResponse, type SearchResults, type SearchResultsItem, type SearchSource, type SnippetResult, type SnippetResultOption, type SortRemainingBy, type SupportedLanguage, type TaskIDResponse, type TaskStatus, type TimeRange, type TypoTolerance, type TypoToleranceEnum, type Value, type WaitForCompositionTaskOptions, type Widgets, apiClientVersion, compositionClient };