> ## Documentation Index
> Fetch the complete documentation index at: https://algolia.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Retrieve index settings

> Retrieves an object with non-null index settings.

**Required ACL:** `settings`


## OpenAPI

````yaml specs/search.yml get /1/indexes/{indexName}/settings
openapi: 3.1.0
info:
  title: Search API
  summary: >-
    The Algolia Search API lets you search, configure, and manage your indices
    and records
  description: >
    ## Client libraries


    Use Algolia's API clients and libraries to reliably integrate Algolia's APIs
    with your apps.

    The official API clients are covered by Algolia's [Service Level
    Agreement](https://www.algolia.com/policies/sla).


    For more information, see [Algolia's
    ecosystem](https://www.algolia.com/doc/libraries).


    ## Base URLs


    Base URLs for the Search API:


    - `https://{APPLICATION_ID}.algolia.net`

    - `https://{APPLICATION_ID}-dsn.algolia.net`.
      If your subscription includes a [Distributed Search Network](https://dashboard.algolia.com/infra),
      this ensures that requests are sent to servers closest to users.

    Both URLs provide high availability by distributing requests with load
    balancing.


    **All requests must use HTTPS.**


    ## Retry strategy


    To guarantee high availability, implement a retry strategy for all API
    requests using the URLs of your servers as fallbacks:


    - `https://{APPLICATION_ID}-1.algolianet.com`

    - `https://{APPLICATION_ID}-2.algolianet.com`

    - `https://{APPLICATION_ID}-3.algolianet.com`


    These URLs use a different DNS provider than the primary URLs.

    Randomize this list to ensure an even load across the three servers.


    All Algolia API clients implement this retry strategy.


    ## Authentication


    Add these headers to authenticate requests:


    - `x-algolia-application-id`. Your Algolia application ID.

    - `x-algolia-api-key`. An API key with the necessary permissions to make the
    request.
      The required access control list (ACL) to make a request is listed in each endpoint's reference.

    You can find your application ID and API key in the [Algolia
    dashboard](https://dashboard.algolia.com/account/api-keys).


    ## Request format


    Depending on the endpoint, request bodies are either JSON objects or arrays
    of JSON objects.


    ## Parameters


    Parameters are passed as query parameters for GET and DELETE requests,

    and in the request body for POST and PUT requests.


    Query parameters must be
    [URL-encoded](https://developer.mozilla.org/en-US/docs/Glossary/Percent-encoding).

    Non-ASCII characters must be UTF-8 encoded.

    Plus characters (`+`) are interpreted as spaces.

    Arrays as query parameters must be one of:


    - A comma-separated string: `attributesToRetrieve=title,description`

    - A URL-encoded JSON array:
    `attributesToRetrieve=%5B%22title%22,%22description%22%D`


    ## Response status and errors


    The Search API returns JSON responses.

    Since JSON doesn't guarantee any specific ordering, don't rely on the order
    of attributes in the API response.


    Successful responses return `2xx` statuses. Client errors return `4xx`
    statuses. Server errors return `5xx` statuses.

    Error responses have a `message` property with more information.


    ## Version


    The current version of the Search API is version 1, indicated by the `/1/`
    in each endpoint's URL.
  version: 1.0.0
servers:
  - url: https://{appId}.algolia.net
    variables:
      appId:
        default: ALGOLIA_APPLICATION_ID
  - url: https://{appId}-1.algolianet.com
    variables:
      appId:
        default: ALGOLIA_APPLICATION_ID
  - url: https://{appId}-2.algolianet.com
    variables:
      appId:
        default: ALGOLIA_APPLICATION_ID
  - url: https://{appId}-3.algolianet.com
    variables:
      appId:
        default: ALGOLIA_APPLICATION_ID
  - url: https://{appId}-dsn.algolia.net
    variables:
      appId:
        default: ALGOLIA_APPLICATION_ID
security:
  - appId: []
    apiKey: []
tags:
  - name: Advanced
    description: Query your logs.
  - name: Api Keys
    x-displayName: API keys
    description: >
      Manage your API keys.


      API requests must be authenticated with an API key.

      API keys can have permissions (access control lists, ACL) and
      restrictions.
    externalDocs:
      url: https://www.algolia.com/doc/guides/security/api-keys
      description: API keys.
  - name: Clusters
    description: |
      Multi-cluster operations.

      Multi-cluster operations are **deprecated**.
      If you have issues with your Algolia infrastructure
      due to large volumes of data, contact the Algolia support team.
  - name: Dictionaries
    description: >
      Manage your dictionaries.


      Customize language-specific settings, such as stop words, plurals, or word
      segmentation.


      Dictionaries are application-wide.
    externalDocs:
      url: >-
        https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp
      description: Natural languages.
  - name: Indices
    description: >
      Manage your indices and index settings.


      Indices are copies of your data that are stored on Algolia's servers.

      They're optimal data structures for fast search and are made up of records
      and settings.
    externalDocs:
      url: >-
        https://www.algolia.com/doc/guides/sending-and-managing-data/manage-indices-and-apps/manage-indices
      description: Manage your indices.
  - name: Records
    description: >
      Add, update, and delete records from your indices.


      Records are individual items in your index.

      When they match a search query, they're returned as search results, in the
      order determined by your ranking.

      Records are schemaless JSON objects.

      When adding or updating many records, check the [indexing rate
      limits](https://support.algolia.com/hc/articles/4406975251089-Is-there-a-rate-limit-for-indexing-on-Algolia).
    externalDocs:
      url: >-
        https://www.algolia.com/doc/guides/sending-and-managing-data/prepare-your-data
      description: Prepare your records.
  - name: Rules
    description: >
      Create, update, delete, and search for rules.


      Rules are _if-then_ statements that you can use to curate search results.

      Rules have _conditions_ that can trigger _consequences_.

      Consequences are changes to the search results, such as changing the order
      of search results or boosting a facet.

      This can be useful for tuning specific queries or for merchandising.
    externalDocs:
      url: https://www.algolia.com/doc/guides/managing-results/rules/rules-overview
      description: Index Rules.
  - name: Search
    description: Search one or more indices for matching records or facet values.
  - name: Synonyms
    description: |
      Create, update, delete, and search for synonyms.

      Synonyms are terms that the search engine should consider equal.
    externalDocs:
      url: >-
        https://www.algolia.com/doc/guides/managing-results/optimize-search-results/adding-synonyms
      description: Synonyms.
  - name: Vaults
    description: >-
      Algolia Vault lets you restrict access to your clusters to specific IP
      addresses and provides disk-level encryption at rest.
    externalDocs:
      url: https://www.algolia.com/doc/guides/security/algolia-vault
      description: Algolia Vault.
  - name: _model_index_settings
    x-displayName: Index settings
    description: |
      <SchemaDefinition schemaRef="#/components/schemas/indexSettings" />.
paths:
  /1/indexes/{indexName}/settings:
    get:
      tags:
        - Indices
      summary: Retrieve index settings
      description: Retrieves an object with non-null index settings.
      operationId: getSettings
      parameters:
        - $ref: '#/components/parameters/IndexName'
        - $ref: '#/components/parameters/getVersion'
      responses:
        '200':
          description: OK
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/settingsResponse'
        '400':
          $ref: '#/components/responses/BadRequest'
        '402':
          $ref: '#/components/responses/FeatureNotEnabled'
        '403':
          $ref: '#/components/responses/MethodNotAllowed'
        '404':
          $ref: '#/components/responses/IndexNotFound'
      x-codeSamples:
        - lang: csharp
          label: C#
          source: >-
            // Initialize the client

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


            // Call the API

            var response = await client.GetSettingsAsync("<YOUR_INDEX_NAME>",
            2);


            // print the response

            Console.WriteLine(response);
        - lang: dart
          label: Dart
          source: |-
            // Initialize the client
            final client =
                SearchClient(appId: 'ALGOLIA_APPLICATION_ID', apiKey: 'ALGOLIA_API_KEY');

            // Call the API
            final response = await client.getSettings(
              indexName: "<YOUR_INDEX_NAME>",
              getVersion: 2,
            );

            // print the response
            print(response);
        - lang: go
          label: Go
          source: >-
            // 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.GetSettings(client.NewApiGetSettingsRequest(
              "<YOUR_INDEX_NAME>").WithGetVersion(2))
            if err != nil {
              // handle the eventual error
              panic(err)
            }



            // print the response

            print(response)
        - lang: java
          label: Java
          source: >-
            // Initialize the client

            SearchClient client = new SearchClient("ALGOLIA_APPLICATION_ID",
            "ALGOLIA_API_KEY");


            // Call the API

            SettingsResponse response = client.getSettings("<YOUR_INDEX_NAME>",
            2);


            // print the response

            System.out.println(response);
        - lang: javascript
          label: JavaScript
          source: >-
            // Initialize the client

            const client = algoliasearch('ALGOLIA_APPLICATION_ID',
            'ALGOLIA_API_KEY');


            // Call the API

            const response = await client.getSettings({ indexName:
            'cts_e2e_settings', getVersion: 2 });



            // print the response

            console.log(response);
        - lang: kotlin
          label: Kotlin
          source: >-
            // Initialize the client

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


            // Call the API

            var response = client.getSettings(indexName = "<YOUR_INDEX_NAME>",
            getVersion = 2)



            // print the response

            println(response)
        - lang: php
          label: PHP
          source: >-
            // Initialize the client

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


            // Call the API

            $response = $client->getSettings(
                '<YOUR_INDEX_NAME>',
                2,
            );



            // print the response

            var_dump($response);
        - lang: python
          label: Python
          source: >-
            # 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.get_settings(
                index_name="<YOUR_INDEX_NAME>",
                get_version=2,
            )



            # print the response

            print(response)
        - lang: ruby
          label: Ruby
          source: >-
            # Initialize the client

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


            # Call the API

            response = client.get_settings("<YOUR_INDEX_NAME>", 2)



            # print the response

            puts(response)
        - lang: scala
          label: Scala
          source: >-
            // Initialize the client

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


            // Call the API

            val response = Await.result(
              client.getSettings(
                indexName = "<YOUR_INDEX_NAME>",
                getVersion = Some(2)
              ),
              Duration(100, "sec")
            )


            // print the response

            println(response)
        - lang: swift
          label: Swift
          source: >-
            // Initialize the client

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


            // Call the API

            let response = try await client.getSettings(indexName:
            "<YOUR_INDEX_NAME>", getVersion: 2)


            // print the response

            print(response)
        - lang: cURL
          label: curl
          source: |-
            curl --request GET \
              --url 'https://algolia_application_id.algolia.net/1/indexes/ALGOLIA_INDEX_NAME/settings?getVersion=1' \
              --header 'accept: application/json' \
              --header 'x-algolia-api-key: ALGOLIA_API_KEY' \
              --header 'x-algolia-application-id: ALGOLIA_APPLICATION_ID'
components:
  parameters:
    IndexName:
      name: indexName
      in: path
      description: Name of the index on which to perform the operation.
      required: true
      schema:
        type: string
        example: ALGOLIA_INDEX_NAME
    getVersion:
      name: getVersion
      description: >-
        When set to 2, the endpoint will not include `synonyms` in the response.
        This parameter is here for backward compatibility.
      in: query
      schema:
        type: integer
        default: 1
  schemas:
    settingsResponse:
      type: object
      properties:
        advancedSyntax:
          $ref: '#/components/schemas/advancedSyntax'
        advancedSyntaxFeatures:
          $ref: '#/components/schemas/IndexSettings_advancedSyntaxFeatures'
        allowCompressionOfIntegerArray:
          type: boolean
          description: >
            Whether arrays with exclusively non-negative integers should be
            compressed for better performance.

            If true, the compressed arrays may be reordered.
          default: false
          x-categories:
            - Performance
        allowTyposOnNumericTokens:
          $ref: '#/components/schemas/allowTyposOnNumericTokens'
        alternativesAsExact:
          $ref: '#/components/schemas/IndexSettings_alternativesAsExact'
        attributeCriteriaComputedByMinProximity:
          $ref: '#/components/schemas/attributeCriteriaComputedByMinProximity'
        attributeForDistinct:
          description: >
            Attribute that should be used to establish groups of results.

            Attribute names are case-sensitive.


            All records with the same value for this attribute are considered a
            group.

            You can combine `attributeForDistinct` with the `distinct` search
            parameter to control

            how many items per group are included in the search results.


            If you want to use the same attribute also for faceting, use the
            `afterDistinct` modifier of the `attributesForFaceting` setting.

            This applies faceting _after_ deduplication, which will result in
            accurate facet counts.
          example: url
          type: string
        attributesForFaceting:
          type: array
          items:
            type: string
          example:
            - author
            - filterOnly(isbn)
            - searchable(edition)
            - afterDistinct(category)
            - afterDistinct(searchable(publisher))
          description: >
            Attributes used for
            [faceting](https://www.algolia.com/doc/guides/managing-results/refine-results/faceting).


            Facets are attributes that let you categorize search results.

            They can be used for filtering search results.

            By default, no attribute is used for faceting.

            Attribute names are case-sensitive.


            **Modifiers**


            - `filterOnly("ATTRIBUTE")`.
              Allows the attribute to be used as a filter but doesn't evaluate the facet values.

            - `searchable("ATTRIBUTE")`.
              Allows searching for facet values.

            - `afterDistinct("ATTRIBUTE")`.
              Evaluates the facet count _after_ deduplication with `distinct`.
              This ensures accurate facet counts.
              You can apply this modifier to searchable facets: `afterDistinct(searchable(ATTRIBUTE))`.
          default: []
          x-categories:
            - Faceting
        attributesToHighlight:
          $ref: '#/components/schemas/attributesToHighlight'
        attributesToRetrieve:
          $ref: '#/components/schemas/attributesToRetrieve'
        attributesToSnippet:
          $ref: '#/components/schemas/attributesToSnippet'
        attributesToTransliterate:
          description: >
            Attributes, for which you want to support [Japanese
            transliteration](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/language-specific-configurations/#japanese-transliteration-and-type-ahead).


            Transliteration supports searching in any of the Japanese writing
            systems.

            To support transliteration, you must set the indexing language to
            Japanese.

            Attribute names are case-sensitive.
          type: array
          items:
            type: string
          example:
            - name
            - description
          x-categories:
            - Languages
        camelCaseAttributes:
          type: array
          items:
            type: string
          example:
            - description
          description: >
            Attributes for which to split [camel
            case](https://wikipedia.org/wiki/Camel_case) words.

            Attribute names are case-sensitive.
          default: []
          x-categories:
            - Languages
        customNormalization:
          description: >
            Characters and their normalized replacements.

            This overrides Algolia's default
            [normalization](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/normalization).
          type: object
          example:
            default:
              ä: ae
              ü: ue
          additionalProperties:
            type: object
            additionalProperties:
              type: string
          x-categories:
            - Languages
        customRanking:
          type: array
          items:
            type: string
          example:
            - desc(popularity)
            - asc(price)
          description: >
            Attributes to use as [custom
            ranking](https://www.algolia.com/doc/guides/managing-results/must-do/custom-ranking).

            Attribute names are case-sensitive.


            The custom ranking attributes decide which items are shown first if
            the other ranking criteria are equal.


            Records with missing values for your selected custom ranking
            attributes are always sorted last.

            Boolean attributes are sorted based on their alphabetical order.


            **Modifiers**


            - `asc("ATTRIBUTE")`.
              Sort the index by the values of an attribute, in ascending order.

            - `desc("ATTRIBUTE")`.
              Sort the index by the values of an attribute, in descending order.

            If you use two or more custom ranking attributes,

            [reduce the
            precision](https://www.algolia.com/doc/guides/managing-results/must-do/custom-ranking/how-to/controlling-custom-ranking-metrics-precision)
            of your first attributes,

            or the other attributes will never be applied.
          default: []
          x-categories:
            - Ranking
        decompoundedAttributes:
          type: object
          example:
            de:
              - name
          description: >
            Searchable attributes to which Algolia should apply [word
            segmentation](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/how-to/customize-segmentation)
            (decompounding).

            Attribute names are case-sensitive.


            Compound words are formed by combining two or more individual words,

            and are particularly prevalent in Germanic languages—for example,
            "firefighter".

            With decompounding, the individual components are indexed
            separately.


            You can specify different lists for different languages.

            Decompounding is supported for these languages:

            Dutch (`nl`), German (`de`), Finnish (`fi`), Danish (`da`), Swedish
            (`sv`), and Norwegian (`no`).

            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).
          default: {}
          x-categories:
            - Languages
        decompoundQuery:
          $ref: '#/components/schemas/decompoundQuery'
        disableExactOnAttributes:
          $ref: '#/components/schemas/disableExactOnAttributes'
        disablePrefixOnAttributes:
          type: array
          items:
            type: string
          example:
            - sku
          description: >
            Searchable attributes for which you want to turn off [prefix
            matching](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/override-search-engine-defaults/#adjusting-prefix-search).

            Attribute names are case-sensitive.
          default: []
          x-categories:
            - Query strategy
        disableTypoToleranceOnAttributes:
          $ref: '#/components/schemas/disableTypoToleranceOnAttributes'
        disableTypoToleranceOnWords:
          type: array
          items:
            type: string
          example:
            - wheel
            - 1X2BCD
          description: >
            Creates a list of [words which require exact
            matches](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/typo-tolerance/in-depth/configuring-typo-tolerance/#turn-off-typo-tolerance-for-certain-words).

            This also turns off [word splitting and
            concatenation](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/handling-natural-languages-nlp/in-depth/splitting-and-concatenation)
            for the specified words.
          default: []
          x-categories:
            - Typos
        distinct:
          $ref: '#/components/schemas/distinct'
        enablePersonalization:
          $ref: '#/components/schemas/enablePersonalization'
        enableReRanking:
          $ref: '#/components/schemas/enableReRanking'
        enableRules:
          $ref: '#/components/schemas/enableRules'
        exactOnSingleWordQuery:
          $ref: '#/components/schemas/exactOnSingleWordQuery'
        highlightPostTag:
          $ref: '#/components/schemas/highlightPostTag'
        highlightPreTag:
          $ref: '#/components/schemas/highlightPreTag'
        hitsPerPage:
          $ref: '#/components/schemas/hitsPerPage'
        ignorePlurals:
          $ref: '#/components/schemas/ignorePlurals'
        indexLanguages:
          type: array
          items:
            $ref: '#/components/schemas/supportedLanguage'
          example:
            - ja
          description: >
            Languages for language-specific processing steps, such as word
            detection and dictionary settings.


            **Always specify an indexing 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).
          default: []
          x-categories:
            - Languages
        keepDiacriticsOnCharacters:
          type: string
          example: øé
          description: |
            Characters for which diacritics should be preserved.

            By default, Algolia removes diacritics from letters.
            For example, `é` becomes `e`. If this causes issues in your search,
            you can specify characters that should keep their diacritics.
          default: ''
          x-categories:
            - Languages
        maxFacetHits:
          $ref: '#/components/schemas/maxFacetHits'
        maxValuesPerFacet:
          $ref: '#/components/schemas/maxValuesPerFacet'
        minProximity:
          $ref: '#/components/schemas/minProximity'
        minWordSizefor1Typo:
          $ref: '#/components/schemas/minWordSizefor1Typo'
        minWordSizefor2Typos:
          $ref: '#/components/schemas/minWordSizefor2Typos'
        mode:
          $ref: '#/components/schemas/mode'
        numericAttributesForFiltering:
          type: array
          items:
            type: string
          description: >
            Numeric attributes that can be used as [numerical
            filters](https://www.algolia.com/doc/guides/managing-results/rules/detecting-intent/how-to/applying-a-custom-filter-for-a-specific-query/#numerical-filters).

            Attribute names are case-sensitive.


            By default, all numeric attributes are available as numerical
            filters.

            For faster indexing, reduce the number of numeric attributes.


            To turn off filtering for all numeric attributes, specify an
            attribute that doesn't exist in your index, such as
            `NO_NUMERIC_FILTERING`.


            **Modifier**


            - `equalOnly("ATTRIBUTE")`.
              Support only filtering based on equality comparisons `=` and `!=`.
          example:
            - equalOnly(quantity)
            - popularity
          default: []
          x-categories:
            - Performance
        optionalWords:
          $ref: '#/components/schemas/optionalWords'
        paginationLimitedTo:
          type: integer
          example: 100
          description: >
            Maximum number of search results that can be obtained through
            pagination.


            Higher pagination limits might slow down your search.

            For pagination limits above 1,000, the sorting of results beyond the
            1,000th hit can't be guaranteed.
          default: 1000
          maximum: 20000
        primary:
          type: string
          description: >
            Replica indices only: the name of the primary index for this
            replica.
        queryLanguages:
          $ref: '#/components/schemas/queryLanguages'
        queryType:
          $ref: '#/components/schemas/queryType'
        ranking:
          type: array
          items:
            type: string
          description: >
            Determines the order in which Algolia returns your results.


            By default, each entry corresponds to a [ranking
            criteria](https://www.algolia.com/doc/guides/managing-results/relevance-overview/in-depth/ranking-criteria).

            The tie-breaking algorithm sequentially applies each criterion in
            the order they're specified.

            If you configure a replica index for [sorting by an
            attribute](https://www.algolia.com/doc/guides/managing-results/refine-results/sorting/how-to/sort-by-attribute),

            you put the sorting attribute at the top of the list.


            **Modifiers**


            - `asc("ATTRIBUTE")`.
              Sort the index by the values of an attribute, in ascending order.
            - `desc("ATTRIBUTE")`.
              Sort the index by the values of an attribute, in descending order.

            Before you modify the default setting,

            test your changes in the dashboard,

            and by [A/B
            testing](https://www.algolia.com/doc/guides/ab-testing/what-is-ab-testing).
          default:
            - typo
            - geo
            - words
            - filters
            - proximity
            - attribute
            - exact
            - custom
          x-categories:
            - Ranking
        relevancyStrictness:
          $ref: '#/components/schemas/relevancyStrictness'
        removeStopWords:
          $ref: '#/components/schemas/removeStopWords'
        removeWordsIfNoResults:
          $ref: '#/components/schemas/removeWordsIfNoResults'
        renderingContent:
          $ref: '#/components/schemas/renderingContent'
        replaceSynonymsInHighlight:
          $ref: '#/components/schemas/replaceSynonymsInHighlight'
        replicas:
          type: array
          items:
            type: string
          example:
            - virtual(prod_products_price_asc)
            - dev_products_replica
          description: >
            Creates [replica
            indices](https://www.algolia.com/doc/guides/managing-results/refine-results/sorting/in-depth/replicas).


            Replicas are copies of a primary index with the same records but
            different settings, synonyms, or rules.

            If you want to offer a different ranking or sorting of your search
            results, you'll use replica indices.

            All index operations on a primary index are automatically forwarded
            to its replicas.

            To add a replica index, you must provide the complete set of
            replicas to this parameter.

            If you omit a replica from this list, the replica turns into a
            regular, standalone index that will no longer be synced with the
            primary index.


            **Modifier**


            - `virtual("REPLICA")`.
              Create a virtual replica,
              Virtual replicas don't increase the number of records and are optimized for [Relevant sorting](https://www.algolia.com/doc/guides/managing-results/refine-results/sorting/in-depth/relevant-sort).
          default: []
          x-categories:
            - Ranking
        reRankingApplyFilter:
          oneOf:
            - $ref: '#/components/schemas/reRankingApplyFilter'
            - type: 'null'
        responseFields:
          $ref: '#/components/schemas/responseFields'
        restrictHighlightAndSnippetArrays:
          $ref: '#/components/schemas/restrictHighlightAndSnippetArrays'
        searchableAttributes:
          type: array
          items:
            type: string
          example:
            - title,alternative_title
            - author
            - unordered(text)
            - emails.personal
          description: >
            Attributes used for searching. Attribute names are case-sensitive.


            By default, all attributes are searchable and the
            [Attribute](https://www.algolia.com/doc/guides/managing-results/relevance-overview/in-depth/ranking-criteria/#attribute)
            ranking criterion is turned off.

            With a non-empty list, Algolia only returns results with matches in
            the selected attributes.

            In addition, the Attribute ranking criterion is turned on: matches
            in attributes that are higher in the list of `searchableAttributes`
            rank first.

            To make matches in two attributes rank equally, include them in a
            comma-separated string, such as `"title,alternate_title"`.

            Attributes with the same priority are always unordered.


            For more information, see [Searchable
            attributes](https://www.algolia.com/doc/guides/sending-and-managing-data/prepare-your-data/how-to/setting-searchable-attributes).


            **Modifier**


            - `unordered("ATTRIBUTE")`.
              Ignore the position of a match within the attribute.

            Without a modifier, matches at the beginning of an attribute rank
            higher than matches at the end.
          default: []
          x-categories:
            - Attributes
        semanticSearch:
          $ref: '#/components/schemas/semanticSearch'
        separatorsToIndex:
          type: string
          example: +#
          description: >
            Control which non-alphanumeric characters are indexed.


            By default, Algolia ignores [non-alphanumeric
            characters](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/typo-tolerance/how-to/how-to-search-in-hyphenated-attributes/#handling-non-alphanumeric-characters)
            like hyphen (`-`), plus (`+`), and parentheses (`(`,`)`).

            To include such characters, define them with `separatorsToIndex`.


            Separators are all non-letter characters except spaces and currency
            characters, such as $€£¥.


            With `separatorsToIndex`, Algolia treats separator characters as
            separate words.

            For example, in a search for "Disney+", Algolia considers "Disney"
            and "+" as two separate words.
          default: ''
          x-categories:
            - Typos
        snippetEllipsisText:
          $ref: '#/components/schemas/snippetEllipsisText'
        sortFacetValuesBy:
          $ref: '#/components/schemas/sortFacetValuesBy'
        typoTolerance:
          $ref: '#/components/schemas/typoTolerance'
        unretrievableAttributes:
          type: array
          items:
            type: string
          example:
            - total_sales
          description: >
            Attributes that can't be retrieved at query time.


            This can be useful if you want to use an attribute for ranking or to
            [restrict
            access](https://www.algolia.com/doc/guides/security/api-keys/how-to/user-restricted-access-to-data),

            but don't want to include it in the search results.

            Attribute names are case-sensitive.
          default: []
          x-categories:
            - Attributes
        userData:
          $ref: '#/components/schemas/userData'
      additionalProperties: false
      description: Index settings.
    advancedSyntax:
      type: boolean
      description: >
        Whether to support phrase matching and excluding words from search
        queries

        Use the `advancedSyntaxFeatures` parameter to control which feature is
        supported.
      default: false
      x-categories:
        - Query strategy
    IndexSettings_advancedSyntaxFeatures:
      type: array
      items:
        $ref: '#/components/schemas/advancedSyntaxFeatures'
      description: |
        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.
      default:
        - exactPhrase
        - excludeWords
      x-categories:
        - Query strategy
    allowTyposOnNumericTokens:
      type: boolean
      description: |
        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.
      default: true
      x-categories:
        - Typos
    IndexSettings_alternativesAsExact:
      type: array
      items:
        $ref: '#/components/schemas/alternativesAsExact'
      description: >
        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.
      default:
        - ignorePlurals
        - singleWordSynonym
      x-categories:
        - Query strategy
    attributeCriteriaComputedByMinProximity:
      type: boolean
      description: >
        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.
      default: false
      x-categories:
        - Advanced
    attributesToHighlight:
      type: array
      items:
        type: string
      example:
        - author
        - title
        - conten
        - content
      description: >
        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).
      x-categories:
        - Highlighting and Snippeting
    attributesToRetrieve:
      type: array
      items:
        type: string
      example:
        - author
        - title
        - content
      description: >
        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.
      default:
        - '*'
      x-categories:
        - Attributes
    attributesToSnippet:
      type: array
      items:
        type: string
      example:
        - content:80
        - description
      description: >
        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.
      default: []
      x-categories:
        - Highlighting and Snippeting
    decompoundQuery:
      type: boolean
      description: >
        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).
      default: true
      x-categories:
        - Languages
    disableExactOnAttributes:
      type: array
      items:
        type: string
      example:
        - description
      description: >
        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.
      default: []
      x-categories:
        - Query strategy
    disableTypoToleranceOnAttributes:
      type: array
      items:
        type: string
      example:
        - sku
      description: >
        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.
      default: []
      x-categories:
        - Typos
    distinct:
      description: >
        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.
      example: 1
      oneOf:
        - type: boolean
          description: >-
            Whether deduplication is turned on. If true, only one member of a
            group is shown in the search results.
        - type: integer
          description: >
            Number of members of a group of records to include in the search
            results.


            - Don't use `distinct > 1` for records that might be [promoted by
            rules](https://www.algolia.com/doc/guides/managing-results/rules/merchandising-and-promoting/how-to/promote-hits).
              The number of hits won't be correct and faceting won't work as expected.
            - With `distinct > 1`, the `hitsPerPage` parameter controls the
            number of returned groups.
              For example, with `hitsPerPage: 10` and `distinct: 2`, up to 20 records are returned.
              Likewise, the `nbHits` response attribute contains the number of returned groups.
          minimum: 0
          maximum: 4
          default: 0
      x-categories:
        - Advanced
    enablePersonalization:
      type: boolean
      description: Whether to enable Personalization.
      default: false
      x-categories:
        - Personalization
    enableReRanking:
      type: boolean
      description: >
        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.
      default: true
      x-categories:
        - Filtering
    enableRules:
      type: boolean
      description: Whether to enable rules.
      default: true
      x-categories:
        - Rules
    exactOnSingleWordQuery:
      type: string
      enum:
        - attribute
        - none
        - word
      description: >
        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.
      default: attribute
      x-categories:
        - Query strategy
    highlightPostTag:
      type: string
      description: >-
        HTML tag to insert after the highlighted parts in all highlighted
        results and snippets.
      default: </em>
      x-categories:
        - Highlighting and Snippeting
    highlightPreTag:
      type: string
      description: >-
        HTML tag to insert before the highlighted parts in all highlighted
        results and snippets.
      default: <em>
      x-categories:
        - Highlighting and Snippeting
    hitsPerPage:
      type: integer
      description: Number of hits per page.
      default: 20
      minimum: 1
      maximum: 1000
      x-categories:
        - Pagination
    ignorePlurals:
      description: |
        Treat singular, plurals, and other forms of declensions as equivalent.
        Only use this feature for the languages used in your index.
      example:
        - ca
        - es
      oneOf:
        - type: array
          description: |
            ISO code for languages for which this feature should be active.
            This overrides languages you set with `queryLanguages`.
          items:
            $ref: '#/components/schemas/supportedLanguage'
        - $ref: '#/components/schemas/booleanString'
        - type: boolean
          description: >
            If true, `ignorePlurals` is active for all languages included in
            `queryLanguages`, or for all supported languages, if `queryLanguges`
            is empty.

            If false, singulars, plurals, and other declensions won't be
            considered equivalent.
          default: false
      x-categories:
        - Languages
    supportedLanguage:
      type: string
      description: ISO code for a supported language.
      enum:
        - 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
    maxFacetHits:
      type: integer
      description: >-
        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).
      maximum: 100
      default: 10
      x-categories:
        - Advanced
    maxValuesPerFacet:
      type: integer
      description: Maximum number of facet values to return for each facet.
      default: 100
      maximum: 1000
      x-categories:
        - Faceting
    minProximity:
      type: integer
      minimum: 1
      maximum: 7
      description: >
        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.
      default: 1
      x-categories:
        - Advanced
    minWordSizefor1Typo:
      type: integer
      description: >-
        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).
      default: 4
      x-categories:
        - Typos
    minWordSizefor2Typos:
      type: integer
      description: >-
        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).
      default: 8
      x-categories:
        - Typos
    mode:
      type: string
      enum:
        - neuralSearch
        - keywordSearch
      description: >
        Search mode the index will use to query for results.


        This setting only applies to indices, for which Algolia enabled
        NeuralSearch for you.
      default: keywordSearch
      x-categories:
        - Query strategy
    optionalWords:
      description: >
        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 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
        optional,

        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 fewer 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 2,000 need 2 matched words.
        - If `optionalWords` has 10 or more words, the required number of
        matched words increases by the number of optional words divided by 5
        (rounded down).
          Example: with 18 optional words, results 1 to 1,000 require 1 matched word; results 1,001 to 2,000 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).
      oneOf:
        - type: string
        - type: 'null'
        - $ref: '#/components/schemas/optionalWordsArray'
    queryLanguages:
      type: array
      items:
        $ref: '#/components/schemas/supportedLanguage'
      example:
        - es
      description: >
        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, place the CJK language **first**.

        **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).
      default: []
      x-categories:
        - Languages
    queryType:
      type: string
      enum:
        - prefixLast
        - prefixAll
        - prefixNone
      description: >
        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).
      default: prefixLast
      x-categories:
        - Query strategy
    relevancyStrictness:
      type: integer
      example: 90
      description: >
        Relevancy threshold below which less relevant results aren't included in
        the results

        You can only set `relevancyStrictness` on [virtual replica
        indices](https://www.algolia.com/doc/guides/managing-results/refine-results/sorting/in-depth/replicas/#what-are-virtual-replicas).

        Use this setting to strike a balance between the relevance and number of
        returned results.
      default: 100
      x-categories:
        - Ranking
    removeStopWords:
      description: >
        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.


        Only use this feature for the languages used in your index.
      example:
        - ca
        - es
      oneOf:
        - type: array
          description: >-
            ISO code for languages for which stop words should be removed. This
            overrides languages you set in `queryLanguges`.
          items:
            $ref: '#/components/schemas/supportedLanguage'
        - type: boolean
          default: false
          description: >
            If true, stop words are removed for all languages you included in
            `queryLanguages`, or for all supported languages, if
            `queryLanguages` is empty.

            If false, stop words are not removed.
      x-categories:
        - Languages
    removeWordsIfNoResults:
      type: string
      enum:
        - none
        - lastWords
        - firstWords
        - allOptional
      example: firstWords
      description: >
        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).
      default: none
      x-categories:
        - Query strategy
    renderingContent:
      description: >
        Extra data that can be used in the search UI.


        You can use this to control aspects of your search UI, such as the order
        of facet names and values

        without changing your frontend code.
      type: object
      additionalProperties: false
      properties:
        facetOrdering:
          $ref: '#/components/schemas/facetOrdering'
        redirect:
          $ref: '#/components/schemas/redirectURL'
        widgets:
          $ref: '#/components/schemas/widgets'
      x-categories:
        - Advanced
    replaceSynonymsInHighlight:
      type: boolean
      description: >
        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.
      default: false
      x-categories:
        - Highlighting and Snippeting
    reRankingApplyFilter:
      description: >
        Restrict [Dynamic
        Re-Ranking](https://www.algolia.com/doc/guides/algolia-ai/re-ranking) to
        records that match these filters.
      oneOf:
        - type: array
          items:
            $ref: '#/components/schemas/reRankingApplyFilter'
        - type: string
          x-categories:
            - Filtering
    responseFields:
      type: array
      items:
        type: string
      description: >
        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.
      default:
        - '*'
      x-categories:
        - Advanced
    restrictHighlightAndSnippetArrays:
      type: boolean
      description: >
        Whether to restrict highlighting and snippeting to items that at least
        partially matched the search query.

        By default, all items are highlighted and snippeted.
      default: false
      x-categories:
        - Highlighting and Snippeting
    semanticSearch:
      type: object
      description: |
        Settings for the semantic search part of NeuralSearch.
        Only used when `mode` is `neuralSearch`.
      properties:
        eventSources:
          oneOf:
            - type: array
              description: |
                Indices from which to collect click and conversion events.

                If null, the current index and all its replicas are used.
              items:
                type: string
            - type: 'null'
    snippetEllipsisText:
      type: string
      description: String used as an ellipsis indicator when a snippet is truncated.
      default: …
      x-categories:
        - Highlighting and Snippeting
    sortFacetValuesBy:
      type: string
      description: >
        Order in which to retrieve facet values

        - `count`.
          Facet values are retrieved by decreasing count.
          The count is the number of matching records containing this facet value
        - `alpha`.
          Retrieve facet values alphabetically
        This setting doesn't influence how facet values are displayed in your UI
        (see `renderingContent`).

        For more information, see [facet value
        display](https://www.algolia.com/doc/guides/building-search-ui/ui-and-ux-patterns/facet-display/js).
      default: count
      x-categories:
        - Faceting
    typoTolerance:
      description: >
        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.
      oneOf:
        - type: boolean
          default: true
          description: >-
            Whether typo tolerance is active. If true, matches with typos are
            included in the search results and rank after exact matches.
        - $ref: '#/components/schemas/typoToleranceEnum'
      x-categories:
        - Typos
    userData:
      example:
        settingID: f2a7b51e3503acc6a39b3784ffb84300
        pluginVersion: 1.6.0
      description: |
        An object with custom data.

        You can store up to 32kB as custom data.
      default: {}
      x-categories:
        - Advanced
    ErrorBase:
      description: Error.
      type: object
      x-keep-model: true
      additionalProperties: true
      properties:
        message:
          type: string
          example: Invalid Application-Id or API-Key
    advancedSyntaxFeatures:
      type: string
      enum:
        - exactPhrase
        - excludeWords
      x-categories:
        - Query strategy
    alternativesAsExact:
      type: string
      enum:
        - ignorePlurals
        - singleWordSynonym
        - multiWordsSynonym
        - ignoreConjugations
      x-categories:
        - Query strategy
    booleanString:
      type: string
      enum:
        - 'true'
        - 'false'
    optionalWordsArray:
      type: array
      items:
        type: string
      example:
        - blue
        - iphone case
      description: >-
        List of [optional
        words](https://www.algolia.com/doc/guides/managing-results/optimize-search-results/empty-or-insufficient-results/#creating-a-list-of-optional-words).
      default: []
      x-categories:
        - Query strategy
    facetOrdering:
      description: Order of facet names and facet values in your UI.
      type: object
      additionalProperties: false
      properties:
        facets:
          $ref: '#/components/schemas/facets'
        values:
          $ref: '#/components/schemas/values'
    redirectURL:
      description: The redirect rule container.
      type: object
      additionalProperties: false
      properties:
        url:
          type: string
    widgets:
      description: Widgets returned from any rules that are applied to the current search.
      type: object
      additionalProperties: false
      properties:
        banners:
          $ref: '#/components/schemas/banners'
    typoToleranceEnum:
      type: string
      title: typo tolerance
      description: |
        - `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.
      enum:
        - min
        - strict
        - 'true'
        - 'false'
    facets:
      description: Order of facet names.
      type: object
      additionalProperties: false
      properties:
        order:
          $ref: '#/components/schemas/order'
    values:
      description: Order of facet values. One object for each facet.
      type: object
      additionalProperties:
        $ref: '#/components/schemas/value'
        x-additionalPropertiesName: facet
    banners:
      description: Banners defined in the Merchandising Studio for a given search.
      type: array
      items:
        $ref: '#/components/schemas/banner'
    order:
      description: >
        Explicit order of facets or facet values.


        This setting lets you always show specific facets or facet values at the
        top of the list.
      type: array
      items:
        type: string
    value:
      type: object
      additionalProperties: false
      properties:
        hide:
          $ref: '#/components/schemas/hide'
        order:
          $ref: '#/components/schemas/order'
        sortRemainingBy:
          $ref: '#/components/schemas/sortRemainingBy'
    banner:
      description: Banner with image and link to redirect users.
      type: object
      additionalProperties: false
      properties:
        image:
          $ref: '#/components/schemas/bannerImage'
        link:
          $ref: '#/components/schemas/bannerLink'
    hide:
      description: Hide facet values.
      type: array
      items:
        type: string
    sortRemainingBy:
      description: >
        Order of facet values that aren't explicitly positioned with the `order`
        setting.


        - `count`.
          Order remaining facet values by decreasing count.
          The count is the number of matching records containing this facet value.

        - `alpha`.
          Sort facet values alphabetically.

        - `hidden`.
          Don't show facet values that aren't explicitly positioned.
      type: string
      enum:
        - count
        - alpha
        - hidden
    bannerImage:
      description: Image to show inside a banner.
      type: object
      additionalProperties: false
      properties:
        title:
          type: string
        urls:
          type: array
          items:
            $ref: '#/components/schemas/bannerImageUrl'
    bannerLink:
      description: Link for a banner defined in the Merchandising Studio.
      type: object
      additionalProperties: false
      properties:
        url:
          type: string
    bannerImageUrl:
      description: URL for an image to show inside a banner.
      type: object
      additionalProperties: false
      properties:
        url:
          type: string
  responses:
    BadRequest:
      description: Bad request or request arguments.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorBase'
    FeatureNotEnabled:
      description: This feature is not enabled on your Algolia account.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorBase'
    MethodNotAllowed:
      description: Method not allowed with this API key.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorBase'
    IndexNotFound:
      description: Index not found.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/ErrorBase'
  securitySchemes:
    appId:
      type: apiKey
      in: header
      name: x-algolia-application-id
      description: Your Algolia application ID.
    apiKey:
      type: apiKey
      in: header
      name: x-algolia-api-key
      description: >
        Your Algolia API key with the necessary permissions to make the request.

        Permissions are controlled through access control lists (ACL) and access
        restrictions.

        The required ACL to make a request is listed in each endpoint's
        reference.

````